Changeset 933f32f for src

Timestamp:

May 24, 2019, 10:19:41 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

d908563

Parents:

6a9d4b4 (diff), 292642a (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 cleanup-dtors

Location:

src

Files:

• AST/Attribute.cpp (added)
• AST/Attribute.hpp (added)
• AST/Bitfield.hpp (added)
• AST/CVQualifiers.hpp (added)
• AST/Convert.cpp (added)
• AST/Convert.hpp (added)
• AST/Decl.cpp (added)
• AST/Decl.hpp (added)
• AST/DeclReplacer.cpp (added)
• AST/DeclReplacer.hpp (added)
• AST/Expr.cpp (added)
• AST/Expr.hpp (added)
• AST/FunctionSpec.hpp (added)
• AST/Fwd.hpp (added)
• AST/Init.cpp (added)
• AST/Init.hpp (added)
• AST/Label.hpp (added)
• AST/LinkageSpec.cpp (added)
• AST/LinkageSpec.hpp (added)
• AST/Node.cpp (added)
• AST/Node.hpp (added)
• AST/ParseNode.hpp (added)
• AST/Pass.hpp (added)
• AST/Pass.impl.hpp (added)
• AST/Pass.proto.hpp (added)
• AST/Stmt.cpp (added)
• AST/Stmt.hpp (added)
• AST/StorageClasses.hpp (added)
• AST/Type.cpp (added)
• AST/Type.hpp (added)
• AST/TypeSubstitution.cpp (added)
• AST/TypeSubstitution.hpp (added)
• AST/TypeVar.hpp (added)
• AST/Visitor.hpp (added)
• AST/module.mk (added)
• AST/porting.md (added)
• BasicTypes-gen.cc (added)
• CodeGen/CodeGenerator.cc (modified) (37 diffs)
• CodeGen/CodeGenerator.h (modified) (4 diffs)
• CodeGen/GenType.cc (modified) (19 diffs)
• CodeGen/GenType.h (modified) (2 diffs)
• CodeGen/Options.h (added)
• CodeGen/module.mk (modified) (1 diff)
• Common/Assert.cc (modified) (1 diff)
• Common/Heap.cc (deleted)
• Common/PassVisitor.cc (added)
• Common/PassVisitor.h (modified) (6 diffs)
• Common/PassVisitor.impl.h (modified) (16 diffs)
• Common/PassVisitor.proto.h (modified) (3 diffs)
• Common/PersistentMap.h (added)
• Common/SemanticError.h (modified) (1 diff)
• Common/Stats.h (added)
• Common/Stats/Base.h (added)
• Common/Stats/Counter.cc (added)
• Common/Stats/Counter.h (added)
• Common/Stats/Heap.cc (added)
• Common/Stats/Heap.h (moved) (moved from src/Common/Heap.h ) (1 diff)
• Common/Stats/Stats.cc (added)
• Common/Stats/Time.cc (added)
• Common/Stats/Time.h (added)
• Common/module.mk (modified) (1 diff)
• Common/utility.h (modified) (1 diff)
• CompilationState.cc (modified) (2 diffs)
• CompilationState.h (modified) (2 diffs)
• Concurrency/Waitfor.cc (modified) (1 diff)
• Concurrency/module.mk (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (3 diffs)
• ControlStruct/ForExprMutator.cc (modified) (4 diffs)
• ControlStruct/LabelFixer.cc (modified) (7 diffs)
• ControlStruct/LabelGenerator.cc (modified) (3 diffs)
• ControlStruct/module.mk (modified) (1 diff)
• GenPoly/Box.cc (modified) (2 diffs)
• GenPoly/GenPoly.cc (modified) (2 diffs)
• GenPoly/GenPoly.h (modified) (1 diff)
• GenPoly/InstantiateGeneric.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (3 diffs)
• GenPoly/module.mk (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (5 diffs)
• InitTweak/InitTweak.h (modified) (2 diffs)
• InitTweak/module.mk (modified) (1 diff)
• MakeLibCfa.cc (modified) (2 diffs)
• Makefile.am (modified) (4 diffs)
• Makefile.in (modified) (22 diffs)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/ExpressionNode.cc (modified) (6 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• Parser/TypeData.cc (modified) (3 diffs)
• Parser/TypeData.h (modified) (5 diffs)
• Parser/lex.ll (modified) (7 diffs)
• Parser/module.mk (modified) (1 diff)
• Parser/parser.yy (modified) (19 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/CommonType.cc (modified) (4 diffs)
• ResolvExpr/ConversionCost.cc (modified) (8 diffs)
• ResolvExpr/Cost.h (modified) (14 diffs)
• ResolvExpr/RenameVars.cc (modified) (4 diffs)
• ResolvExpr/ResolveAssertions.cc (modified) (14 diffs)
• ResolvExpr/ResolveAssertions.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (27 diffs)
• ResolvExpr/Resolver.h (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (4 diffs)
• ResolvExpr/TypeEnvironment.h (modified) (4 diffs)
• ResolvExpr/Unify.cc (modified) (4 diffs)
• ResolvExpr/module.mk (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (3 diffs)
• SymTab/Indexer.cc (modified) (10 diffs)
• SymTab/Indexer.h (modified) (5 diffs)
• SymTab/Mangler.cc (modified) (5 diffs)
• SymTab/Mangler.h (modified) (1 diff)
• SymTab/ManglerCommon.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (2 diffs)
• SymTab/module.mk (modified) (1 diff)
• SynTree/AddressExpr.cc (modified) (2 diffs)
• SynTree/Attribute.cc (modified) (1 diff)
• SynTree/BaseSyntaxNode.h (modified) (2 diffs)
• SynTree/BasicType.cc (modified) (3 diffs)
• SynTree/Constant.cc (modified) (2 diffs)
• SynTree/Declaration.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (8 diffs)
• SynTree/Expression.cc (modified) (48 diffs)
• SynTree/Expression.h (modified) (2 diffs)
• SynTree/Label.h (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/Statement.h (modified) (23 diffs)
• SynTree/SynTree.h (modified) (3 diffs)
• SynTree/Type.cc (modified) (3 diffs)
• SynTree/Type.h (modified) (3 diffs)
• SynTree/TypeSubstitution.cc (modified) (3 diffs)
• SynTree/TypeSubstitution.h (modified) (11 diffs)
• SynTree/Visitor.h (modified) (1 diff)
• SynTree/module.mk (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (4 diffs)
• Tuples/Tuples.h (modified) (3 diffs)
• Tuples/module.mk (modified) (1 diff)
• Validate/module.mk (modified) (1 diff)
• config.h.in (modified) (7 diffs)
• include/cassert (modified) (1 diff)
• main.cc (modified) (22 diffs)

src/CodeGen/CodeGenerator.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 : Sat May  5 09:08:32 2018
-// Update Count     : 494
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:47:00 2019
+// Update Count     : 497
 //
 #include "CodeGenerator.h"
@@ -83 +83 @@
         void CodeGenerator::updateLocation( CodeLocation const & to ) {
                 // skip if linemarks shouldn't appear or if codelocation is unset
-                if ( !lineMarks || to.isUnset() ) return;
+                if ( !options.lineMarks || to.isUnset() ) return;
 
                 if ( currentLocation.followedBy( to, 0 ) ) {
@@ -116 +116 @@
         }
 
-        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), printExprTypes( printExprTypes ), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), options( pretty, genC, lineMarks, printExprTypes ), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, const Options &options ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), options(options), endl( *this ) {}
 
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {
                 // GCC builtins should always be printed unmangled
-                if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name;
+                if ( options.pretty || decl->linkage.is_gcc_builtin ) return decl->name;
                 if ( decl->mangleName != "" ) {
                         // need to incorporate scope level in order to differentiate names for destructors
@@ -164 +165 @@
                 previsit( (BaseSyntaxNode *)node );
                 GuardAction( [this, node](){
-                        if ( printExprTypes && node->result ) {
-                                output << " /* " << genType( node->result, "", pretty, genC ) << " */ ";
+                        if ( options.printExprTypes && node->result ) {
+                                output << " /* " << genType( node->result, "", options ) << " */ ";
                         }
                 } );
@@ -173 +174 @@
         void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
                 // deleted decls should never be used, so don't print them
-                if ( functionDecl->isDeleted && genC ) return;
+                if ( functionDecl->isDeleted && options.genC ) return;
                 extension( functionDecl );
                 genAttributes( functionDecl->get_attributes() );
@@ -180 +181 @@
                 functionDecl->get_funcSpec().print( output );
 
-                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty, genC );
+                Options subOptions = options;
+                subOptions.anonymousUnused = functionDecl->has_body();
+                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), subOptions );
 
                 asmName( functionDecl );
@@ -194 +197 @@
         void CodeGenerator::postvisit( ObjectDecl * objectDecl ) {
                 // deleted decls should never be used, so don't print them
-                if ( objectDecl->isDeleted && genC ) return;
-                if (objectDecl->get_name().empty() && genC ) {
+                if ( objectDecl->isDeleted && options.genC ) return;
+                if (objectDecl->get_name().empty() && options.genC ) {
                         // only generate an anonymous name when generating C code, otherwise it clutters the output too much
                         static UniqueName name = { "__anonymous_object" };
                         objectDecl->set_name( name.newName() );
+            // Stops unused parameter warnings.
+            if ( options.anonymousUnused ) {
+                objectDecl->attributes.push_back( new Attribute( "unused" ) );
+            }
                 }
 
@@ -205 +212 @@
 
                 handleStorageClass( objectDecl );
-                output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty, genC );
+                output << genType( objectDecl->get_type(), mangleName( objectDecl ), options.pretty, options.genC );
 
                 asmName( objectDecl );
@@ -224 +231 @@
 
         void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
-                if( ! aggDecl->parameters.empty() && ! genC ) {
+                if( ! aggDecl->parameters.empty() && ! options.genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         output << "forall(";
@@ -294 +301 @@
 
         void CodeGenerator::postvisit( TraitDecl * traitDecl ) {
-                assertf( ! genC, "TraitDecls should not reach code generation." );
+                assertf( ! options.genC, "TraitDecls should not reach code generation." );
                 extension( traitDecl );
                 handleAggregate( traitDecl, "trait " );
@@ -300 +307 @@
 
         void CodeGenerator::postvisit( TypedefDecl * typeDecl ) {
-                assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
+                assertf( ! options.genC, "Typedefs are removed and substituted in earlier passes." );
                 output << "typedef ";
-                output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
+                output << genType( typeDecl->get_base(), typeDecl->get_name(), options ) << endl;
         }
 
         void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
-                assertf( ! genC, "TypeDecls should not reach code generation." );
+                assertf( ! options.genC, "TypeDecls should not reach code generation." );
                 output << typeDecl->genTypeString() << " " << typeDecl->name;
                 if ( typeDecl->sized ) {
@@ -371 +378 @@
 
         void CodeGenerator::postvisit( ConstructorInit * init ){
-                assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
+                assertf( ! options.genC, "ConstructorInit nodes should not reach code generation." );
                 // pseudo-output for constructor/destructor pairs
                 output << "<ctorinit>{" << endl << ++indent << "ctor: ";
@@ -507 +514 @@
                                         } else {
                                                 // no constructors with 0 or more than 2 parameters
-                                                assertf( ! genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
+                                                assertf( ! options.genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
                                                 output << "(";
                                                 (*arg++)->accept( *visitor );
@@ -604 +611 @@
                         // an lvalue cast, this has been taken out.
                         output << "(";
-                        output << genType( castExpr->get_result(), "", pretty, genC );
+                        output << genType( castExpr->get_result(), "", options );
                         output << ")";
                 } // if
@@ -612 +619 @@
 
         void CodeGenerator::postvisit( KeywordCastExpr * castExpr ) {
-                assertf( ! genC, "KeywordCast should not reach code generation." );
+                assertf( ! options.genC, "KeywordCast should not reach code generation." );
                 extension( castExpr );
                 output << "((" << castExpr->targetString() << " &)";
@@ -620 +627 @@
 
         void CodeGenerator::postvisit( VirtualCastExpr * castExpr ) {
-                assertf( ! genC, "VirtualCastExpr should not reach code generation." );
+                assertf( ! options.genC, "VirtualCastExpr should not reach code generation." );
                 extension( castExpr );
                 output << "(virtual ";
@@ -628 +635 @@
 
         void CodeGenerator::postvisit( UntypedMemberExpr * memberExpr ) {
-                assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
+                assertf( ! options.genC, "UntypedMemberExpr should not reach code generation." );
                 extension( memberExpr );
                 memberExpr->get_aggregate()->accept( *visitor );
@@ -661 +668 @@
                 output << "sizeof(";
                 if ( sizeofExpr->get_isType() ) {
-                        output << genType( sizeofExpr->get_type(), "", pretty, genC );
+                        output << genType( sizeofExpr->get_type(), "", options );
                 } else {
                         sizeofExpr->get_expr()->accept( *visitor );
@@ -673 +680 @@
                 output << "__alignof__(";
                 if ( alignofExpr->get_isType() ) {
-                        output << genType( alignofExpr->get_type(), "", pretty, genC );
+                        output << genType( alignofExpr->get_type(), "", options );
                 } else {
                         alignofExpr->get_expr()->accept( *visitor );
@@ -681 +688 @@
 
         void CodeGenerator::postvisit( UntypedOffsetofExpr * offsetofExpr ) {
-                assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
+                assertf( ! options.genC, "UntypedOffsetofExpr should not reach code generation." );
                 output << "offsetof(";
-                output << genType( offsetofExpr->get_type(), "", pretty, genC );
+                output << genType( offsetofExpr->get_type(), "", options );
                 output << ", " << offsetofExpr->get_member();
                 output << ")";
@@ -691 +698 @@
                 // use GCC builtin
                 output << "__builtin_offsetof(";
-                output << genType( offsetofExpr->get_type(), "", pretty, genC );
+                output << genType( offsetofExpr->get_type(), "", options );
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
@@ -697 +704 @@
 
         void CodeGenerator::postvisit( OffsetPackExpr * offsetPackExpr ) {
-                assertf( ! genC, "OffsetPackExpr should not reach code generation." );
-                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
+                assertf( ! options.genC, "OffsetPackExpr should not reach code generation." );
+                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", options ) << ")";
         }
 
@@ -728 +735 @@
                 extension( commaExpr );
                 output << "(";
-                if ( genC ) {
+                if ( options.genC ) {
                         // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
                         commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
@@ -739 +746 @@
 
         void CodeGenerator::postvisit( TupleAssignExpr * tupleExpr ) {
-                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
+                assertf( ! options.genC, "TupleAssignExpr should not reach code generation." );
                 tupleExpr->stmtExpr->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( UntypedTupleExpr * tupleExpr ) {
-                assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
+                assertf( ! options.genC, "UntypedTupleExpr should not reach code generation." );
                 extension( tupleExpr );
                 output << "[";
@@ -752 +759 @@
 
         void CodeGenerator::postvisit( TupleExpr * tupleExpr ) {
-                assertf( ! genC, "TupleExpr should not reach code generation." );
+                assertf( ! options.genC, "TupleExpr should not reach code generation." );
                 extension( tupleExpr );
                 output << "[";
@@ -760 +767 @@
 
         void CodeGenerator::postvisit( TupleIndexExpr * tupleExpr ) {
-                assertf( ! genC, "TupleIndexExpr should not reach code generation." );
+                assertf( ! options.genC, "TupleIndexExpr should not reach code generation." );
                 extension( tupleExpr );
                 tupleExpr->get_tuple()->accept( *visitor );
@@ -767 +774 @@
 
         void CodeGenerator::postvisit( TypeExpr * typeExpr ) {
-                // if ( genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
-                // assertf( ! genC, "TypeExpr should not reach code generation." );
-                if ( ! genC ) {
-                        output<< genType( typeExpr->get_type(), "", pretty, genC );
+                // if ( options.genC ) std::cerr << "typeexpr still exists: " << typeExpr << std::endl;
+                // assertf( ! options.genC, "TypeExpr should not reach code generation." );
+                if ( ! options.genC ) {
+                        output << genType( typeExpr->get_type(), "", options );
                 }
         }
@@ -788 +795 @@
         void CodeGenerator::postvisit( CompoundLiteralExpr *compLitExpr ) {
                 assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
-                output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
+                output << "(" << genType( compLitExpr->get_result(), "", options ) << ")";
                 compLitExpr->get_initializer()->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( UniqueExpr * unqExpr ) {
-                assertf( ! genC, "Unique expressions should not reach code generation." );
+                assertf( ! options.genC, "Unique expressions should not reach code generation." );
                 output << "unq<" << unqExpr->get_id() << ">{ ";
                 unqExpr->get_expr()->accept( *visitor );
@@ -829 +836 @@
 
         void CodeGenerator::postvisit( ConstructorExpr * expr ) {
-                assertf( ! genC, "Unique expressions should not reach code generation." );
+                assertf( ! options.genC, "Unique expressions should not reach code generation." );
                 expr->callExpr->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( DeletedExpr * expr ) {
-                assertf( ! genC, "Deleted expressions should not reach code generation." );
+                assertf( ! options.genC, "Deleted expressions should not reach code generation." );
                 expr->expr->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( DefaultArgExpr * arg ) {
-                assertf( ! genC, "Default argument expressions should not reach code generation." );
+                assertf( ! options.genC, "Default argument expressions should not reach code generation." );
                 arg->expr->accept( *visitor );
         }
 
         void CodeGenerator::postvisit( GenericExpr * expr ) {
-                assertf( ! genC, "C11 _Generic expressions should not reach code generation." );
+                assertf( ! options.genC, "C11 _Generic expressions should not reach code generation." );
                 output << "_Generic(";
                 expr->control->accept( *visitor );
@@ -854 +861 @@
                                 output << "default: ";
                         } else {
-                                output << genType( assoc.type, "", pretty, genC ) << ": ";
+                                output << genType( assoc.type, "", options ) << ": ";
                         }
                         assoc.expr->accept( *visitor );
@@ -889 +896 @@
         void CodeGenerator::postvisit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                if ( genC ) {
+                if ( options.genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
                         exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
@@ -999 +1006 @@
                   case BranchStmt::FallThrough:
                   case BranchStmt::FallThroughDefault:
-                        assertf( ! genC, "fallthru should not reach code generation." );
+                        assertf( ! options.genC, "fallthru should not reach code generation." );
                   output << "fallthru";
                         break;
                 } // switch
                 // print branch target for labelled break/continue/fallthru in debug mode
-                if ( ! genC && branchStmt->get_type() != BranchStmt::Goto ) {
+                if ( ! options.genC && branchStmt->get_type() != BranchStmt::Goto ) {
                         if ( ! branchStmt->get_target().empty() ) {
                                 output << " " << branchStmt->get_target();
@@ -1021 +1028 @@
 
         void CodeGenerator::postvisit( ThrowStmt * throwStmt ) {
-                assertf( ! genC, "Throw statements should not reach code generation." );
+                assertf( ! options.genC, "Throw statements should not reach code generation." );
 
                 output << ((throwStmt->get_kind() == ThrowStmt::Terminate) ?
@@ -1036 +1043 @@
         }
         void CodeGenerator::postvisit( CatchStmt * stmt ) {
-                assertf( ! genC, "Catch statements should not reach code generation." );
+                assertf( ! options.genC, "Catch statements should not reach code generation." );
 
                 output << ((stmt->get_kind() == CatchStmt::Terminate) ?
@@ -1053 +1060 @@
 
         void CodeGenerator::postvisit( WaitForStmt * stmt ) {
-                assertf( ! genC, "Waitfor statements should not reach code generation." );
+                assertf( ! options.genC, "Waitfor statements should not reach code generation." );
 
                 bool first = true;
@@ -1099 +1106 @@
 
         void CodeGenerator::postvisit( WithStmt * with ) {
-                if ( ! genC ) {
+                if ( ! options.genC ) {
                         output << "with ( ";
                         genCommaList( with->exprs.begin(), with->exprs.end() );
@@ -1165 +1172 @@
 
         void CodeGenerator::postvisit( ImplicitCtorDtorStmt * stmt ) {
-                assertf( ! genC, "ImplicitCtorDtorStmts should not reach code generation." );
+                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
                 stmt->callStmt->accept( *visitor );
         }

src/CodeGen/CodeGenerator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 18 15:40:00 2017
-// Update Count     : 56
+// Last Modified On : Tue Apr 30 12:01:00 2019
+// Update Count     : 57
 //
 
@@ -20 +20 @@
 #include <string>                 // for string
 
+#include "CodeGen/Options.h"      // for Options
 #include "Common/Indenter.h"      // for Indenter
 #include "Common/PassVisitor.h"   // for PassVisitor
@@ -31 +32 @@
 
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
+                CodeGenerator( std::ostream &os, const Options &options );
 
                 //*** Turn off visit_children for all nodes
@@ -144 +146 @@
                 std::ostream & output;
                 LabelPrinter printLabels;
-                bool pretty = false;  // pretty print
-                bool genC = false;    // true if output has to be C code
-                bool lineMarks = false;
-                bool printExprTypes = false;
+                Options options;
         public:
                 LineEnder endl;

src/CodeGen/GenType.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 09:02:28 2017
-// Update Count     : 22
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May  1 15:24:00 2019
+// Update Count     : 23
 //
 #include "GenType.h"
@@ -28 +28 @@
         struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
                 std::string typeString;
-                GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks );
+                GenType( const std::string &typeString, const Options &options );
 
                 void previsit( BaseSyntaxNode * );
@@ -57 +57 @@
                 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
 
-                bool pretty = false;    // pretty print
-                bool genC = false;      // generating C code?
-                bool lineMarks = false; // lineMarks on for CodeGenerator?
+                Options options;
         };
 
-        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
-                PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks );
+        std::string genType( Type *type, const std::string &baseString, const Options &options ) {
+                PassVisitor<GenType> gt( baseString, options );
                 std::ostringstream os;
 
                 if ( ! type->get_attributes().empty() ) {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         cg.pass.genAttributes( type->get_attributes() );
                 } // if
@@ -75 +73 @@
         }
 
-  std::string genPrettyType( Type * type, const std::string & baseString ) {
-        return genType( type, baseString, true, false );
-  }
-
-        GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
+                return genType( type, baseString, Options(pretty, genC, lineMarks, false ) );
+        }
+
+        std::string genPrettyType( Type * type, const std::string & baseString ) {
+                return genType( type, baseString, true, false );
+        }
+
+        GenType::GenType( const std::string &typeString, const Options &options ) : typeString( typeString ), options( options ) {}
 
         // *** BaseSyntaxNode
@@ -133 +135 @@
                 } // if
                 if ( dimension != 0 ) {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
@@ -167 +169 @@
         void GenType::postvisit( ReferenceType * refType ) {
                 assert( refType->base != 0);
-                assertf( ! genC, "Reference types should not reach code generation." );
+                assertf( ! options.genC, "Reference types should not reach code generation." );
                 handleQualifiers( refType );
                 typeString = "&" + typeString;
@@ -195 +197 @@
                         } // if
                 } else {
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         os << "(" ;
 
@@ -215 +217 @@
 
                 // add forall
-                if( ! funcType->forall.empty() && ! genC ) {
+                if( ! funcType->forall.empty() && ! options.genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         std::ostringstream os;
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         os << "forall(";
                         cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
@@ -229 +231 @@
                 if ( ! refType->parameters.empty() ) {
                         std::ostringstream os;
-                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        PassVisitor<CodeGenerator> cg( os, options );
                         os << "(";
                         cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
@@ -240 +242 @@
         void GenType::postvisit( StructInstType * structInst )  {
                 typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
-                if ( genC ) typeString = "struct " + typeString;
+                if ( options.genC ) typeString = "struct " + typeString;
                 handleQualifiers( structInst );
         }
@@ -246 +248 @@
         void GenType::postvisit( UnionInstType * unionInst ) {
                 typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
-                if ( genC ) typeString = "union " + typeString;
+                if ( options.genC ) typeString = "union " + typeString;
                 handleQualifiers( unionInst );
         }
@@ -252 +254 @@
         void GenType::postvisit( EnumInstType * enumInst ) {
                 typeString = enumInst->name + " " + typeString;
-                if ( genC ) typeString = "enum " + typeString;
+                if ( options.genC ) typeString = "enum " + typeString;
                 handleQualifiers( enumInst );
         }
@@ -262 +264 @@
 
         void GenType::postvisit( TupleType * tupleType ) {
-                assertf( ! genC, "Tuple types should not reach code generation." );
+                assertf( ! options.genC, "Tuple types should not reach code generation." );
                 unsigned int i = 0;
                 std::ostringstream os;
@@ -268 +270 @@
                 for ( Type * t : *tupleType ) {
                         i++;
-                        os << genType( t, "", pretty, genC, lineMarks ) << (i == tupleType->size() ? "" : ", ");
+                        os << genType( t, "", options ) << (i == tupleType->size() ? "" : ", ");
                 }
                 os << "] ";
@@ -281 +283 @@
         void GenType::postvisit( ZeroType * zeroType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
-                typeString = (pretty ? "zero_t " : "long int ") + typeString;
+                typeString = (options.pretty ? "zero_t " : "long int ") + typeString;
                 handleQualifiers( zeroType );
         }
@@ -287 +289 @@
         void GenType::postvisit( OneType * oneType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
-                typeString = (pretty ? "one_t " : "long int ") + typeString;
+                typeString = (options.pretty ? "one_t " : "long int ") + typeString;
                 handleQualifiers( oneType );
         }
 
         void GenType::postvisit( GlobalScopeType * globalType ) {
-                assertf( ! genC, "Global scope type should not reach code generation." );
+                assertf( ! options.genC, "Global scope type should not reach code generation." );
                 handleQualifiers( globalType );
         }
 
         void GenType::postvisit( TraitInstType * inst ) {
-                assertf( ! genC, "Trait types should not reach code generation." );
+                assertf( ! options.genC, "Trait types should not reach code generation." );
                 typeString = inst->name + " " + typeString;
                 handleQualifiers( inst );
@@ -304 +306 @@
         void GenType::postvisit( TypeofType * typeof ) {
                 std::ostringstream os;
-                PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                PassVisitor<CodeGenerator> cg( os, options );
                 os << "typeof(";
                 typeof->expr->accept( cg );
@@ -313 +315 @@
 
         void GenType::postvisit( QualifiedType * qualType ) {
-                assertf( ! genC, "Qualified types should not reach code generation." );
-                std::ostringstream os;
-                os << genType( qualType->parent, "", pretty, genC, lineMarks ) << "." << genType( qualType->child, "", pretty, genC, lineMarks ) << typeString;
+                assertf( ! options.genC, "Qualified types should not reach code generation." );
+                std::ostringstream os;
+                os << genType( qualType->parent, "", options ) << "." << genType( qualType->child, "", options ) << typeString;
                 typeString = os.str();
                 handleQualifiers( qualType );
@@ -333 +335 @@
                         typeString = "_Atomic " + typeString;
                 } // if
-                if ( type->get_lvalue() && ! genC ) {
+                if ( type->get_lvalue() && ! options.genC ) {
                         // when not generating C code, print lvalue for debugging.
                         typeString = "lvalue " + typeString;

src/CodeGen/GenType.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 : Fri Jul 21 22:17:23 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 30 11:47:00 2019
+// Update Count     : 3
 //
 
@@ -18 +18 @@
 #include <string>  // for string
 
+#include "CodeGen/Options.h" // for Options
+
 class Type;
 
 namespace CodeGen {
+        std::string genType( Type *type, const std::string &baseString, const Options &options );
         std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
   std::string genPrettyType( Type * type, const std::string & baseString );

src/CodeGen/module.mk

@@ -18 +18 @@
 #       ArgTweak/Mutate.cc
 
-SRC +=  CodeGen/Generate.cc \
+SRC_CODEGEN = \
         CodeGen/CodeGenerator.cc \
+        CodeGen/FixMain.cc \
         CodeGen/GenType.cc \
-        CodeGen/FixNames.cc \
-        CodeGen/FixMain.cc \
         CodeGen/OperatorTable.cc
+
+
+SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/FixNames.cc
+SRCDEMANGLE += $(SRC_CODEGEN)

src/Common/Assert.cc

@@ -39 +39 @@
 }
 
+void abort(const char *fmt, ... ) noexcept __attribute__((noreturn, format(printf, 1, 2)));
+void abort(const char *fmt, ... ) noexcept {
+        va_list args;
+        va_start( args, fmt );
+        vfprintf( stderr, fmt, args );
+        va_end( args );
+        fprintf( stderr, "\n" );
+        abort();
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/Common/PassVisitor.h

@@ -4 +4 @@
 
 #include <stack>
-
+#include <type_traits>
+
+#include "Common/Stats.h"
 #include "Common/utility.h"
 
@@ -153 +155 @@
         virtual void visit( ConstructorInit * ctorInit ) override final;
 
-        virtual void visit( Subrange * subrange ) override final;
-
         virtual void visit( Constant * constant ) override final;
 
@@ -255 +255 @@
         virtual Initializer * mutate( ConstructorInit * ctorInit ) override final;
 
-        virtual Subrange * mutate( Subrange * subrange ) override final;
-
         virtual Constant * mutate( Constant * constant ) override final;
 
@@ -300 +298 @@
 
 
-        TypeSubstitution **             get_env_ptr    () { return env_impl             ( pass, 0); }
+        auto                                    get_env_ptr    () -> decltype(env_impl( pass, 0)) { return env_impl( pass, 0); }
         std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
         std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
@@ -347 +345 @@
 };
 
+class WithConstTypeSubstitution {
+protected:
+        WithConstTypeSubstitution() = default;
+        ~WithConstTypeSubstitution() = default;
+
+public:
+        const TypeSubstitution * env = nullptr;
+};
+
 class WithStmtsToAdd {
 protected:
@@ -426 +433 @@
 };
 
+#include "Common/Stats.h"
+
+extern struct PassVisitorStats {
+        size_t depth = 0;
+        Stats::Counters::MaxCounter<double> * max = nullptr;
+        Stats::Counters::AverageCounter<double> * avg = nullptr;
+} pass_visitor_stats;
+
 #include "SynTree/TypeSubstitution.h"
 #include "PassVisitor.impl.h"

src/Common/PassVisitor.impl.h

@@ -20 +20 @@
 
 #define MUTATE_END( type, node )                \
-        return call_postmutate< type * >( node ); \
+        auto __return = call_postmutate< type * >( node ); \
+        assert( __return ); \
+        return __return;
 
 
@@ -67 +69 @@
         SemanticErrorException errors;
 
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
+
+
                 // splice in new declarations after previous decl
                 if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
@@ -83 +90 @@
                 if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
         }
+        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
@@ -94 +102 @@
         SemanticErrorException errors;
 
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
@@ -109 +120 @@
                 if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
         }
+        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
@@ -126 +138 @@
         if ( ! visitor.get_visit_children() ) return;
         SemanticErrorException errors;
+
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -135 +151 @@
                 }
         }
+        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
@@ -151 +168 @@
 template< typename Container, typename pass_type >
 inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
+
         if ( ! mutator.get_visit_children() ) return;
         SemanticErrorException errors;
+
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -163 +185 @@
                 } // try
         } // for
+        pass_visitor_stats.depth--;
         if ( ! errors.isEmpty() ) {
                 throw errors;
@@ -185 +208 @@
         DeclList_t* afterDecls  = get_afterDecls();
 
+        pass_visitor_stats.depth++;
+        pass_visitor_stats.max->push(pass_visitor_stats.depth);
+        pass_visitor_stats.avg->push(pass_visitor_stats.depth);
         for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
 
@@ -192 +218 @@
                 try {
                         func( *i );
+                        assert( *i );
                         assert(( empty( beforeStmts ) && empty( afterStmts ))
                             || ( empty( beforeDecls ) && empty( afterDecls )) );
@@ -202 +229 @@
                 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
         }
+        pass_visitor_stats.depth--;
 
         if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
@@ -229 +257 @@
 
         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
-        ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
+        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
         ValueGuardPtr< DeclList_t >          oldBeforeDecls( get_beforeDecls() );
         ValueGuardPtr< DeclList_t >          oldAfterDecls ( get_afterDecls () );
@@ -1965 +1993 @@
 
         // don't want statements from outer CompoundStmts to be added to this StmtExpr
-        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
+        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
@@ -1982 +2010 @@
 
         // don't want statements from outer CompoundStmts to be added to this StmtExpr
-        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
+        ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
@@ -2678 +2706 @@
 
 //--------------------------------------------------------------------------
-// Subrange
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( Subrange * node ) {
-        VISIT_START( node );
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
-        MUTATE_START( node );
-
-        MUTATE_END( Subrange, node );
-}
-
-//--------------------------------------------------------------------------
 // Attribute
 template< typename pass_type >

src/Common/PassVisitor.proto.h

@@ -165 +165 @@
 static inline type * name##_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) { return nullptr;}    \
 
-FIELD_PTR( TypeSubstitution *, env )
+FIELD_PTR( const TypeSubstitution *, env )
 FIELD_PTR( std::list< Statement* >, stmtsToAddBefore )
 FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
@@ -174 +174 @@
 FIELD_PTR( PassVisitor<pass_type> * const, visitor )
 
+#undef FIELD_PTR
+
 //---------------------------------------------------------
 // Indexer
@@ -220 +222 @@
 INDEXER_FUNC2( addWith   , std::list< Expression * > &, BaseSyntaxNode * );
 
+#undef INDEXER_FUNC1
+#undef INDEXER_FUNC2
 
 template<typename pass_type>

src/Common/SemanticError.h

@@ -17 +17 @@
 
 #include "ErrorObjects.h"
+#include "AST/Node.hpp"
 #include <cstring>
 

src/Common/Stats/Heap.h

@@ -16 +16 @@
 #pragma once
 
-namespace HeapStats {
-        void newPass( const char * const name );
-        void printStats();
+namespace Stats {
+        namespace Heap {
+                void newPass( const char * const name );
+                void print();
+        }
 }

src/Common/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Common/SemanticError.cc \
-       Common/UniqueName.cc \
-       Common/DebugMalloc.cc \
-       Common/Assert.cc \
-       Common/Heap.cc \
-       Common/Eval.cc
+SRC_COMMON = \
+      Common/Assert.cc \
+      Common/Eval.cc \
+      Common/PassVisitor.cc \
+      Common/SemanticError.cc \
+      Common/Stats/Counter.cc \
+      Common/Stats/Heap.cc \
+      Common/Stats/Stats.cc \
+      Common/Stats/Time.cc \
+      Common/UniqueName.cc
+
+SRC += $(SRC_COMMON) Common/DebugMalloc.cc
+SRCDEMANGLE += $(SRC_COMMON)

src/Common/utility.h

@@ -463 +463 @@
 std::pair<long long int, bool> eval(Expression * expr);
 
-// -----------------------------------------------------------------------------
-/// Reorders the input range in-place so that the minimal-value elements according to the 
-/// comparator are in front; 
+namespace ast {
+        class Expr;
+}
+
+std::pair<long long int, bool> eval(const ast::Expr * expr);
+
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the
+/// comparator are in front;
 /// returns the iterator after the last minimal-value element.
 template<typename Iter, typename Compare>
 Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
         if ( begin == end ) return end;
-        
+
         Iter min_pos = begin;
         for ( Iter i = begin + 1; i != end; ++i ) {

src/CompilationState.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
-// Last Modified By : Rob Schluntz
-// Last Modified On : Mon Ju1 30 10:46:25 2018
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri May  3 13:45:23 2019
+// Update Count     : 4
 //
 
-bool
+int
         astp = false,
         bresolvep = false,
@@ -26 +26 @@
         libcfap = false,
         nopreludep = false,
-        noprotop = false,
+        genproto = false,
         nomainp = false,
         parsep = false,

src/CompilationState.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Mon Ju1 30 10:47:01 2018
-// Last Modified By : Rob Schluntz
-// Last Modified On : Mon Ju1 30 10:46:25 2018
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri May  3 13:43:21 2019
+// Update Count     : 4
 //
 
 extern int yydebug;                   // set for -g flag (Grammar)
-extern bool
+extern int
         astp,
         bresolvep,
@@ -27 +27 @@
         libcfap,
         nopreludep,
-        noprotop,
+        genproto,
         nomainp,
         parsep,

src/Concurrency/Waitfor.cc

@@ -11 +11 @@
 // Last Modified By :
 // Last Modified On :
-// Update Count     : 5
+// Update Count     : 7
 //
 

src/Concurrency/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Concurrency/Keywords.cc \
-       Concurrency/Waitfor.cc
+SRC += Concurrency/Keywords.cc Concurrency/Waitfor.cc
+SRCDEMANGLE += Concurrency/Keywords.cc
 

src/ControlStruct/ExceptTranslate.cc

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Wed Jun 14 16:49:00 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Aug 17 17:19:00 2017
-// Update Count     : 9
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb 13 18:15:29 2019
+// Update Count     : 11
 //
 
@@ -617 +617 @@
                                 return create_terminate_rethrow( throwStmt );
                         } else {
-                                assertf(false, "Invalid throw in %s at %i\n",
+                                abort("Invalid throw in %s at %i\n",
                                         throwStmt->location.filename.c_str(),
                                         throwStmt->location.first_line);
-                                return nullptr;
                         }
                 } else {
@@ -628 +627 @@
                                 return create_resume_rethrow( throwStmt );
                         } else {
-                                assertf(false, "Invalid throwResume in %s at %i\n",
+                                abort("Invalid throwResume in %s at %i\n",
                                         throwStmt->location.filename.c_str(),
                                         throwStmt->location.first_line);
-                                return nullptr;
                         }
                 }

src/ControlStruct/ForExprMutator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 18 10:22:00 2017
-// Update Count     : 12
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:52 2019
+// Update Count     : 14
 //
 
@@ -21 +21 @@
 
 namespace ControlStruct {
-        Statement *hoist( Statement *originalStmt, std::list<Statement *> &init ) {
+        Statement * hoist( Statement * originalStmt, std::list<Statement *> & init ) {
                 // If no hoisting is needed, skip:
                 if ( 0 == init.size() ) {
@@ -29 +29 @@
                 // Create compound statement, move initializers outside,
                 // the resut of the original stays as is.
-                CompoundStmt *block = new CompoundStmt();
-                std::list<Statement *> &stmts = block->get_kids();
+                CompoundStmt * block = new CompoundStmt();
+                std::list<Statement *> & stmts = block->get_kids();
                 stmts.splice( stmts.end(), init );
 
@@ -38 +38 @@
         }
 
-        Statement *ForExprMutator::postmutate( IfStmt *ifStmt ) {
+        Statement * ForExprMutator::postmutate( IfStmt * ifStmt ) {
                 return hoist( ifStmt, ifStmt->initialization );
         }
-        Statement *ForExprMutator::postmutate( ForStmt *forStmt ) {
+        Statement * ForExprMutator::postmutate( ForStmt * forStmt ) {
                 // hoist any initializer declarations to make them C89 (rather than C99)
                 return hoist( forStmt, forStmt->initialization );
         }
-        Statement *ForExprMutator::postmutate( WhileStmt *whileStmt ) {
+        Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
                 return hoist( whileStmt, whileStmt->initialization );
         }

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Jul 28 13:32:43 2015
-// Update Count     : 156
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:02 2019
+// Update Count     : 159
 //
 
@@ -32 +32 @@
         }
 
-        LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
+        LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
                 if ( generator == 0 )
                         generator = LabelGenerator::getGenerator();
@@ -49 +49 @@
 
         // prune to at most one label definition for each statement
-        void LabelFixer::previsit( Statement *stmt ) {
+        void LabelFixer::previsit( Statement * stmt ) {
                 std::list< Label > &labels = stmt->get_labels();
 
@@ -58 +58 @@
         }
 
-        void LabelFixer::previsit( BranchStmt *branchStmt ) {
+        void LabelFixer::previsit( BranchStmt * branchStmt ) {
                 previsit( ( Statement *)branchStmt );
 
@@ -75 +75 @@
 
 
-        // sets the definition of the labelTable entry to be the provided
-        // statement for every label in the list parameter. Happens for every kind of statement
-        Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
+        // sets the definition of the labelTable entry to be the provided statement for every label in the list
+        // parameter. Happens for every kind of statement
+        Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
                 assert( definition != 0 );
                 assert( llabel.size() > 0 );
@@ -100 +100 @@
                 } // for
 
-                // produce one of the labels attached to this statement to be
-                // temporarily used as the canonical label
+                // produce one of the labels attached to this statement to be temporarily used as the canonical label
                 return labelTable[ llabel.front() ]->get_label();
         }
@@ -117 +116 @@
 
         // Builds a table that maps a label to its defining statement.
-        std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+        std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {

src/ControlStruct/LabelGenerator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Aug 14 14:14:00 2015
-// Update Count     : 14
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:23:20 2019
+// Update Count     : 15
 //
 
@@ -24 +24 @@
 
 namespace ControlStruct {
-        LabelGenerator *LabelGenerator::labelGenerator = 0;
+        LabelGenerator * LabelGenerator::labelGenerator = 0;
 
-        LabelGenerator *LabelGenerator::getGenerator() {
+        LabelGenerator * LabelGenerator::getGenerator() {
                 if ( LabelGenerator::labelGenerator == 0 )
                         LabelGenerator::labelGenerator = new LabelGenerator();
-
                 return labelGenerator;
         }
@@ -38 +37 @@
                 if ( stmt && ! stmt->get_labels().empty() ) {
                         os << "_" << stmt->get_labels().front() << "__";
-                }
+                } // if
                 std::string ret = os.str();
                 Label l( ret );

src/ControlStruct/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC +=  ControlStruct/LabelGenerator.cc \
+SRC_CONTROLSTRUCT = \
+        ControlStruct/ForExprMutator.cc \
         ControlStruct/LabelFixer.cc \
+        ControlStruct/LabelGenerator.cc \
         ControlStruct/MLEMutator.cc \
-        ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc \
-        ControlStruct/ExceptTranslate.cc
+        ControlStruct/Mutate.cc
+
+SRC += $(SRC_CONTROLSTRUCT) ControlStruct/ExceptTranslate.cc
+SRCDEMANGLE += $(SRC_CONTROLSTRUCT)
+

src/GenPoly/Box.cc

@@ -76 +76 @@
 
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
-                class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
+                class Pass1 final : public BoxPass, public WithConstTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
                   public:
                         Pass1();
@@ -150 +150 @@
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
-                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
+                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithConstTypeSubstitution {
                 public:
                         PolyGenericCalculator();

src/GenPoly/GenPoly.cc

@@ -440 +440 @@
         }
 
-        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ) {
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
                 if ( ! isPolyType( param, exprTyVars ) ) return false;
@@ -450 +450 @@
         }
 
-        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ) {
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
                 assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );

src/GenPoly/GenPoly.h

@@ -81 +81 @@
 
         /// true if arg requires boxing given exprTyVars
-        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env );
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
 
         /// true if arg requires boxing in the call to appExpr
-        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env );
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
 
         /// Adds the type variable `tyVar` to `tyVarMap`

src/GenPoly/InstantiateGeneric.cc

@@ -168 +168 @@
 
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
+        struct GenericInstantiator final : public WithConstTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;

src/GenPoly/Specialize.cc

@@ -42 +42 @@
 
 namespace GenPoly {
-        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+        struct Specialize final : public WithConstTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
                 Expression * postmutate( CastExpr *castExpr );
@@ -54 +54 @@
 
         /// Looks up open variables in actual type, returning true if any of them are bound in the environment or formal type.
-        bool needsPolySpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool needsPolySpecialization( Type *formalType, Type *actualType, const TypeSubstitution *env ) {
                 if ( env ) {
                         using namespace ResolvExpr;
@@ -145 +145 @@
         }
 
-        bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool needsSpecialization( Type *formalType, Type *actualType, const TypeSubstitution *env ) {
                 return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType );
         }

src/GenPoly/module.mk

@@ -22 +22 @@
        GenPoly/FindFunction.cc \
        GenPoly/InstantiateGeneric.cc
+
+SRCDEMANGLE += GenPoly/GenPoly.cc GenPoly/Lvalue.cc
+

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 21 17:35:05 2017
-// Update Count     : 74
+// Last Modified On : Wed Feb 13 18:15:56 2019
+// Update Count     : 76
 //
 #include "FixInit.h"
@@ -72 +72 @@
                 };
 
-                struct InsertImplicitCalls : public WithTypeSubstitution {
+                struct InsertImplicitCalls : public WithConstTypeSubstitution {
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed

src/InitTweak/InitTweak.cc

@@ -5 +5 @@
 #include <memory>                  // for __shared_ptr
 
+#include "AST/Expr.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -26 +29 @@
 #include "Tuples/Tuples.h"         // for Tuples::isTtype
 
-class UntypedValofExpr;
-
 namespace InitTweak {
         namespace {
@@ -432 +433 @@
                         assert( false );
                 }
+
+                // template<typename CallExpr>
+                // const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
+                //      if( pos >= call->args.size() ) {
+                //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
+                //                      pos, toString( call ).c_str() );
+                //      }
+                //      for ( const ast::Expr * arg : call->args ) {
+                //              if ( pos == 0 ) return arg;
+                //              --pos;
+                //      }
+                //      assert( false );
+                // }
         }
 
@@ -451 +465 @@
                         assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() );
                 }
+        }
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
+                (void)call;
+                (void)pos;
+                #warning unimplemented; needs to build AST/Expr.cpp
+                assertf(false, "unimplemented; needs to build AST/Expr.cpp");
+                // if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
+                //      return callArg( app, pos );
+                // } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
+                //      return callArg( untyped, pos );
+                // } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
+                //      const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
+                //      assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
+                //      const ExprStmt * stmt = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back() );
+                //      const TupleExpr * tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr );
+                //      assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
+                //      return getCallArg( tuple->exprs.front(), pos );
+                // } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
+                //      return getCallArg( ctor->callExpr, pos );
+                // } else {
+                //      assertf( false, "Unexpected expression type passed to getCallArg: %s",
+                //              toString( call ).c_str() );
+                // }
         }
 
@@ -513 +550 @@
                 }
         }
+        const ast::Type* getPointerBase( const ast::Type* t ) {
+                (void)t;
+                #warning needs to build Type.cpp before inclusion
+                assertf(false, "needs to build Type.cpp before inclusion");
+                // if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
+                //      return p->base;
+                // } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
+                //      return a->base;
+                // } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
+                //      return r->base;
+                // } else return nullptr;
+        }
 
         Type * isPointerType( Type * type ) {

src/InitTweak/InitTweak.h

@@ -20 +20 @@
 #include <string>             // for string, allocator
 
+#include "AST/Fwd.hpp"        // for AST nodes
 #include "SynTree/SynTree.h"  // for Visitor Nodes
 
@@ -80 +81 @@
         /// returns the argument to a call expression in position N indexed from 0
         Expression *& getCallArg( Expression * callExpr, unsigned int pos );
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos );
 
         /// returns the base type of a PointerType or ArrayType, else returns NULL
         Type * getPointerBase( Type * );
+        const ast::Type* getPointerBase( const ast::Type* );
 
         /// returns the argument if it is a PointerType or ArrayType, else returns NULL

src/InitTweak/module.mk

@@ -20 +20 @@
         InitTweak/InitTweak.cc
 
+SRCDEMANGLE += InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc
+

src/MakeLibCfa.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 10:33:33 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Fri Apr 22 13:54:15 2016
-// Update Count     : 40
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun Feb 17 21:08:09 2019
+// Update Count     : 41
 //
 
@@ -146 +146 @@
         } // namespace
 } // namespace LibCfa
+
+// Local Variables: //
+// tab-width: 4 //
+// End: //

src/Makefile.am

@@ -10 +10 @@
 ## Author           : Peter A. Buhr
 ## Created On       : Sun May 31 08:51:46 2015
-## Last Modified By : Andrew Beach
-## Last Modified On : Tus Jul 25 10:34:00 2017
-## Update Count     : 76
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Fri Feb 15 09:44:09 2019
+## Update Count     : 97
 ###############################################################################
 
@@ -20 +20 @@
 
 SRC = main.cc \
-                        MakeLibCfa.cc \
-                        CompilationState.cc
+      MakeLibCfa.cc \
+      CompilationState.cc
+
+SRCDEMANGLE = CompilationState.cc
 
 MAINTAINERCLEANFILES =
-MOSTLYCLEANFILES = Parser/gcc-flags.h
+MOSTLYCLEANFILES =
 
-Parser/gcc-flags.h :
-        ${AM_V_GEN}$(CC) -dM -E - < /dev/null | sed 's/define /define __GCC__/' > $(@)
+if WITH_LIBPROFILER
+LIBPROFILER = -lprofiler
+endif
 
-Parser/lex.ll : Parser/gcc-flags.h
+if WITH_LIBTCMALLOC
+LIBTCMALLOC = -ltcmalloc
+TCMALLOCFLAG = -DTCMALLOC
+endif
 
 include CodeGen/module.mk
@@ -46 +52 @@
 include Virtual/module.mk
 
+$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/SynTree/Type.h
+
+$(srcdir)/SynTree/Type.h : BasicTypes-gen.cc
+        ${AM_V_GEN}${CXXCOMPILE} $< -o BasicTypes-gen -Wall -Wextra
+        @./BasicTypes-gen
+        @rm BasicTypes-gen
+
 # put into lib for now
 cfa_cpplibdir = $(CFA_LIBDIR)
 cfa_cpplib_PROGRAMS = ../driver/cfa-cpp demangler
 ___driver_cfa_cpp_SOURCES = $(SRC)
-___driver_cfa_cpp_LDADD = -ldl                  # yywrap
+___driver_cfa_cpp_LDADD = -ldl $(LIBPROFILER) $(LIBTCMALLOC)
 
-AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
+AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++14 $(TCMALLOCFLAG)
 AM_LDFLAGS  = @HOST_FLAGS@ -Xlinker -export-dynamic
 ARFLAGS     = cr
@@ -58 +71 @@
 demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
 
-demangler_LDADD = libdemangle.a     # yywrap
+demangler_LDADD = libdemangle.a -ldl                    # yywrap
 
 noinst_LIBRARIES = libdemangle.a
-libdemangle_a_SOURCES = \
-        SymTab/Demangle.cc \
-        SymTab/ManglerCommon.cc \
-        SynTree/Type.cc \
-        SynTree/VoidType.cc \
-        SynTree/BasicType.cc \
-        SynTree/PointerType.cc \
-        SynTree/ArrayType.cc \
-        SynTree/ReferenceType.cc \
-        SynTree/FunctionType.cc \
-        SynTree/ReferenceToType.cc \
-        SynTree/TupleType.cc \
-        SynTree/TypeofType.cc \
-        SynTree/AttrType.cc \
-        SynTree/VarArgsType.cc \
-        SynTree/ZeroOneType.cc \
-        SynTree/Constant.cc \
-        SynTree/Expression.cc \
-        SynTree/TupleExpr.cc \
-        SynTree/CommaExpr.cc \
-        SynTree/TypeExpr.cc \
-        SynTree/ApplicationExpr.cc \
-        SynTree/AddressExpr.cc \
-        SynTree/Statement.cc \
-        SynTree/CompoundStmt.cc \
-        SynTree/DeclStmt.cc \
-        SynTree/Declaration.cc \
-        SynTree/DeclarationWithType.cc \
-        SynTree/ObjectDecl.cc \
-        SynTree/FunctionDecl.cc \
-        SynTree/AggregateDecl.cc \
-        SynTree/NamedTypeDecl.cc \
-        SynTree/TypeDecl.cc \
-        SynTree/Initializer.cc \
-        SynTree/TypeSubstitution.cc \
-        SynTree/Attribute.cc \
-        SynTree/DeclReplacer.cc \
-        CompilationState.cc \
-        CodeGen/CodeGenerator.cc \
-        CodeGen/FixMain.cc \
-        CodeGen/Generate.cc \
-        CodeGen/GenType.cc \
-        CodeGen/OperatorTable.cc \
-        Common/Assert.cc \
-        Common/Eval.cc \
-        Common/SemanticError.cc \
-        Common/UniqueName.cc \
-        Concurrency/Keywords.cc \
-        ControlStruct/ForExprMutator.cc \
-        ControlStruct/LabelFixer.cc \
-        ControlStruct/LabelGenerator.cc \
-        ControlStruct/MLEMutator.cc \
-        ControlStruct/Mutate.cc \
-        GenPoly/GenPoly.cc \
-        GenPoly/Lvalue.cc \
-        InitTweak/GenInit.cc \
-        InitTweak/InitTweak.cc \
-        Parser/LinkageSpec.cc \
-        ResolvExpr/AdjustExprType.cc \
-        ResolvExpr/Alternative.cc \
-        ResolvExpr/AlternativeFinder.cc \
-        ResolvExpr/ExplodedActual.cc \
-        ResolvExpr/CastCost.cc \
-        ResolvExpr/CommonType.cc \
-        ResolvExpr/ConversionCost.cc \
-        ResolvExpr/CurrentObject.cc \
-        ResolvExpr/FindOpenVars.cc \
-        ResolvExpr/Occurs.cc \
-        ResolvExpr/PolyCost.cc \
-        ResolvExpr/PtrsAssignable.cc \
-        ResolvExpr/PtrsCastable.cc \
-        ResolvExpr/RenameVars.cc \
-        ResolvExpr/ResolveAssertions.cc \
-        ResolvExpr/Resolver.cc \
-        ResolvExpr/ResolveTypeof.cc \
-        ResolvExpr/SpecCost.cc \
-        ResolvExpr/TypeEnvironment.cc \
-        ResolvExpr/Unify.cc \
-        SymTab/Autogen.cc \
-        SymTab/FixFunction.cc \
-        SymTab/Indexer.cc \
-        SymTab/Mangler.cc \
-        SymTab/Validate.cc \
-        Tuples/Explode.cc \
-        Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc \
-        Validate/HandleAttributes.cc \
-        Validate/FindSpecialDecls.cc
-
+libdemangle_a_SOURCES = $(SRCDEMANGLE)
 
 MAINTAINERCLEANFILES += ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}

src/Makefile.in

@@ -162 +162 @@
 libdemangle_a_LIBADD =
 am__dirstamp = $(am__leading_dot)dirstamp
-am_libdemangle_a_OBJECTS = SymTab/Demangle.$(OBJEXT) \
-        SymTab/ManglerCommon.$(OBJEXT) SynTree/Type.$(OBJEXT) \
-        SynTree/VoidType.$(OBJEXT) SynTree/BasicType.$(OBJEXT) \
-        SynTree/PointerType.$(OBJEXT) SynTree/ArrayType.$(OBJEXT) \
-        SynTree/ReferenceType.$(OBJEXT) SynTree/FunctionType.$(OBJEXT) \
-        SynTree/ReferenceToType.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
-        SynTree/TypeofType.$(OBJEXT) SynTree/AttrType.$(OBJEXT) \
-        SynTree/VarArgsType.$(OBJEXT) SynTree/ZeroOneType.$(OBJEXT) \
-        SynTree/Constant.$(OBJEXT) SynTree/Expression.$(OBJEXT) \
-        SynTree/TupleExpr.$(OBJEXT) SynTree/CommaExpr.$(OBJEXT) \
-        SynTree/TypeExpr.$(OBJEXT) SynTree/ApplicationExpr.$(OBJEXT) \
-        SynTree/AddressExpr.$(OBJEXT) SynTree/Statement.$(OBJEXT) \
-        SynTree/CompoundStmt.$(OBJEXT) SynTree/DeclStmt.$(OBJEXT) \
-        SynTree/Declaration.$(OBJEXT) \
-        SynTree/DeclarationWithType.$(OBJEXT) \
-        SynTree/ObjectDecl.$(OBJEXT) SynTree/FunctionDecl.$(OBJEXT) \
-        SynTree/AggregateDecl.$(OBJEXT) \
-        SynTree/NamedTypeDecl.$(OBJEXT) SynTree/TypeDecl.$(OBJEXT) \
-        SynTree/Initializer.$(OBJEXT) \
-        SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
-        SynTree/DeclReplacer.$(OBJEXT) CompilationState.$(OBJEXT) \
-        CodeGen/CodeGenerator.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
-        CodeGen/Generate.$(OBJEXT) CodeGen/GenType.$(OBJEXT) \
-        CodeGen/OperatorTable.$(OBJEXT) Common/Assert.$(OBJEXT) \
-        Common/Eval.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
-        Common/UniqueName.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
-        ControlStruct/ForExprMutator.$(OBJEXT) \
+am__objects_1 = CodeGen/CodeGenerator.$(OBJEXT) \
+        CodeGen/FixMain.$(OBJEXT) CodeGen/GenType.$(OBJEXT) \
+        CodeGen/OperatorTable.$(OBJEXT)
+am__objects_2 = Common/Assert.$(OBJEXT) Common/Eval.$(OBJEXT) \
+        Common/PassVisitor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
+        Common/Stats/Counter.$(OBJEXT) Common/Stats/Heap.$(OBJEXT) \
+        Common/Stats/Stats.$(OBJEXT) Common/Stats/Time.$(OBJEXT) \
+        Common/UniqueName.$(OBJEXT)
+am__objects_3 = ControlStruct/ForExprMutator.$(OBJEXT) \
         ControlStruct/LabelFixer.$(OBJEXT) \
         ControlStruct/LabelGenerator.$(OBJEXT) \
         ControlStruct/MLEMutator.$(OBJEXT) \
-        ControlStruct/Mutate.$(OBJEXT) GenPoly/GenPoly.$(OBJEXT) \
-        GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
-        InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
-        ResolvExpr/AdjustExprType.$(OBJEXT) \
+        ControlStruct/Mutate.$(OBJEXT)
+am__objects_4 = ResolvExpr/AdjustExprType.$(OBJEXT) \
         ResolvExpr/Alternative.$(OBJEXT) \
         ResolvExpr/AlternativeFinder.$(OBJEXT) \
-        ResolvExpr/ExplodedActual.$(OBJEXT) \
         ResolvExpr/CastCost.$(OBJEXT) ResolvExpr/CommonType.$(OBJEXT) \
         ResolvExpr/ConversionCost.$(OBJEXT) \
         ResolvExpr/CurrentObject.$(OBJEXT) \
+        ResolvExpr/ExplodedActual.$(OBJEXT) \
         ResolvExpr/FindOpenVars.$(OBJEXT) ResolvExpr/Occurs.$(OBJEXT) \
         ResolvExpr/PolyCost.$(OBJEXT) \
@@ -212 +192 @@
         ResolvExpr/SpecCost.$(OBJEXT) \
         ResolvExpr/TypeEnvironment.$(OBJEXT) \
-        ResolvExpr/Unify.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
-        SymTab/FixFunction.$(OBJEXT) SymTab/Indexer.$(OBJEXT) \
-        SymTab/Mangler.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
-        Tuples/Explode.$(OBJEXT) Tuples/TupleAssignment.$(OBJEXT) \
-        Tuples/TupleExpansion.$(OBJEXT) \
-        Validate/HandleAttributes.$(OBJEXT) \
-        Validate/FindSpecialDecls.$(OBJEXT)
-libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
-am__installdirs = "$(DESTDIR)$(cfa_cpplibdir)"
-PROGRAMS = $(cfa_cpplib_PROGRAMS)
-am__objects_1 = main.$(OBJEXT) MakeLibCfa.$(OBJEXT) \
-        CompilationState.$(OBJEXT) CodeGen/Generate.$(OBJEXT) \
-        CodeGen/CodeGenerator.$(OBJEXT) CodeGen/GenType.$(OBJEXT) \
-        CodeGen/FixNames.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
-        CodeGen/OperatorTable.$(OBJEXT) CodeTools/DeclStats.$(OBJEXT) \
-        CodeTools/ResolvProtoDump.$(OBJEXT) \
-        CodeTools/TrackLoc.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
-        Concurrency/Waitfor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
-        Common/UniqueName.$(OBJEXT) Common/DebugMalloc.$(OBJEXT) \
-        Common/Assert.$(OBJEXT) Common/Heap.$(OBJEXT) \
-        Common/Eval.$(OBJEXT) ControlStruct/LabelGenerator.$(OBJEXT) \
-        ControlStruct/LabelFixer.$(OBJEXT) \
-        ControlStruct/MLEMutator.$(OBJEXT) \
-        ControlStruct/Mutate.$(OBJEXT) \
-        ControlStruct/ForExprMutator.$(OBJEXT) \
-        ControlStruct/ExceptTranslate.$(OBJEXT) GenPoly/Box.$(OBJEXT) \
-        GenPoly/GenPoly.$(OBJEXT) GenPoly/ScrubTyVars.$(OBJEXT) \
-        GenPoly/Lvalue.$(OBJEXT) GenPoly/Specialize.$(OBJEXT) \
-        GenPoly/FindFunction.$(OBJEXT) \
-        GenPoly/InstantiateGeneric.$(OBJEXT) \
-        InitTweak/GenInit.$(OBJEXT) InitTweak/FixInit.$(OBJEXT) \
-        InitTweak/FixGlobalInit.$(OBJEXT) \
-        InitTweak/InitTweak.$(OBJEXT) Parser/parser.$(OBJEXT) \
-        Parser/lex.$(OBJEXT) Parser/TypedefTable.$(OBJEXT) \
-        Parser/ParseNode.$(OBJEXT) Parser/DeclarationNode.$(OBJEXT) \
-        Parser/ExpressionNode.$(OBJEXT) Parser/StatementNode.$(OBJEXT) \
-        Parser/InitializerNode.$(OBJEXT) Parser/TypeData.$(OBJEXT) \
-        Parser/LinkageSpec.$(OBJEXT) Parser/parserutility.$(OBJEXT) \
-        ResolvExpr/AlternativeFinder.$(OBJEXT) \
-        ResolvExpr/Alternative.$(OBJEXT) ResolvExpr/Unify.$(OBJEXT) \
-        ResolvExpr/PtrsAssignable.$(OBJEXT) \
-        ResolvExpr/CommonType.$(OBJEXT) \
-        ResolvExpr/ConversionCost.$(OBJEXT) \
-        ResolvExpr/CastCost.$(OBJEXT) \
-        ResolvExpr/PtrsCastable.$(OBJEXT) \
-        ResolvExpr/AdjustExprType.$(OBJEXT) \
-        ResolvExpr/AlternativePrinter.$(OBJEXT) \
-        ResolvExpr/Resolver.$(OBJEXT) \
-        ResolvExpr/ResolveTypeof.$(OBJEXT) \
-        ResolvExpr/RenameVars.$(OBJEXT) \
-        ResolvExpr/FindOpenVars.$(OBJEXT) \
-        ResolvExpr/PolyCost.$(OBJEXT) ResolvExpr/Occurs.$(OBJEXT) \
-        ResolvExpr/TypeEnvironment.$(OBJEXT) \
-        ResolvExpr/CurrentObject.$(OBJEXT) \
-        ResolvExpr/ExplodedActual.$(OBJEXT) \
-        ResolvExpr/SpecCost.$(OBJEXT) \
-        ResolvExpr/ResolveAssertions.$(OBJEXT) \
+        ResolvExpr/Unify.$(OBJEXT)
+am__objects_5 = SymTab/Autogen.$(OBJEXT) SymTab/FixFunction.$(OBJEXT) \
         SymTab/Indexer.$(OBJEXT) SymTab/Mangler.$(OBJEXT) \
-        SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
-        SymTab/FixFunction.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
-        SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
+        SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT)
+am__objects_6 = SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
         SynTree/BasicType.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
         SynTree/ArrayType.$(OBJEXT) SynTree/ReferenceType.$(OBJEXT) \
@@ -291 +215 @@
         SynTree/Initializer.$(OBJEXT) \
         SynTree/TypeSubstitution.$(OBJEXT) SynTree/Attribute.$(OBJEXT) \
-        SynTree/DeclReplacer.$(OBJEXT) \
+        SynTree/DeclReplacer.$(OBJEXT)
+am__objects_7 = CompilationState.$(OBJEXT) $(am__objects_1) \
+        Concurrency/Keywords.$(OBJEXT) $(am__objects_2) \
+        $(am__objects_3) GenPoly/GenPoly.$(OBJEXT) \
+        GenPoly/Lvalue.$(OBJEXT) InitTweak/GenInit.$(OBJEXT) \
+        InitTweak/InitTweak.$(OBJEXT) Parser/LinkageSpec.$(OBJEXT) \
+        $(am__objects_4) $(am__objects_5) SymTab/Demangle.$(OBJEXT) \
+        $(am__objects_6) Tuples/TupleAssignment.$(OBJEXT) \
+        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
+        Validate/HandleAttributes.$(OBJEXT) \
+        Validate/FindSpecialDecls.$(OBJEXT)
+am_libdemangle_a_OBJECTS = $(am__objects_7)
+libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
+am__installdirs = "$(DESTDIR)$(cfa_cpplibdir)"
+PROGRAMS = $(cfa_cpplib_PROGRAMS)
+am__objects_8 = main.$(OBJEXT) MakeLibCfa.$(OBJEXT) \
+        CompilationState.$(OBJEXT) $(am__objects_1) \
+        CodeGen/Generate.$(OBJEXT) CodeGen/FixNames.$(OBJEXT) \
+        CodeTools/DeclStats.$(OBJEXT) \
+        CodeTools/ResolvProtoDump.$(OBJEXT) \
+        CodeTools/TrackLoc.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
+        Concurrency/Waitfor.$(OBJEXT) $(am__objects_2) \
+        Common/DebugMalloc.$(OBJEXT) $(am__objects_3) \
+        ControlStruct/ExceptTranslate.$(OBJEXT) GenPoly/Box.$(OBJEXT) \
+        GenPoly/GenPoly.$(OBJEXT) GenPoly/ScrubTyVars.$(OBJEXT) \
+        GenPoly/Lvalue.$(OBJEXT) GenPoly/Specialize.$(OBJEXT) \
+        GenPoly/FindFunction.$(OBJEXT) \
+        GenPoly/InstantiateGeneric.$(OBJEXT) \
+        InitTweak/GenInit.$(OBJEXT) InitTweak/FixInit.$(OBJEXT) \
+        InitTweak/FixGlobalInit.$(OBJEXT) \
+        InitTweak/InitTweak.$(OBJEXT) Parser/parser.$(OBJEXT) \
+        Parser/lex.$(OBJEXT) Parser/TypedefTable.$(OBJEXT) \
+        Parser/ParseNode.$(OBJEXT) Parser/DeclarationNode.$(OBJEXT) \
+        Parser/ExpressionNode.$(OBJEXT) Parser/StatementNode.$(OBJEXT) \
+        Parser/InitializerNode.$(OBJEXT) Parser/TypeData.$(OBJEXT) \
+        Parser/LinkageSpec.$(OBJEXT) Parser/parserutility.$(OBJEXT) \
+        $(am__objects_4) ResolvExpr/AlternativePrinter.$(OBJEXT) \
+        $(am__objects_5) $(am__objects_6) \
         Tuples/TupleAssignment.$(OBJEXT) \
         Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
@@ -297 +258 @@
         Validate/FindSpecialDecls.$(OBJEXT) \
         Virtual/ExpandCasts.$(OBJEXT)
-am____driver_cfa_cpp_OBJECTS = $(am__objects_1)
+am____driver_cfa_cpp_OBJECTS = $(am__objects_8)
 ___driver_cfa_cpp_OBJECTS = $(am____driver_cfa_cpp_OBJECTS)
-___driver_cfa_cpp_DEPENDENCIES =
+am__DEPENDENCIES_1 =
+___driver_cfa_cpp_DEPENDENCIES = $(am__DEPENDENCIES_1) \
+        $(am__DEPENDENCIES_1)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@@ -418 +381 @@
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
-ALLOCA = @ALLOCA@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
@@ -566 +528 @@
 AUTOMAKE_OPTIONS = foreign subdir-objects
 ACLOCAL_AMFLAGS = -I automake
-SRC = main.cc MakeLibCfa.cc CompilationState.cc CodeGen/Generate.cc \
-        CodeGen/CodeGenerator.cc CodeGen/GenType.cc \
-        CodeGen/FixNames.cc CodeGen/FixMain.cc \
-        CodeGen/OperatorTable.cc CodeTools/DeclStats.cc \
+SRC = main.cc MakeLibCfa.cc CompilationState.cc $(SRC_CODEGEN) \
+        CodeGen/Generate.cc CodeGen/FixNames.cc CodeTools/DeclStats.cc \
         CodeTools/ResolvProtoDump.cc CodeTools/TrackLoc.cc \
-        Concurrency/Keywords.cc Concurrency/Waitfor.cc \
-        Common/SemanticError.cc Common/UniqueName.cc \
-        Common/DebugMalloc.cc Common/Assert.cc Common/Heap.cc \
-        Common/Eval.cc ControlStruct/LabelGenerator.cc \
-        ControlStruct/LabelFixer.cc ControlStruct/MLEMutator.cc \
-        ControlStruct/Mutate.cc ControlStruct/ForExprMutator.cc \
+        Concurrency/Keywords.cc Concurrency/Waitfor.cc $(SRC_COMMON) \
+        Common/DebugMalloc.cc $(SRC_CONTROLSTRUCT) \
         ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
@@ -587 +543 @@
         Parser/StatementNode.cc Parser/InitializerNode.cc \
         Parser/TypeData.cc Parser/LinkageSpec.cc \
-        Parser/parserutility.cc ResolvExpr/AlternativeFinder.cc \
-        ResolvExpr/Alternative.cc ResolvExpr/Unify.cc \
-        ResolvExpr/PtrsAssignable.cc ResolvExpr/CommonType.cc \
-        ResolvExpr/ConversionCost.cc ResolvExpr/CastCost.cc \
-        ResolvExpr/PtrsCastable.cc ResolvExpr/AdjustExprType.cc \
-        ResolvExpr/AlternativePrinter.cc ResolvExpr/Resolver.cc \
-        ResolvExpr/ResolveTypeof.cc ResolvExpr/RenameVars.cc \
-        ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \
-        ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
-        ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
-        ResolvExpr/SpecCost.cc ResolvExpr/ResolveAssertions.cc \
-        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/ManglerCommon.cc \
-        SymTab/Validate.cc SymTab/FixFunction.cc SymTab/Autogen.cc \
-        SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \
-        SynTree/PointerType.cc SynTree/ArrayType.cc \
-        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
-        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
-        SynTree/TypeofType.cc SynTree/AttrType.cc \
-        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
-        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
-        SynTree/CommaExpr.cc SynTree/TypeExpr.cc \
-        SynTree/ApplicationExpr.cc SynTree/AddressExpr.cc \
-        SynTree/Statement.cc SynTree/CompoundStmt.cc \
-        SynTree/DeclStmt.cc SynTree/Declaration.cc \
-        SynTree/DeclarationWithType.cc SynTree/ObjectDecl.cc \
-        SynTree/FunctionDecl.cc SynTree/AggregateDecl.cc \
-        SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
-        SynTree/Initializer.cc SynTree/TypeSubstitution.cc \
-        SynTree/Attribute.cc SynTree/DeclReplacer.cc \
+        Parser/parserutility.cc $(SRC_RESOLVEXPR) \
+        ResolvExpr/AlternativePrinter.cc $(SRC_SYMTAB) $(SRC_SYNTREE) \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Validate/HandleAttributes.cc \
         Validate/FindSpecialDecls.cc Virtual/ExpandCasts.cc
+SRCDEMANGLE = CompilationState.cc $(SRC_CODEGEN) \
+        Concurrency/Keywords.cc $(SRC_COMMON) $(SRC_CONTROLSTRUCT) \
+        GenPoly/GenPoly.cc GenPoly/Lvalue.cc InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc Parser/LinkageSpec.cc $(SRC_RESOLVEXPR) \
+        $(SRC_SYMTAB) SymTab/Demangle.cc $(SRC_SYNTREE) \
+        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc Validate/HandleAttributes.cc \
+        Validate/FindSpecialDecls.cc
 MAINTAINERCLEANFILES = ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
-MOSTLYCLEANFILES = Parser/gcc-flags.h Parser/lex.cc Parser/parser.cc \
-        Parser/parser.hh Parser/parser.output
-BUILT_SOURCES = Parser/parser.hh
-AM_YFLAGS = -d -t -v
-
-# put into lib for now
-cfa_cpplibdir = $(CFA_LIBDIR)
-___driver_cfa_cpp_SOURCES = $(SRC)
-___driver_cfa_cpp_LDADD = -ldl                  # yywrap
-AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
-AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
-ARFLAGS = cr
-demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
-demangler_LDADD = libdemangle.a     # yywrap
-noinst_LIBRARIES = libdemangle.a
-libdemangle_a_SOURCES = \
-        SymTab/Demangle.cc \
-        SymTab/ManglerCommon.cc \
-        SynTree/Type.cc \
-        SynTree/VoidType.cc \
-        SynTree/BasicType.cc \
-        SynTree/PointerType.cc \
-        SynTree/ArrayType.cc \
-        SynTree/ReferenceType.cc \
-        SynTree/FunctionType.cc \
-        SynTree/ReferenceToType.cc \
-        SynTree/TupleType.cc \
-        SynTree/TypeofType.cc \
-        SynTree/AttrType.cc \
-        SynTree/VarArgsType.cc \
-        SynTree/ZeroOneType.cc \
-        SynTree/Constant.cc \
-        SynTree/Expression.cc \
-        SynTree/TupleExpr.cc \
-        SynTree/CommaExpr.cc \
-        SynTree/TypeExpr.cc \
-        SynTree/ApplicationExpr.cc \
-        SynTree/AddressExpr.cc \
-        SynTree/Statement.cc \
-        SynTree/CompoundStmt.cc \
-        SynTree/DeclStmt.cc \
-        SynTree/Declaration.cc \
-        SynTree/DeclarationWithType.cc \
-        SynTree/ObjectDecl.cc \
-        SynTree/FunctionDecl.cc \
-        SynTree/AggregateDecl.cc \
-        SynTree/NamedTypeDecl.cc \
-        SynTree/TypeDecl.cc \
-        SynTree/Initializer.cc \
-        SynTree/TypeSubstitution.cc \
-        SynTree/Attribute.cc \
-        SynTree/DeclReplacer.cc \
-        CompilationState.cc \
+MOSTLYCLEANFILES = Parser/lex.cc Parser/parser.cc Parser/parser.hh \
+        Parser/parser.output
+@WITH_LIBPROFILER_TRUE@LIBPROFILER = -lprofiler
+@WITH_LIBTCMALLOC_TRUE@LIBTCMALLOC = -ltcmalloc
+@WITH_LIBTCMALLOC_TRUE@TCMALLOCFLAG = -DTCMALLOC
+SRC_CODEGEN = \
         CodeGen/CodeGenerator.cc \
         CodeGen/FixMain.cc \
-        CodeGen/Generate.cc \
         CodeGen/GenType.cc \
-        CodeGen/OperatorTable.cc \
-        Common/Assert.cc \
-        Common/Eval.cc \
-        Common/SemanticError.cc \
-        Common/UniqueName.cc \
-        Concurrency/Keywords.cc \
+        CodeGen/OperatorTable.cc
+
+SRC_COMMON = \
+      Common/Assert.cc \
+      Common/Eval.cc \
+      Common/PassVisitor.cc \
+      Common/SemanticError.cc \
+      Common/Stats/Counter.cc \
+      Common/Stats/Heap.cc \
+      Common/Stats/Stats.cc \
+      Common/Stats/Time.cc \
+      Common/UniqueName.cc
+
+SRC_CONTROLSTRUCT = \
         ControlStruct/ForExprMutator.cc \
         ControlStruct/LabelFixer.cc \
         ControlStruct/LabelGenerator.cc \
         ControlStruct/MLEMutator.cc \
-        ControlStruct/Mutate.cc \
-        GenPoly/GenPoly.cc \
-        GenPoly/Lvalue.cc \
-        InitTweak/GenInit.cc \
-        InitTweak/InitTweak.cc \
-        Parser/LinkageSpec.cc \
-        ResolvExpr/AdjustExprType.cc \
-        ResolvExpr/Alternative.cc \
-        ResolvExpr/AlternativeFinder.cc \
-        ResolvExpr/ExplodedActual.cc \
-        ResolvExpr/CastCost.cc \
-        ResolvExpr/CommonType.cc \
-        ResolvExpr/ConversionCost.cc \
-        ResolvExpr/CurrentObject.cc \
-        ResolvExpr/FindOpenVars.cc \
-        ResolvExpr/Occurs.cc \
-        ResolvExpr/PolyCost.cc \
-        ResolvExpr/PtrsAssignable.cc \
-        ResolvExpr/PtrsCastable.cc \
-        ResolvExpr/RenameVars.cc \
-        ResolvExpr/ResolveAssertions.cc \
-        ResolvExpr/Resolver.cc \
-        ResolvExpr/ResolveTypeof.cc \
-        ResolvExpr/SpecCost.cc \
-        ResolvExpr/TypeEnvironment.cc \
-        ResolvExpr/Unify.cc \
-        SymTab/Autogen.cc \
-        SymTab/FixFunction.cc \
-        SymTab/Indexer.cc \
-        SymTab/Mangler.cc \
-        SymTab/Validate.cc \
-        Tuples/Explode.cc \
-        Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc \
-        Validate/HandleAttributes.cc \
-        Validate/FindSpecialDecls.cc
-
+        ControlStruct/Mutate.cc
+
+BUILT_SOURCES = Parser/parser.hh
+AM_YFLAGS = -d -t -v
+SRC_RESOLVEXPR = \
+      ResolvExpr/AdjustExprType.cc \
+      ResolvExpr/Alternative.cc \
+      ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/CastCost.cc \
+      ResolvExpr/CommonType.cc \
+      ResolvExpr/ConversionCost.cc \
+      ResolvExpr/CurrentObject.cc \
+      ResolvExpr/ExplodedActual.cc \
+      ResolvExpr/FindOpenVars.cc \
+      ResolvExpr/Occurs.cc \
+      ResolvExpr/PolyCost.cc \
+      ResolvExpr/PtrsAssignable.cc \
+      ResolvExpr/PtrsCastable.cc \
+      ResolvExpr/RenameVars.cc \
+      ResolvExpr/ResolveAssertions.cc \
+      ResolvExpr/Resolver.cc \
+      ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/SpecCost.cc \
+      ResolvExpr/TypeEnvironment.cc \
+      ResolvExpr/Unify.cc
+
+SRC_SYMTAB = \
+      SymTab/Autogen.cc \
+      SymTab/FixFunction.cc \
+      SymTab/Indexer.cc \
+      SymTab/Mangler.cc \
+      SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+
+SRC_SYNTREE = \
+      SynTree/Type.cc \
+      SynTree/VoidType.cc \
+      SynTree/BasicType.cc \
+      SynTree/PointerType.cc \
+      SynTree/ArrayType.cc \
+      SynTree/ReferenceType.cc \
+      SynTree/FunctionType.cc \
+      SynTree/ReferenceToType.cc \
+      SynTree/TupleType.cc \
+      SynTree/TypeofType.cc \
+      SynTree/AttrType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/ZeroOneType.cc \
+      SynTree/Constant.cc \
+      SynTree/Expression.cc \
+      SynTree/TupleExpr.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/TypeExpr.cc \
+      SynTree/ApplicationExpr.cc \
+      SynTree/AddressExpr.cc \
+      SynTree/Statement.cc \
+      SynTree/CompoundStmt.cc \
+      SynTree/DeclStmt.cc \
+      SynTree/Declaration.cc \
+      SynTree/DeclarationWithType.cc \
+      SynTree/ObjectDecl.cc \
+      SynTree/FunctionDecl.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
+      SynTree/Initializer.cc \
+      SynTree/TypeSubstitution.cc \
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc
+
+
+# put into lib for now
+cfa_cpplibdir = $(CFA_LIBDIR)
+___driver_cfa_cpp_SOURCES = $(SRC)
+___driver_cfa_cpp_LDADD = -ldl $(LIBPROFILER) $(LIBTCMALLOC)
+AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++14 $(TCMALLOCFLAG)
+AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
+ARFLAGS = cr
+demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
+demangler_LDADD = libdemangle.a -ldl                    # yywrap
+noinst_LIBRARIES = libdemangle.a
+libdemangle_a_SOURCES = $(SRCDEMANGLE)
 all: $(BUILT_SOURCES)
         $(MAKE) $(AM_MAKEFLAGS) all-am
@@ -762 +704 @@
 clean-noinstLIBRARIES:
         -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
-SymTab/$(am__dirstamp):
-        @$(MKDIR_P) SymTab
-        @: > SymTab/$(am__dirstamp)
-SymTab/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) SymTab/$(DEPDIR)
-        @: > SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/Demangle.$(OBJEXT): SymTab/$(am__dirstamp) \
-        SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/ManglerCommon.$(OBJEXT): SymTab/$(am__dirstamp) \
-        SymTab/$(DEPDIR)/$(am__dirstamp)
-SynTree/$(am__dirstamp):
-        @$(MKDIR_P) SynTree
-        @: > SynTree/$(am__dirstamp)
-SynTree/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) SynTree/$(DEPDIR)
-        @: > SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/AddressExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/AggregateDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
-        SynTree/$(DEPDIR)/$(am__dirstamp)
 CodeGen/$(am__dirstamp):
         @$(MKDIR_P) CodeGen
@@ -856 +714 @@
 CodeGen/FixMain.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
-CodeGen/Generate.$(OBJEXT): CodeGen/$(am__dirstamp) \
-        CodeGen/$(DEPDIR)/$(am__dirstamp)
 CodeGen/GenType.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
 CodeGen/OperatorTable.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
+Concurrency/$(am__dirstamp):
+        @$(MKDIR_P) Concurrency
+        @: > Concurrency/$(am__dirstamp)
+Concurrency/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) Concurrency/$(DEPDIR)
+        @: > Concurrency/$(DEPDIR)/$(am__dirstamp)
+Concurrency/Keywords.$(OBJEXT): Concurrency/$(am__dirstamp) \
+        Concurrency/$(DEPDIR)/$(am__dirstamp)
 Common/$(am__dirstamp):
         @$(MKDIR_P) Common
@@ -872 +736 @@
 Common/Eval.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
+Common/PassVisitor.$(OBJEXT): Common/$(am__dirstamp) \
+        Common/$(DEPDIR)/$(am__dirstamp)
 Common/SemanticError.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
+Common/Stats/$(am__dirstamp):
+        @$(MKDIR_P) Common/Stats
+        @: > Common/Stats/$(am__dirstamp)
+Common/Stats/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) Common/Stats/$(DEPDIR)
+        @: > Common/Stats/$(DEPDIR)/$(am__dirstamp)
+Common/Stats/Counter.$(OBJEXT): Common/Stats/$(am__dirstamp) \
+        Common/Stats/$(DEPDIR)/$(am__dirstamp)
+Common/Stats/Heap.$(OBJEXT): Common/Stats/$(am__dirstamp) \
+        Common/Stats/$(DEPDIR)/$(am__dirstamp)
+Common/Stats/Stats.$(OBJEXT): Common/Stats/$(am__dirstamp) \
+        Common/Stats/$(DEPDIR)/$(am__dirstamp)
+Common/Stats/Time.$(OBJEXT): Common/Stats/$(am__dirstamp) \
+        Common/Stats/$(DEPDIR)/$(am__dirstamp)
 Common/UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
-Concurrency/$(am__dirstamp):
-        @$(MKDIR_P) Concurrency
-        @: > Concurrency/$(am__dirstamp)
-Concurrency/$(DEPDIR)/$(am__dirstamp):
-        @$(MKDIR_P) Concurrency/$(DEPDIR)
-        @: > Concurrency/$(DEPDIR)/$(am__dirstamp)
-Concurrency/Keywords.$(OBJEXT): Concurrency/$(am__dirstamp) \
-        Concurrency/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/$(am__dirstamp):
         @$(MKDIR_P) ControlStruct
@@ -940 +812 @@
 ResolvExpr/AlternativeFinder.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/CastCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/CommonType.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/ConversionCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/CurrentObject.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/ExplodedActual.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
-ResolvExpr/CastCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
-        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
-ResolvExpr/CommonType.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
-        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
-ResolvExpr/ConversionCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
-        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
-ResolvExpr/CurrentObject.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
-        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/FindOpenVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
@@ -974 +846 @@
 ResolvExpr/Unify.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+SymTab/$(am__dirstamp):
+        @$(MKDIR_P) SymTab
+        @: > SymTab/$(am__dirstamp)
+SymTab/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) SymTab/$(DEPDIR)
+        @: > SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
@@ -982 +860 @@
 SymTab/Mangler.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/ManglerCommon.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/Validate.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/Demangle.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
+SynTree/$(am__dirstamp):
+        @$(MKDIR_P) SynTree
+        @: > SynTree/$(am__dirstamp)
+SynTree/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) SynTree/$(DEPDIR)
+        @: > SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Type.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/VoidType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/BasicType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/PointerType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ReferenceType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/FunctionType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ReferenceToType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TupleType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeofType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/AttrType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Expression.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TupleExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/CommaExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ApplicationExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/AddressExpr.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Statement.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/CompoundStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclStmt.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Declaration.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclarationWithType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/ObjectDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/FunctionDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/AggregateDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/NamedTypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeDecl.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Initializer.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/TypeSubstitution.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/DeclReplacer.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
@@ -990 +946 @@
         @$(MKDIR_P) Tuples/$(DEPDIR)
         @: > Tuples/$(DEPDIR)/$(am__dirstamp)
-Tuples/Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
-        Tuples/$(DEPDIR)/$(am__dirstamp)
 Tuples/TupleAssignment.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
 Tuples/TupleExpansion.$(OBJEXT): Tuples/$(am__dirstamp) \
+        Tuples/$(DEPDIR)/$(am__dirstamp)
+Tuples/Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
 Validate/$(am__dirstamp):
@@ -1060 +1016 @@
         echo " rm -f" $$list; \
         rm -f $$list
+CodeGen/Generate.$(OBJEXT): CodeGen/$(am__dirstamp) \
+        CodeGen/$(DEPDIR)/$(am__dirstamp)
 CodeGen/FixNames.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
@@ -1077 +1035 @@
         Concurrency/$(DEPDIR)/$(am__dirstamp)
 Common/DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
-        Common/$(DEPDIR)/$(am__dirstamp)
-Common/Heap.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/ExceptTranslate.$(OBJEXT):  \
@@ -1149 +1105 @@
         -rm -f CodeTools/*.$(OBJEXT)
         -rm -f Common/*.$(OBJEXT)
+        -rm -f Common/Stats/*.$(OBJEXT)
         -rm -f Concurrency/*.$(OBJEXT)
         -rm -f ControlStruct/*.$(OBJEXT)
@@ -1179 +1136 @@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/DebugMalloc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/Eval.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/Heap.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/PassVisitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/SemanticError.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/UniqueName.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Counter.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Heap.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Stats.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/Stats/$(DEPDIR)/Time.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Keywords.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/Waitfor.Po@am__quote@
@@ -1444 +1405 @@
         -rm -f Common/$(DEPDIR)/$(am__dirstamp)
         -rm -f Common/$(am__dirstamp)
+        -rm -f Common/Stats/$(DEPDIR)/$(am__dirstamp)
+        -rm -f Common/Stats/$(am__dirstamp)
         -rm -f Concurrency/$(DEPDIR)/$(am__dirstamp)
         -rm -f Concurrency/$(am__dirstamp)
@@ -1481 +1444 @@
 
 distclean: distclean-am
-        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Common/Stats/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
         -rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
@@ -1527 +1490 @@
 
 maintainer-clean: maintainer-clean-am
-        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) CodeGen/$(DEPDIR) CodeTools/$(DEPDIR) Common/$(DEPDIR) Common/Stats/$(DEPDIR) Concurrency/$(DEPDIR) ControlStruct/$(DEPDIR) GenPoly/$(DEPDIR) InitTweak/$(DEPDIR) Parser/$(DEPDIR) ResolvExpr/$(DEPDIR) SymTab/$(DEPDIR) SynTree/$(DEPDIR) Tuples/$(DEPDIR) Validate/$(DEPDIR) Virtual/$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
@@ -1567 +1530 @@
 
 
-Parser/gcc-flags.h :
-        ${AM_V_GEN}$(CC) -dM -E - < /dev/null | sed 's/define /define __GCC__/' > $(@)
-
-Parser/lex.ll : Parser/gcc-flags.h
+$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/SynTree/Type.h
+
+$(srcdir)/SynTree/Type.h : BasicTypes-gen.cc
+        ${AM_V_GEN}${CXXCOMPILE} $< -o BasicTypes-gen -Wall -Wextra
+        @./BasicTypes-gen
+        @rm BasicTypes-gen
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov  1 20:54:26 2018
-// Update Count     : 1108
+// Last Modified On : Fri Feb  1 16:49:17 2019
+// Update Count     : 1113
 //
 
@@ -41 +41 @@
 
 // These must harmonize with the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" };
-const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "int128",
+                                                                                                   "float", "double", "long double", "float80", "float128",
+                                                                                                   "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames" };
+const char * DeclarationNode::complexTypeNames[] = { "_Complex", "NoComplexTypeNames", "_Imaginary" }; // Imaginary unsupported => parse, but make invisible and print error message
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
 const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  4 21:24:45 2018
-// Update Count     : 802
+// Last Modified On : Sun Mar 10 16:10:32 2019
+// Update Count     : 976
 //
 
@@ -51 +51 @@
 extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
 
-static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
-static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
-static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
-static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
+// static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
+// static inline bool checkZ( char c ) { return c == 'z' || c == 'Z'; }
+// static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
+static inline bool checkF80( char c ) { return c == 'w' || c == 'W'; }
+static inline bool checkF128( char c ) { return c == 'q' || c == 'Q'; }
+static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
 static inline bool checkB( char c ) { return c == 'b' || c == 'B'; }
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
-
-static const char * lnthsInt[2][6] = {
-        { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", },
-        { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", }
-}; // lnthsInt
-
-static inline void checkLNInt( string & str, int & lnth, int & size ) {
-        string::size_type posn = str.find_first_of( "lL" ), start = posn;
-  if ( posn == string::npos ) return;
-        size = 4;                                                                                       // assume largest size
-        posn += 1;                                                                                      // advance to size
-        if ( str[posn] == '8' ) {                                                       // 8
-                lnth = 0;
-        } else if ( str[posn] == '1' ) {
-                posn += 1;
-                if ( str[posn] == '6' ) {                                               // 16
-                        lnth = 1;
+// static inline bool checkN( char c ) { return c == 'n' || c == 'N'; }
+
+void lnthSuffix( string & str, int & type, int & ltype ) {
+        string::size_type posn = str.find_last_of( "lL" );
+
+        if ( posn == string::npos ) return;                                     // no suffix
+        if ( posn == str.length() - 1 ) { type = 3; return; } // no length => long
+
+        string::size_type next = posn + 1;                                      // advance to length
+        if ( str[next] == '3' ) {                                                       // 32
+                type = ltype = 2;
+        } else if ( str[next] == '6' ) {                                        // 64
+                type = ltype = 3;
+        } else if ( str[next] == '8' ) {                                        // 8
+                type = ltype = 1;
+        } else if ( str[next] == '1' ) {
+                if ( str[next + 1] == '6' ) {                                   // 16
+                        type = ltype = 0;
                 } else {                                                                                // 128
-                        posn += 1;
-                        lnth = 5;
-                } // if
-        } else {
-                if ( str[posn] == '3' ) {                                               // 32
-                        lnth = 2;
-                } else if ( str[posn] == '6' ) {                                // 64
-                        lnth = 3;
-                } else {
-                        assertf( false, "internal error, bad integral length %s", str.c_str() );
-                } // if
-                posn += 1;
-        } // if
-        str.erase( start, posn - start + 1 );                           // remove length suffix
-} // checkLNInt
+                        type = 5; ltype = 6;
+                } // if
+        } // if
+        // remove "lL" for these cases because it may not imply long
+        str.erase( posn );                                                                      // remove length
+} // lnthSuffix
+
+void valueToType( unsigned long long int & v, bool dec, int & type, bool & Unsigned ) {
+        // use value to determine type
+        if ( v <= INT_MAX ) {                                                           // signed int
+                type = 2;
+        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
+                type = 2;
+                Unsigned = true;                                                                // unsigned
+        } else if ( v <= LONG_MAX ) {                                           // signed long int
+                type = 3;
+        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
+                type = 3;
+                Unsigned = true;                                                                // unsigned long int
+        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
+                type = 4;
+        } else {                                                                                        // unsigned long long int
+                type = 4;
+                Unsigned = true;                                                                // unsigned long long int
+        } // if
+} // valueToType
 
 Expression * build_constantInteger( string & str ) {
-        static const BasicType::Kind kind[2][6] = {
-                // short (h) must be before char (hh)
+        static const BasicType::Kind kind[2][7] = {
+                // 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, },
         };
 
-        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
-        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
-        int lnth = -1;                                                                          // literal length
+        static const char * lnthsInt[2][6] = {
+                { "int16_t",  "int8_t",  "int32_t",  "int64_t",  "size_t",  "uintptr_t", },
+                { "uint16_t", "uint8_t", "uint32_t", "uint64_t", "size_t",  "uintptr_t", },
+        }; // lnthsInt
 
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last subscript of constant
         Expression * ret;
+        //string fred( str );
+
+        int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
+        int ltype = -1;                                                                         // 0 => 16 bits, 1 => 8 bits, 2 => 32 bits, 3 => 64 bits, 4 => size_t, 5 => intptr, 6 => pointer
+        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
 
         // special constants
@@ -119 +139 @@
         } // if
 
-        // Cannot be "0"
+        // Cannot be just "0"/"1"; sscanf stops at the suffix, if any; value goes over the wall => always generate
 
         if ( str[0] == '0' ) {                                                          // radix character ?
@@ -127 +147 @@
                         //printf( "%llx %llu\n", v, v );
                 } else if ( checkB( str[1] ) ) {                                // binary constant ?
-                        v = 0;
-                        for ( unsigned int i = 2;; i += 1 ) {           // compute value
+                        v = 0;                                                                          // compute value
+                        for ( unsigned int i = 2;; ) {                          // ignore prefix
                                 if ( str[i] == '1' ) v |= 1;
-                          if ( i == last ) break;
+                                i += 1;
+                          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
                                 v <<= 1;
                         } // for
-                        //printf( "%llx %llu\n", v, v );
+                        //printf( "%#llx %llu\n", v, v );
                 } else {                                                                                // octal constant
                         sscanf( (char *)str.c_str(), "%llo", &v );
-                        //printf( "%llo %llu\n", v, v );
+                        //printf( "%#llo %llu\n", v, v );
                 } // if
         } else {                                                                                        // decimal constant ?
                 sscanf( (char *)str.c_str(), "%llu", &v );
-                //printf( "%llu %llu\n", v, v );
-        } // if
-
-        if ( v <= INT_MAX ) {                                                           // signed int
-                size = 2;
-        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
-                size = 2;
-                Unsigned = true;                                                                // unsigned
-        } else if ( v <= LONG_MAX ) {                                           // signed long int
-                size = 3;
-        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
-                size = 3;
-                Unsigned = true;                                                                // unsigned long int
-        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
-                size = 4;
-        } else {                                                                                        // unsigned long long int
-                size = 4;
-                Unsigned = true;                                                                // unsigned long long int
-        } // if
-
-        // At least one digit in integer constant, so safe to backup while looking for suffix.
-
-        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
-                Unsigned = true;
-                if ( checkL( str[last - 1] ) ) {                                // suffix 'l' ?
-                        size = 3;
-                        if ( checkL( str[last - 2] ) ) {                        // suffix "ll" ?
-                                size = 4;
+                //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 ( !( 0 <= type && type <= 6 ) ) { printf( "%s %lu %d %s\n", fred.c_str(), fred.length(), type, str.c_str() ); }
+        assert( 0 <= type && type <= 6 );
+
+        // Constant type is correct for overload resolving.
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
+        if ( Unsigned && type < 2 ) {                                           // hh or h, less than int ?
+                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+        } else if ( ltype != -1 ) {                                                     // explicit length ?
+                if ( ltype == 6 ) {                                                             // int128, (int128)constant
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                } else {                                                                                // explicit length, (length_type)constant
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
+                        if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant )
+                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );
                         } // if
-                } else if ( checkH( str[last - 1] ) ) {                 // suffix 'h' ?
-                        size = 0;
-                        if ( checkH( str[last - 2] ) ) {                        // suffix "hh" ?
-                                size = 1;
-                        } // if
-                        str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
-                } else {                                                                                // suffix "ln" ?
-                        checkLNInt( str, lnth, size );
-                } // if
-        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
-                size = 3;
-                if ( checkL( str[last - 1] ) ) {                                // suffix 'll' ?
-                        size = 4;
-                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
-                                Unsigned = true;
-                        } // if
-                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
-                        Unsigned = true;
-                } // if
-        } else if ( checkH( str[ last ] ) ) {                           // suffix 'h' ?
-                size = 0;
-                if ( checkH( str[last - 1] ) ) {                                // suffix "hh" ?
-                        size = 1;
-                        if ( checkU( str[last - 2] ) ) {                        // suffix 'u' ?
-                                Unsigned = true;
-                        } // if
-                } else if ( checkU( str[last - 1] ) ) {                 // suffix 'u' ?
-                        Unsigned = true;
-                } // if
-                str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
-        } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
-                lnth = 4;
-                str.erase( last, 1 );                                                   // remove 'z'
-        } else {                                                                                        // suffix "ln" ?
-                checkLNInt( str, lnth, size );
-        } // if
-
-        assert( 0 <= size && size < 6 );
-        // Constant type is correct for overload resolving.
-        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
-        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
-                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
-                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
-        } else if ( lnth != -1 ) {                                                      // explicit length ?
-                if ( lnth == 5 ) {                                                              // int128 ?
-                        size = 5;
-                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
-                } else {
-                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
-                } // if
-        } // if
-  CLEANUP:
-
+                } // if
+        } // if
+
+  CLEANUP: ;
         delete &str;                                                                            // created by lex
         return ret;
@@ -227 +229 @@
 
 
-static inline void checkLNFloat( string & str, int & lnth, int & size ) {
-        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+static inline void checkFnxFloat( string & str, size_t last, bool & explnth, int & type ) {
+        string::size_type posn;
+        // floating-point constant has minimum of 2 characters, 1. or .1, so safe to look ahead
+        if ( str[1] == 'x' ) {                                                          // hex ?
+                posn = str.find_last_of( "pP" );                                // back for exponent (must have)
+                posn = str.find_first_of( "fF", posn + 1 );             // forward for size (fF allowed in hex constant)
+        } else {
+                posn = str.find_last_of( "fF" );                                // back for size (fF not allowed)
+        } // if
   if ( posn == string::npos ) return;
-        size = 2;                                                                                       // assume largest size
-        lnth = 0;
+        explnth = true;
         posn += 1;                                                                                      // advance to size
         if ( str[posn] == '3' ) {                                                       // 32
-                size = 0;
+                if ( str[last] != 'x' ) type = 6;
+                else type = 7;
         } else if ( str[posn] == '6' ) {                                        // 64
-                size = 1;
-        } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
-                size = 2;
-                if ( str[posn] == '1' ) posn += 1;
+                if ( str[last] != 'x' ) type = 8;
+                else type = 9;
+        } else if ( str[posn] == '8' ) {                                        // 80
+                type = 3;
+        } else if ( str[posn] == '1' ) {                                        // 16/128
+                if ( str[posn + 1] == '6' ) {                                   // 16
+                        type = 5;
+                } else {                                                                                // 128
+                        if ( str[last] != 'x' ) type = 10;
+                        else type = 11;
+                } // if
         } else {
                 assertf( false, "internal error, bad floating point length %s", str.c_str() );
         } // if
-        posn += 1;
-        str.erase( start, posn - start + 1 );                           // remove length suffix
-} // checkLNFloat
+} // checkFnxFloat
 
 
 Expression * build_constantFloat( string & str ) {
-        static const BasicType::Kind kind[2][3] = {
-                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
-                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
+        static const BasicType::Kind kind[2][12] = {
+                { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x },
+                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
         };
 
-        bool complx = false;                                                            // real, complex
-        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
-        int lnth = -1;                                                                          // literal length
-        // floating-point constant has minimum of 2 characters: 1. or .1
+        // floating-point constant has minimum of 2 characters 1. or .1
         size_t last = str.length() - 1;
         double v;
+        int type;                                                                                       // 0 => float, 1 => double, 3 => long double, ...
+        bool complx = false;                                                            // real, complex
+        bool explnth = false;                                                           // explicit literal length
 
         sscanf( str.c_str(), "%lg", &v );
@@ -269 +283 @@
 
         if ( checkF( str[last] ) ) {                                            // float ?
-                size = 0;
+                type = 0;
         } else if ( checkD( str[last] ) ) {                                     // double ?
-                size = 1;
+                type = 1;
         } else if ( checkL( str[last] ) ) {                                     // long double ?
-                size = 2;
+                type = 2;
+        } else if ( checkF80( str[last] ) ) {                           // __float80 ?
+                type = 3;
+        } else if ( checkF128( str[last] ) ) {                          // __float128 ?
+                type = 4;
         } else {
-                size = 1;                                                                               // double (default)
-                checkLNFloat( str, lnth, size );
-        } // if
+                type = 1;                                                                               // double (default if no suffix)
+                checkFnxFloat( str, last, explnth, type );
+        } // if
+
         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
                 complx = true;
         } // if
 
-        assert( 0 <= size && size < 3 );
-        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
-        if ( lnth != -1 ) {                                                                     // explicit length ?
-                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false );
+        assert( 0 <= type && type < 12 );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][type] ), str, v ) );
+        if ( explnth ) {                                                                        // explicit length ?
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][type] ), false );
         } // if
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov  1 20:54:53 2018
-// Update Count     : 854
+// Last Modified On : Mon Apr 15 14:22:39 2019
+// Update Count     : 874
 //
 
@@ -132 +132 @@
         void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
 
-        Expression *get_expr() const { return expr.get(); }
         template<typename T>
         bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
 
         Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
+
+        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
   private:
         bool extension = false;
-        std::unique_ptr<Expression> expr;
 }; // ExpressionNode
 
@@ -206 +206 @@
 class DeclarationNode : public ParseNode {
   public:
-        // These enumerations must harmonize with their names.
-        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
+        // These enumerations must harmonize with their names in DeclarationNode.cc.
+        enum BasicType { Void, Bool, Char, Int, Int128,
+                                         Float, Double, LongDouble, uuFloat80, uuFloat128,
+                                         uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
         static const char * basicTypeNames[];
-        enum ComplexType { Complex, Imaginary, NoComplexType };
+        enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
         static const char * complexTypeNames[];
         enum Signedness { Signed, Unsigned, NoSignedness };

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov  2 07:54:26 2018
-// Update Count     : 624
+// Last Modified On : Wed Feb 13 18:16:23 2019
+// Update Count     : 649
 //
 
@@ -666 +666 @@
 
           case DeclarationNode::Float:
-          case DeclarationNode::Float80:
-          case DeclarationNode::Float128:
           case DeclarationNode::Double:
           case DeclarationNode::LongDouble:                                     // not set until below
-                static BasicType::Kind floattype[3][3] = {
-                        { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
-                        { BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary },
-                        { BasicType::Float, BasicType::Double, BasicType::LongDouble },
+          case DeclarationNode::uuFloat80:
+          case DeclarationNode::uuFloat128:
+          case DeclarationNode::uFloat16:
+          case DeclarationNode::uFloat32:
+          case DeclarationNode::uFloat32x:
+          case DeclarationNode::uFloat64:
+          case DeclarationNode::uFloat64x:
+          case DeclarationNode::uFloat128:
+          case DeclarationNode::uFloat128x:
+                static BasicType::Kind floattype[2][12] = {
+                        { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex, },
+                        { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x, },
                 };
 
@@ -686 +692 @@
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
+                if ( td->complextype == DeclarationNode::Imaginary ) {
+                        genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
+                } // if
+                if ( (td->basictype == DeclarationNode::uuFloat80 || td->basictype == DeclarationNode::uuFloat128) && td->complextype == DeclarationNode::Complex ) { // gcc unsupported
+                        genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
+                } // if
                 if ( td->length == DeclarationNode::Long ) {
                         const_cast<TypeData *>(td)->basictype = DeclarationNode::LongDouble;
                 } // if
 
-                if ( td->basictype == DeclarationNode::Float80 || td->basictype == DeclarationNode::Float128 ) {
-                        // if ( td->complextype != DeclarationNode::NoComplexType ) {
-                        //      genTSError( DeclarationNode::complexTypeNames[ td->complextype ], td->basictype );
-                        // }
-                        if ( td->basictype == DeclarationNode::Float80 ) ret = BasicType::Float80;
-                        else ret = BasicType::Float128;
-                        break;
-                }
-
                 ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ];
+                //printf( "XXXX %d %d %d %d\n", td->complextype, td->basictype, DeclarationNode::Float, ret );
                 break;
 

src/Parser/TypeData.h

@@ -31 +31 @@
         struct Aggregate_t {
                 DeclarationNode::Aggregate kind;
-                const std::string * name;
-                DeclarationNode * params;
-                ExpressionNode * actuals;                                               // holds actual parameters later applied to AggInst
-                DeclarationNode * fields;
+                const std::string * name = nullptr;
+                DeclarationNode * params = nullptr;
+                ExpressionNode * actuals = nullptr;                                             // holds actual parameters later applied to AggInst
+                DeclarationNode * fields = nullptr;
                 bool body;
                 bool anon;
 
                 bool tagged;
-                const std::string * parent;
+                const std::string * parent = nullptr;
         };
 
         struct AggInst_t {
-                TypeData * aggregate;
-                ExpressionNode * params;
+                TypeData * aggregate = nullptr;
+                ExpressionNode * params = nullptr;
                 bool hoistType;
         };
 
         struct Array_t {
-                ExpressionNode * dimension;
+                ExpressionNode * dimension = nullptr;
                 bool isVarLen;
                 bool isStatic;
@@ -55 +55 @@
 
         struct Enumeration_t {
-                const std::string * name;
-                DeclarationNode * constants;
+                const std::string * name = nullptr;
+                DeclarationNode * constants = nullptr;
                 bool body;
                 bool anon;
@@ -62 +62 @@
 
         struct Function_t {
-                mutable DeclarationNode * params;                               // mutables modified in buildKRFunction
-                mutable DeclarationNode * idList;                               // old-style
-                mutable DeclarationNode * oldDeclList;
-                StatementNode * body;
-                ExpressionNode * withExprs;                                             // expressions from function's with_clause
+                mutable DeclarationNode * params = nullptr;                             // mutables modified in buildKRFunction
+                mutable DeclarationNode * idList = nullptr;                             // old-style
+                mutable DeclarationNode * oldDeclList = nullptr;
+                StatementNode * body = nullptr;
+                ExpressionNode * withExprs = nullptr;                                           // expressions from function's with_clause
         };
 
         struct Symbolic_t {
-                const std::string * name;
+                const std::string * name = nullptr;
                 bool isTypedef;                                                                 // false => TYPEGENname, true => TYPEDEFname
-                DeclarationNode * params;
-                ExpressionNode * actuals;
-                DeclarationNode * assertions;
+                DeclarationNode * params = nullptr;
+                ExpressionNode * actuals = nullptr;
+                DeclarationNode * assertions = nullptr;
         };
 
         struct Qualified_t {                                                            // qualified type S.T
-                TypeData * parent;
-                TypeData * child;
+                TypeData * parent = nullptr;
+                TypeData * child = nullptr;
         };
 
@@ -93 +93 @@
 
         Type::Qualifiers qualifiers;
-        DeclarationNode * forall;
+        DeclarationNode * forall = nullptr;
 
         Aggregate_t aggregate;
@@ -102 +102 @@
         Symbolic_t symbolic;
         Qualified_t qualified;
-        DeclarationNode * tuple;
-        ExpressionNode * typeexpr;
+        DeclarationNode * tuple = nullptr;
+        ExpressionNode * typeexpr = nullptr;
 
         TypeData( Kind k = Unknown );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu Nov  1 20:57:35 2018
- * Update Count     : 687
+ * Last Modified On : Wed May 15 21:25:27 2019
+ * Update Count     : 708
  */
 
@@ -39 +39 @@
 using namespace std;
 
+#include "config.h"                                                                             // configure info
 #include "ParseNode.h"
 #include "TypedefTable.h"
@@ -59 +60 @@
 #define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
 #define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
+
+#ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
+#define FLOATXX(v) KEYWORD_RETURN(v);
+#else
+#define FLOATXX(v) IDENTIFIER_RETURN(); 
+#endif // HAVE_KEYWORDS_FLOATXX
 
 void rm_underscore() {
@@ -92 +99 @@
 hex_quad {hex}("_"?{hex}){3}
 size_opt (8|16|32|64|128)?
-length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
-integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?
+                                // CFA: explicit l8/l16/l32/l64/l128, char 'hh', short 'h', int 'n'
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hHnN])
+                                // CFA: size_t 'z', pointer 'p', which define a sign and length
+integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]|[pP]))?
 
 octal_digits ({octal})|({octal}({octal}|"_")*{octal})
@@ -112 +121 @@
                                 // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
-floating_size 32|64|80|128
-floating_length ([fFdDlL]|[lL]{floating_size})
+floating_size 16|32|32x|64|64x|80|128|128x
+floating_length ([fFdDlLwWqQ]|[fF]{floating_size})
 floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
@@ -217 +226 @@
 char                    { KEYWORD_RETURN(CHAR); }
 choose                  { KEYWORD_RETURN(CHOOSE); }                             // CFA
+coerce                  { KEYWORD_RETURN(COERCE); }                             // CFA
 _Complex                { KEYWORD_RETURN(COMPLEX); }                    // C99
 __complex               { KEYWORD_RETURN(COMPLEX); }                    // GCC
@@ -240 +250 @@
 finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
-_Float32                { KEYWORD_RETURN(FLOAT); }                              // GCC
-_Float32x               { KEYWORD_RETURN(FLOAT); }                              // GCC
-_Float64                { KEYWORD_RETURN(DOUBLE); }                             // GCC
-_Float64x               { KEYWORD_RETURN(DOUBLE); }                             // GCC
-__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
-float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
-_Float128               { KEYWORD_RETURN(FLOAT128); }                   // GCC
-_Float128x              { KEYWORD_RETURN(FLOAT128); }                   // GCC
-__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
-float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
+__float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
+float80                 { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
+__float128              { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
+float128                { KEYWORD_RETURN(uuFLOAT128); }                 // GCC
+_Float16                { FLOATXX(uFLOAT16); }                                  // GCC
+_Float32                { FLOATXX(uFLOAT32); }                                  // GCC
+_Float32x               { FLOATXX(uFLOAT32X); }                                 // GCC
+_Float64                { FLOATXX(uFLOAT64); }                                  // GCC
+_Float64x               { FLOATXX(uFLOAT64X); }                                 // GCC
+_Float128               { FLOATXX(uFLOAT128); }                                 // GCC
+_Float128x              { FLOATXX(uFLOAT128); }                                 // GCC
 for                             { KEYWORD_RETURN(FOR); }
 forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
 fortran                 { KEYWORD_RETURN(FORTRAN); }
 ftype                   { KEYWORD_RETURN(FTYPE); }                              // CFA
+generator               { KEYWORD_RETURN(GENERATOR); }                  // CFA
 _Generic                { KEYWORD_RETURN(GENERIC); }                    // C11
 goto                    { KEYWORD_RETURN(GOTO); }

src/Parser/module.mk

@@ -31 +31 @@
        Parser/parserutility.cc
 
+SRCDEMANGLE += \
+        Parser/LinkageSpec.cc
+
+
 MOSTLYCLEANFILES += Parser/lex.cc Parser/parser.cc Parser/parser.hh Parser/parser.output

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov  8 18:08:23 2018
-// Update Count     : 4052
+// Last Modified On : Wed May 15 21:25:27 2019
+// Update Count     : 4296
 //
 
@@ -99 +99 @@
         // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
         DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
-        //cur->addType( specifier );
-        for ( cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
         declList->addType( cl );
-//      delete cl;
         return declList;
 } // distAttr
@@ -175 +173 @@
 DeclarationNode * fieldDecl( DeclarationNode * typeSpec, DeclarationNode * fieldList ) {
         if ( ! fieldList ) {                                                            // field declarator ?
-                if ( ! ( typeSpec->type && typeSpec->type->kind == TypeData::Aggregate ) ) {
+                if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) {
                         stringstream ss;
                         typeSpec->type->print( ss );
@@ -187 +185 @@
 
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->expr.get());
         if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
         type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
@@ -193 +191 @@
         return new ForCtrl(
                 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
-                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
-                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
-                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : 0,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : 0 );
 } // forCtrl
 
 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
-        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
+                if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
+                        return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+                } else {
+                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
+                } // if
         } else {
                 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
@@ -260 +265 @@
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
-%token FORALL MUTEX VIRTUAL                                                             // CFA
+%token FORALL MUTEX VIRTUAL COERCE                                              // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
-%token INT128 FLOAT80 FLOAT128                                                  // GCC
+%token INT128 uuFLOAT80 uuFLOAT128                                              // GCC
+%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
@@ -269 +275 @@
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
-%token COROUTINE MONITOR THREAD                                                 // CFA
+%token GENERATOR COROUTINE MONITOR THREAD                               // CFA
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
@@ -324 +330 @@
 %type<en> argument_expression_list              argument_expression                     default_initialize_opt
 %type<ifctl> if_control_expression
-%type<fctl> for_control_expression
+%type<fctl> for_control_expression              for_control_expression_list
 %type<compop> inclexcl
 %type<en> subrange
 %type<decl> asm_name_opt
-%type<en> asm_operands_opt asm_operands_list asm_operand
+%type<en> asm_operands_opt                              asm_operands_list                       asm_operand
 %type<label> label_list
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
-%type<genexpr> generic_association generic_assoc_list
+%type<genexpr> generic_association              generic_assoc_list
 
 // statements
@@ -671 +677 @@
         // empty
                 { $$ = nullptr; }
-        | '?'                                                                                           // CFA, default parameter
+        | '@'                                                                                           // CFA, default parameter
                 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
                 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
@@ -789 +795 @@
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+                // keyword cast cannot be grouped because of reduction in aggregate_key
+        | '(' GENERATOR '&' ')' cast_expression                         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
         | '(' COROUTINE '&' ')' cast_expression                         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
@@ -800 +809 @@
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $5 ), maybeMoveBuildType( $3 ) ) ); }
+        | '(' RETURN type_no_function ')' cast_expression       // CFA
+                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+        | '(' COERCE type_no_function ')' cast_expression       // CFA
+                { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
+        | '(' qualifier_cast_list ')' cast_expression           // CFA
+                { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+        ;
+
+qualifier_cast_list:
+        cast_modifier type_qualifier_name
+        | cast_modifier MUTEX
+        | qualifier_cast_list cast_modifier type_qualifier_name
+        | qualifier_cast_list cast_modifier MUTEX
+        ;
+
+cast_modifier:
+        '-'
+        | '+'
         ;
 
@@ -984 +1011 @@
                 // labels cannot be identifiers 0 or 1 or ATTR_IDENTIFIER
         identifier_or_type_name ':' attribute_list_opt statement
-                {
-                        $$ = $4->add_label( $1, $3 );
-                }
+                { $$ = $4->add_label( $1, $3 ); }
         ;
 
@@ -1002 +1027 @@
         statement_decl
         | statement_decl_list statement_decl
-                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+                { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
         ;
 
@@ -1009 +1034 @@
                 { $$ = new StatementNode( $1 ); }
         | EXTENSION declaration                                                         // GCC
-                {
-                        distExt( $2 );
-                        $$ = new StatementNode( $2 );
-                }
+                { distExt( $2 ); $$ = new StatementNode( $2 ); }
         | function_definition
                 { $$ = new StatementNode( $1 ); }
         | EXTENSION function_definition                                         // GCC
-                {
-                        distExt( $2 );
-                        $$ = new StatementNode( $2 );
-                }
+                { distExt( $2 ); $$ = new StatementNode( $2 ); }
         | statement
         ;
@@ -1026 +1045 @@
         statement
         | statement_list_nodecl statement
-                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+                { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
         ;
 
@@ -1138 +1157 @@
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), $2 ) ); }
-        | FOR '(' push for_control_expression ')' statement pop
+        | FOR '(' push for_control_expression_list ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
@@ -1144 +1163 @@
         ;
 
+for_control_expression_list:
+        for_control_expression
+        | for_control_expression_list ':' for_control_expression
+                // ForCtrl + ForCtrl:
+                //    init + init => multiple declaration statements that are hoisted
+                //    condition + condition => (expression) && (expression)
+                //    change + change => (expression), (expression)
+                {
+                        $1->init->set_last( $3->init );
+                        if ( $1->condition ) {
+                                if ( $3->condition ) {
+                                        $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
+                                } // if
+                        } else $1->condition = $3->condition;
+                        if ( $1->change ) {
+                                if ( $3->change ) {
+                                        $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
+                                } // if
+                        } else $1->change = $3->change;
+                        $$ = $1;
+                }
+        ;
+
 for_control_expression:
-        comma_expression                                                                        // CFA
+        ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( $1, $3, $5 ); }
+        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
+                { $$ = new ForCtrl( $1, $2, $4 ); }
+
+        | comma_expression                                                                      // CFA
                 { $$ = 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" ) ) ) ); }
-        | constant_expression inclexcl constant_expression      // CFA
+        | comma_expression inclexcl comma_expression            // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
+        | comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
         | 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 ';' constant_expression inclexcl constant_expression // CFA
+        | comma_expression ';' comma_expression inclexcl comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
+        | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
-        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( $1, $3, $5 ); }
-        | ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
-        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
-                { $$ = new ForCtrl( $1, $2, $4 ); }
+
+                // There is a S/R conflicit if ~ and -~ are factored out.
+        | comma_expression ';' comma_expression '~' '@'         // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' comma_expression ErangeDown '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); }
+        | comma_expression ';' comma_expression ErangeDown '@' '~' comma_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, $7 ); }
+        | comma_expression ';' comma_expression '~' '@' '~' '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, nullptr ); }
         ;
 
@@ -1771 +1826 @@
         | FLOAT
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
-        | FLOAT80
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
-        | FLOAT128
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
         | DOUBLE
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+        | uuFLOAT80
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }
+        | uuFLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }
+        | uFLOAT16
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }
+        | uFLOAT32
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }
+        | uFLOAT32X
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }
+        | uFLOAT64
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }
+        | uFLOAT64X
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }
+        | uFLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
         | COMPLEX                                                                                       // C99
                 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
@@ -1996 +2063 @@
         | EXCEPTION
                 { yyy = true; $$ = DeclarationNode::Exception; }
+        | GENERATOR
+                { yyy = true; $$ = DeclarationNode::Coroutine; }
         | COROUTINE
                 { yyy = true; $$ = DeclarationNode::Coroutine; }

src/ResolvExpr/AlternativeFinder.cc

@@ -258 +258 @@
                         // - necessary pre-requisite to pruning
                         AltList candidates;
+                        std::list<std::string> errors;
                         for ( unsigned i = 0; i < alternatives.size(); ++i ) {
-                                resolveAssertions( alternatives[i], indexer, candidates );
+                                resolveAssertions( alternatives[i], indexer, candidates, errors );
                         }
                         // fail early if none such
                         if ( mode.failFast && candidates.empty() ) {
                                 std::ostringstream stream;
-                                stream << "No resolvable alternatives for expression " << expr << "\n"
-                                       << "Alternatives with failing assertions are:\n";
-                                printAlts( alternatives, stream, 1 );
+                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                                //        << "Alternatives with failing assertions are:\n";
+                                // printAlts( alternatives, stream, 1 );
+                                for ( const auto& err : errors ) {
+                                        stream << err;
+                                }
                                 SemanticError( expr->location, stream.str() );
                         }

src/ResolvExpr/CommonType.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 06:59:27 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 15:18:17 2017
-// Update Count     : 9
+// Last Modified On : Thu Feb 14 17:10:10 2019
+// Update Count     : 24
 //
 
@@ -176 +176 @@
         }
 
-        static const BasicType::Kind combinedType[][ BasicType::NUMBER_OF_BASIC_TYPES ] =
-        {
-/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary   SignedInt128   UnsignedInt128   Float80   Float128 */
-                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128 },
-                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Float,       BasicType::Float, BasicType::Float80, BasicType::Float128 },
-                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Double,      BasicType::Double, BasicType::Float80, BasicType::Float128 },
-                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDouble,  BasicType::LongDouble, BasicType::BasicType::LongDouble, BasicType::Float128 },
-                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::FloatComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, },
-                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex },
-                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, BasicType::LongDoubleComplex, },
-                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::FloatImaginary,      BasicType::FloatImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, },
-                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::DoubleImaginary,     BasicType::DoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, },
-                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, },
-                /* SignedInt128 */      { BasicType::SignedInt128,      BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, },
-                /* UnsignedInt128 */    { BasicType::UnsignedInt128,    BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::UnsignedInt128,      BasicType::UnsignedInt128, BasicType::Float80, BasicType::Float128, },
-                /* Float80 */   { BasicType::Float80,   BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::Float80,     BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::Float80,     BasicType::Float80, BasicType::Float80, BasicType::Float128 },
-                /* Float128 */  { BasicType::Float128,  BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::Float128,    BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::Float128,    BasicType::Float128, BasicType::Float128, BasicType::Float128 },
-        };
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        #define BT BasicType::
+        static const BasicType::Kind commonTypes[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
+                /*                                      B                       C                      SC                      UC                      SI                     SUI
+                                                        I                      UI                      LI                     LUI                     LLI                    LLUI
+                                                       IB                     UIB                     _FH                     _FH                      _F                     _FC
+                                                        F                      FC                     _FX                    _FXC                      FD                    _FDC
+                                                        D                      DC                    F80X                   _FDXC                     F80                     _FB
+                                                    _FLDC                      FB                      LD                     LDC                    _FBX                  _FLDXC
+                                 */
+                                  {
+                /*     B*/                BT Bool,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     C*/                BT Char,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    SC*/          BT SignedChar,          BT SignedChar,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    UC*/        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    SI*/      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   SUI*/    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     I*/           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,
+                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    UI*/         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,
+                                           BT UnsignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    LI*/       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,
+                                         BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   LUI*/     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,
+                                       BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   LLI*/   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,
+                                     BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  LLUI*/ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
+                                   BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    IB*/        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
+                                          BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
+                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   UIB*/      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
+                                        BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
+                                        BT UnsignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FH*/            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
+                                              BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
+                                              BT uFloat16,            BT uFloat16,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FH*/     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
+                                       BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
+                                       BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                          BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    _F*/            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
+                                              BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
+                                              BT uFloat32,            BT uFloat32,            BT uFloat32,     BT uFloat32Complex,            BT uFloat32,     BT uFloat32Complex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FC*/     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                       BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                       BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
+                                          BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     F*/               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
+                                                 BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
+                                                 BT Float,               BT Float,               BT Float,        BT FloatComplex,               BT Float,        BT FloatComplex,
+                                                 BT Float,        BT FloatComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    FC*/        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
+                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
+                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
+                                          BT FloatComplex,        BT FloatComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FX*/           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
+                                             BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
+                                             BT uFloat32x,           BT uFloat32x,           BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,
+                                             BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  _FXC*/    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
+                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
+                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
+                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    FD*/            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
+                                              BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
+                                              BT uFloat64,            BT uFloat64,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
+                                              BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  _FDC*/     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*     D*/              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
+                                                BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
+                                                BT Double,              BT Double,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
+                                                BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
+                                                BT Double,       BT DoubleComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    DC*/       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
+                                         BT DoubleComplex,       BT DoubleComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  F80X*/           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
+                                             BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
+                                             BT uFloat64x,           BT uFloat64x,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
+                                             BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
+                                             BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /* _FDXC*/    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
+                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   F80*/           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,
+                                             BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,           BT uuFloat80,
+                                             BT uuFloat80,           BT uuFloat80,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,
+                                             BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,
+                                             BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,    BT uFloat64xComplex,           BT uuFloat80,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   _FB*/           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
+                                             BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
+                                             BT uFloat128,           BT uFloat128,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
+                                             BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
+                                             BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,           BT uFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /* _FLDC*/    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
+                                      BT uFloat128Complex,    BT uFloat128Complex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    FB*/          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
+                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
+                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
+                                            BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
+                                            BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,          BT uuFloat128,
+                                      BT uFloat128Complex,          BT uuFloat128,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*    LD*/          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
+                                            BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
+                                            BT LongDouble,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,
+                                            BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,
+                                            BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,
+                                     BT LongDoubleComplex,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*   LDC*/   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
+                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*  _FBX*/          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
+                                            BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
+                                            BT uFloat128x,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                            BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                            BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,          BT uFloat128x,
+                                     BT uFloat128xComplex,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
+                                  },
+                                  {
+                /*_FLDXC*/   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
+                                  },
+        }; // commonTypes
+        #undef BT
+        // GENERATED END
         static_assert(
-                sizeof(combinedType)/sizeof(combinedType[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
+                sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
                 "Each basic type kind should have a corresponding row in the combined type matrix"
         );
@@ -218 +491 @@
         void CommonType::postvisit( BasicType *basicType ) {
                 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
-                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
+                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
                         if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
                                 result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType );
@@ -224 +497 @@
                 } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // use signed int in lieu of the enum/zero/one type
-                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
+                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
                         if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
                                 result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType );

src/ResolvExpr/ConversionCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 15:43:34 2017
-// Update Count     : 10
+// Last Modified On : Mon May  6 14:18:22 2019
+// Update Count     : 25
 //
 
@@ -28 +28 @@
 
 namespace ResolvExpr {
-        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0 };
-        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1,  1, -1 };
-        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0 };
-        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0 };
-        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0 };
-        const Cost Cost::var =       Cost{  0,  0,  0,  1,  0,  0 };
-        const Cost Cost::spec =      Cost{  0,  0,  0,  0, -1,  0 };
-        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  1 };
+#if 0
+        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0,  0 };
+        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1, -1,  1, -1 };
+        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0,  0 };
+        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0,  0 };
+        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0,  0 };
+        const Cost Cost::sign =      Cost{  0,  0,  0,  1,  0,  0,  0 };
+        const Cost Cost::var =       Cost{  0,  0,  0,  0,  1,  0,  0 };
+        const Cost Cost::spec =      Cost{  0,  0,  0,  0,  0, -1,  0 };
+        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  0,  1 };
+#endif
 
 #if 0
@@ -42 +45 @@
 #define PRINT(x)
 #endif
+
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
@@ -179 +183 @@
         }
 
-/*
-            Old
-            ===
-           Double
-             |
-           Float
-             |
-           ULong
-           /   \
-        UInt    Long
-           \   /
-            Int
-             |
-           Ushort
-             |
-           Short
-             |
-           Uchar
-           /   \
-        Schar   Char
-
-                                New
-                                ===
-                       +-----LongDoubleComplex--+
-           LongDouble--+          |             +-LongDoubleImag
-             |         +---DoubleComplex---+         |
-           Double------+        |          +----DoubleImag
-             |           +-FloatComplex-+            |
-           Float---------+              +-------FloatImag
-             |
-          ULongLong
-             |
-          LongLong
-             |
-           ULong
-           /   \
-        UInt    Long
-           \   /
-            Int
-             |
-           Ushort
-             |
-           Short
-             |
-           Uchar
-           /   \
-        Schar   Char
-           \   /
-            Bool
-*/
-
-        static const int costMatrix[][ BasicType::NUMBER_OF_BASIC_TYPES ] = {
-        /* Src \ Dest:  Bool    Char    SChar   UChar   Short   UShort  Int     UInt    Long    ULong   LLong   ULLong  Float   Double  LDbl    FCplex  DCplex  LDCplex FImag   DImag   LDImag  I128,   U128, F80, F128 */
-                /* Bool */      { 0,    1,              1,              2,              3,              4,              5,              6,              6,              7,              8,              9,              12,             13,             14,             12,             13,             14,             -1,             -1,             -1,             10,             11,       14,   15},
-                /* Char */      { -1,   0,              -1,             1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,       13,   14},
-                /* SChar */ { -1,       -1,             0,              1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,       13,   14},
-                /* UChar */ { -1,       -1,             -1,             0,              1,              2,              3,              4,              4,              5,              6,              7,              10,             11,             12,             10,             11,             12,             -1,             -1,             -1,             8,              9,        12,   13},
-                /* Short */ { -1,       -1,             -1,             -1,             0,              1,              2,              3,              3,              4,              5,              6,              9,              10,             11,             9,              10,             11,             -1,             -1,             -1,             7,              8,        11,   12},
-                /* UShort */{ -1,       -1,             -1,             -1,             -1,             0,              1,              2,              2,              3,              4,              5,              8,              9,              10,             8,              9,              10,             -1,             -1,             -1,             6,              7,        10,   11},
-                /* Int */       { -1,   -1,             -1,             -1,             -1,             -1,             0,              1,              1,              2,              3,              4,              7,              8,              9,              7,              8,              9,              -1,             -1,             -1,             5,              6,        9,    10},
-                /* UInt */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,        8,    9},
-                /* Long */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,        8,    9},
-                /* ULong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              5,              6,              7,              5,              6,              7,              -1,             -1,             -1,             3,              4,        7,    8},
-                /* LLong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              4,              5,              6,              4,              5,              6,              -1,             -1,             -1,             2,              3,        6,    7},
-                /* ULLong */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              3,              4,              5,              3,              4,              5,              -1,             -1,             -1,             1,              2,        5,    6},
-
-                /* Float */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              1,              2,              3,              -1,             -1,             -1,             -1,             -1,       2,    3},
-                /* Double */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             1,              2,              -1,             -1,             -1,             -1,             -1,       1,    2},
-                /* LDbl */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,       -1,   1},
-                /* FCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              -1,             -1,             -1,             -1,             -1,       -1,   -1},
-                /* DCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             -1,             -1,             -1,             -1,       -1,   -1},
-                /* LDCplex */{ -1,      -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             -1,             -1,             -1,       -1,   -1},
-                /* FImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              0,              1,              2,              -1,             -1,       -1,   -1},
-                /* DImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              -1,             0,              1,              -1,             -1,       -1,   -1},
-                /* LDImag */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             0,              -1,             -1,       -1,   -1},
-
-                /* I128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             2,              3,              4,              3,              4,              5,              -1,             -1,             -1,             0,              1,        4,    4},
-                /* U128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              2,              3,              4,              -1,             -1,             -1,             -1,             0,        3,    3},
-
-                /* F80 */       { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,       0,    1},
-                /* F128 */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,       -1,   0},
-        };
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        /* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves)
+                                 _Bool
+        char                signed char         unsigned char       
+                  signed short int         unsigned short int       
+                  signed int               unsigned int             
+                  signed long int          unsigned long int        
+                  signed long long int     unsigned long long int   
+                  __int128                 unsigned __int128        
+                  _Float16                 _Float16 _Complex        
+                  _Float32                 _Float32 _Complex        
+                  float                    float _Complex           
+                  _Float32x                _Float32x _Complex       
+                  _Float64                 _Float64 _Complex        
+                  double                   double _Complex          
+                  _Float64x                _Float64x _Complex       
+                             __float80
+                  _Float128                _Float128 _Complex       
+                            __float128
+                  long double              long double _Complex     
+                  _Float128x               _Float128x _Complex      
+        */
+        // GENERATED END
+
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
+                /*             B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
+                /*     B*/ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  16,  18,  17, },
+                /*     C*/ {  -1,   0,   1,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
+                /*    SC*/ {  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
+                /*    UC*/ {  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
+                /*    SI*/ {  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
+                /*   SUI*/ {  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
+                /*     I*/ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
+                /*    UI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
+                /*    LI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
+                /*   LUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
+                /*   LLI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
+                /*  LLUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
+                /*    IB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
+                /*   UIB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
+                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,  10,   9,  11,  10, },
+                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,   6,  -1,  -1,   7,  -1,  -1,   8,  -1,   9, },
+                /*    _F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   9,   8,  10,   9, },
+                /*   _FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,  -1,   6,  -1,  -1,   7,  -1,   8, },
+                /*     F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   7,   9,   8, },
+                /*    FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,  -1,   5,  -1,  -1,   6,  -1,   7, },
+                /*   _FX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   6,   8,   7, },
+                /*  _FXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,  -1,   4,  -1,  -1,   5,  -1,   6, },
+                /*    FD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   5,   7,   6, },
+                /*  _FDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,  -1,   3,  -1,  -1,   4,  -1,   5, },
+                /*     D*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   4,   6,   5, },
+                /*    DC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,  -1,   2,  -1,  -1,   3,  -1,   4, },
+                /*  F80X*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   3,   5,   4, },
+                /* _FDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,  -1,   2,  -1,   3, },
+                /*   F80*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3,   3,   4,   4, },
+                /*   _FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3, },
+                /* _FLDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,   2, },
+                /*    FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3, },
+                /*    LD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2, },
+                /*   LDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1, },
+                /*  _FBX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1, },
+                /*_FLDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
+        }; // costMatrix
+        static const int maxIntCost = 15;
+        // GENERATED END
         static_assert(
                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
-                "Each basic type kind should have a corresponding row in the cost matrix"
+                "Missing row in the cost matrix"
         );
 
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
+        static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
+                /*             B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
+                /*     B*/ {   0,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*     C*/ {  -1,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    SC*/ {  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    UC*/ {  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    SI*/ {  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   SUI*/ {  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*     I*/ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    UI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    LI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   LUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   LLI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*  LLUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    IB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   UIB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*    _F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   _FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*     F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*   _FX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*  _FXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*    FD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*  _FDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*     D*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*    DC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*  F80X*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /* _FDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*   F80*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
+                /*   _FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0, },
+                /* _FLDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
+                /*    FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0, },
+                /*    LD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0, },
+                /*   LDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0, },
+                /*  _FBX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0, },
+                /*_FLDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
+        }; // signMatrix
+        // GENERATED END
+        static_assert(
+                sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
+                "Missing row in the sign matrix"
+        );
 
         void ConversionCost::postvisit( VoidType * ) {
@@ -279 +315 @@
                                 cost = Cost::zero;
                                 cost.incSafe( tableResult );
+                                cost.incSign( signMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ] );
                         } // if
                 } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
@@ -300 +337 @@
                                         // types are the same, except otherPointer has more qualifiers
                                         cost = Cost::safe;
-                                }
+                                } // if
                         } else {
                                 int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
@@ -422 +459 @@
                                 cost = Cost::zero;
                                 cost.incSafe( tableResult + 1 );
-                        }
+                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
+                        } // if
                 } else if ( dynamic_cast< PointerType* >( dest ) ) {
-                        cost = Cost::safe;
-                }
+                        cost = Cost::zero;
+                        cost.incSafe( maxIntCost + 2 ); // +1 for zero_t -> int, +1 for disambiguation
+                } // if
         }
 
@@ -439 +478 @@
                                 cost = Cost::zero;
                                 cost.incSafe( tableResult + 1 );
-                        }
-                }
+                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
+                        } // if
+                } // if
         }
 } // namespace ResolvExpr

src/ResolvExpr/Cost.h

@@ -7 +7 @@
 // Cost.h --
 //
-// Author           : Richard C. Bilson
+// Author           : Peter Buhr and Aaron Moss
 // Created On       : Sun May 17 09:39:50 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Fri Oct 05 14:32:00 2018
-// Update Count     : 7
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Apr 29 18:33:44 2019
+// Update Count     : 49
 //
 
@@ -17 +17 @@
 
 #include <iostream>
+#include <cassert>
+#include <climits>
 
 namespace ResolvExpr {
+#if 0
+
+        //*************************** OLD ***************************
+
         class Cost {
           private:
-                Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
-                        int referenceCost );
-
+                Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
+                          int varCost, int specCost, int referenceCost );
           public:
                 Cost & incUnsafe( int inc = 1 );
                 Cost & incPoly( int inc = 1 );
                 Cost & incSafe( int inc = 1 );
+                Cost & incSign( int inc = 1 );
                 Cost & incVar( int inc = 1 );
                 Cost & decSpec( int inc = 1 );
@@ -35 +41 @@
                 int get_polyCost() const { return polyCost; }
                 int get_safeCost() const { return safeCost; }
+                int get_signCost() const { return signCost; }
                 int get_varCost() const { return varCost; }
                 int get_specCost() const { return specCost; }
@@ -40 +47 @@
 
                 Cost operator+( const Cost &other ) const;
-                Cost operator-( const Cost &other ) const;
                 Cost &operator+=( const Cost &other );
                 bool operator<( const Cost &other ) const;
@@ -55 +61 @@
                 static const Cost poly;
                 static const Cost safe;
+                static const Cost sign;
                 static const Cost var;
                 static const Cost spec;
@@ -63 +70 @@
                 int polyCost;       ///< Count of parameters and return values bound to some poly type
                 int safeCost;       ///< Safe (widening) conversions
+                int signCost;       ///< Count of safe sign conversions
                 int varCost;        ///< Count of polymorphic type variables
                 int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
@@ -68 +76 @@
         };
 
-        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost, 
-                        int referenceCost ) 
-                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), varCost( varCost ), 
-                  specCost( specCost ), referenceCost( referenceCost ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
+                                           int varCost, int specCost, int referenceCost )
+                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), signCost( signCost ),
+                  varCost( varCost ), specCost( specCost ), referenceCost( referenceCost ) {}
 
         inline Cost & Cost::incUnsafe( int inc ) {
@@ -88 +96 @@
                 if ( *this == infinity ) return *this;
                 safeCost += inc;
+                return *this;
+        }
+
+        inline Cost & Cost::incSign( int inc ) {
+                if ( *this == infinity ) return *this;
+                signCost += inc;
                 return *this;
         }
@@ -111 +125 @@
         inline Cost Cost::operator+( const Cost &other ) const {
                 if ( *this == infinity || other == infinity ) return infinity;
-                return Cost{ 
-                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, 
-                        varCost + other.varCost, specCost + other.specCost, 
-                        referenceCost + other.referenceCost };
-        }
-
-        inline Cost Cost::operator-( const Cost &other ) const {
-                if ( *this == infinity || other == infinity ) return infinity;
-                return Cost{ 
-                        unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, 
-                        varCost - other.varCost, specCost - other.specCost, 
-                        referenceCost - other.referenceCost };
+                return Cost{
+                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost,
+                                signCost + other.signCost, varCost + other.varCost, specCost + other.specCost,
+                                referenceCost + other.referenceCost };
         }
 
@@ -134 +140 @@
                 polyCost += other.polyCost;
                 safeCost += other.safeCost;
+                signCost += other.signCost;
                 varCost += other.varCost;
                 specCost += other.specCost;
@@ -156 +163 @@
                 } else if ( safeCost < other.safeCost ) {
                         return true;
+                } else if ( signCost > other.signCost ) {
+                        return false;
+                } else if ( signCost < other.signCost ) {
+                        return true;
                 } else if ( varCost > other.varCost ) {
                         return false;
@@ -180 +191 @@
                 c = polyCost - other.polyCost; if ( c ) return c;
                 c = safeCost - other.safeCost; if ( c ) return c;
+                c = signCost - other.signCost; if ( c ) return c;
                 c = varCost - other.varCost; if ( c ) return c;
                 c = specCost - other.specCost; if ( c ) return c;
@@ -189 +201 @@
                         && polyCost == other.polyCost
                         && safeCost == other.safeCost
+                        && signCost == other.signCost
                         && varCost == other.varCost
                         && specCost == other.specCost
@@ -199 +212 @@
 
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " 
-                          << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", "
+                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
+                          << cost.safeCost << ", " << cost.signCost << ", "
+                                  << cost.varCost << ", " << cost.specCost << ", "
                           << cost.referenceCost << " )";
         }
+
+#else
+
+        //*************************** NEW ***************************
+
+        // To maximize performance and space, the 7 resolution costs are packed into a single 64-bit word. However, the
+        // specialization cost is a negative value so a correction is needed is a few places.
+
+        class Cost {
+                union {
+                        struct {
+                        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+                                // Little-endian => first value is low priority and last is high priority.
+                                unsigned char padding;                                  ///< unused
+                                unsigned char referenceCost;                    ///< reference conversions
+                                unsigned char specCost;                                 ///< Polymorphic type specializations (type assertions), negative cost
+                                unsigned char varCost;                                  ///< Count of polymorphic type variables
+                                unsigned char signCost;                                 ///< Count of safe sign conversions
+                                unsigned char safeCost;                                 ///< Safe (widening) conversions
+                                unsigned char polyCost;                                 ///< Count of parameters and return values bound to some poly type
+                                unsigned char unsafeCost;                               ///< Unsafe (narrowing) conversions
+                        #else
+                                #error Cost BIG_ENDIAN unsupported
+                        #endif
+                        } v;
+                        uint64_t all;
+                };
+                static const unsigned char correctb = 0xff;             // byte correction for negative spec cost
+                static const uint64_t correctw = 0x00'00'00'00'00'ff'00'00; //' word correction for negative spec cost
+          public:
+                // Compiler adjusts constants for correct endian.
+                enum : uint64_t {
+                        zero      = 0x00'00'00'00'00'ff'00'00,
+                        infinity  = 0xff'ff'ff'ff'ff'00'ff'ff,
+                        unsafe    = 0x01'00'00'00'00'ff'00'00,
+                        poly      = 0x00'01'00'00'00'ff'00'00,
+                        safe      = 0x00'00'01'00'00'ff'00'00,
+                        sign      = 0x00'00'00'01'00'ff'00'00,
+                        var       = 0x00'00'00'00'01'ff'00'00,
+                        spec      = 0x00'00'00'00'00'fe'00'00,
+                        reference = 0x00'00'00'00'00'ff'01'00,
+                }; //'
+
+                Cost( uint64_t all ) { Cost::all = all; }
+                Cost( int unsafeCost, int polyCost, int safeCost, int signCost, int varCost, int specCost, int referenceCost ) {
+                        // Assume little-endian => first value is low priority and last is high priority.
+                        v = {
+                        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+                                (unsigned char)0,                                               // padding
+                                (unsigned char)referenceCost,                   // low priority
+                                (unsigned char)(specCost + correctb),   // correct for signedness
+                                (unsigned char)varCost, 
+                                (unsigned char)signCost, 
+                                (unsigned char)safeCost, 
+                                (unsigned char)polyCost, 
+                                (unsigned char)unsafeCost,                              // high priority
+                        #else
+                                #error Cost BIG_ENDIAN unsupported
+                        #endif
+                        };
+                }
+
+                int get_unsafeCost() const { return v.unsafeCost; }
+                int get_polyCost() const { return v.polyCost; }
+                int get_safeCost() const { return v.safeCost; }
+                int get_signCost() const { return v.signCost; }
+                int get_varCost() const { return v.varCost; }
+                int get_specCost() const { return -(correctb - v.specCost); }
+                int get_referenceCost() const { return v.referenceCost; }
+
+                friend bool operator==( const Cost, const Cost );
+                friend bool operator!=( const Cost lhs, const Cost rhs );
+                // returns negative for *this < rhs, 0 for *this == rhs, positive for *this > rhs
+                int compare( const Cost rhs ) const {
+                        if ( all == infinity ) return 1;
+                        if ( rhs.all == infinity ) return -1;
+                        return all > rhs.all ? 1 : all == rhs.all ? 0 : -1;
+                }
+                friend bool operator<( const Cost lhs, const Cost rhs );
+
+                friend Cost operator+( const Cost lhs, const Cost rhs );
+ 
+                Cost operator+=( const Cost rhs ) {
+                        if ( all == infinity ) return *this;
+                        if ( rhs.all == infinity ) {
+                                all = infinity;
+                                return *this;
+                        }
+                        all += rhs.all - correctw;                                      // correct for negative spec cost
+                        return *this;
+                }
+
+                Cost incUnsafe( int inc = 1 ) {
+                        if ( all != infinity ) { assert( v.unsafeCost + inc <= UCHAR_MAX ); v.unsafeCost += inc; }
+                        return *this;
+                }
+
+                Cost incPoly( int inc = 1 ) {
+                        if ( all != infinity ) { assert( v.polyCost + inc <= UCHAR_MAX ); v.polyCost += inc; }
+                        return *this;
+                }
+
+                Cost incSafe( int inc = 1 ) {
+                        if ( all != infinity ) { assert( v.safeCost + inc <= UCHAR_MAX ); v.safeCost += inc; }
+                        return *this;
+                }
+
+                Cost incSign( int inc = 1 ) {
+                        if ( all != infinity ) { assert( v.signCost + inc <= UCHAR_MAX ); v.signCost += inc; }
+                        return *this;
+                }
+
+                Cost incVar( int inc = 1 ) {
+                        if ( all != infinity ) { assert( v.varCost + inc <= UCHAR_MAX ); v.varCost += inc; }
+                        return *this;
+                }
+
+                Cost decSpec( int dec = 1 ) {
+                        if ( all != infinity ) { assert( v.specCost - dec >= 0 ); v.specCost -= dec; }
+                        return *this;
+                }
+
+                Cost incReference( int inc = 1 ) {
+                        if ( all != infinity ) { assert( v.referenceCost + inc <= UCHAR_MAX ); v.referenceCost += inc; }
+                        return *this;
+                }
+
+                friend std::ostream & operator<<( std::ostream & os, const Cost cost );
+        };
+
+        inline bool operator==( const Cost lhs, const Cost rhs ) {
+                return lhs.all == rhs.all;
+        }
+
+        inline bool operator!=( const Cost lhs, const Cost rhs ) {
+                return !( lhs.all == rhs.all );
+        }
+
+        inline bool operator<( const Cost lhs, const Cost rhs ) {
+                if ( lhs.all == Cost::infinity ) return false;
+                if ( rhs.all == Cost::infinity ) return true;
+                return lhs.all < rhs.all;
+        }
+
+        inline Cost operator+( const Cost lhs, const Cost rhs ) {
+                if ( lhs.all == Cost::infinity || rhs.all == Cost::infinity ) return Cost{ Cost::infinity };
+                return Cost{ lhs.all + rhs.all - Cost::correctw }; // correct for negative spec cost
+        }
+
+        inline std::ostream & operator<<( std::ostream & os, const Cost cost ) {
+                return os << "( " << cost.get_unsafeCost() << ", " << cost.get_polyCost() << ", " << cost.get_safeCost()
+                                  << ", " << cost.get_signCost() << ", " << cost.get_varCost() << ", " << cost.get_specCost()
+                                  << ", " << cost.get_referenceCost() << " )";
+        }
+#endif // 0
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 12:05:18 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar  2 17:36:32 2016
-// Update Count     : 5
+// Last Modified On : Tue Apr 30 17:07:57 2019
+// Update Count     : 7
 //
 
@@ -39 +39 @@
                   private:
                         int level, resetCount;
-                        std::list< std::map< std::string, std::string > > mapStack;
+                        std::list< std::unordered_map< std::string, std::string > > mapStack;
                 };
 
@@ -55 +55 @@
         namespace {
                 RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
-                        mapStack.push_front( std::map< std::string, std::string >() );
+                        mapStack.push_front( std::unordered_map< std::string, std::string >() );
                 }
 
@@ -65 +65 @@
                 void RenameVars::previsit( TypeInstType * instType ) {
                         previsit( (Type *)instType );
-                        std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
+                        std::unordered_map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
                         if ( i != mapStack.front().end() ) {
                                 instType->name = i->second;

src/ResolvExpr/ResolveAssertions.cc

@@ -20 +20 @@
 #include <list>                     // for list
 #include <memory>                   // for unique_ptr
-#include <string>
+#include <sstream>                  // for ostringstream
+#include <string>                   // for string
 #include <unordered_map>            // for unordered_map, unordered_multimap
 #include <utility>                  // for move
@@ -27 +28 @@
 #include "Alternative.h"            // for Alternative, AssertionItem, AssertionList
 #include "Common/FilterCombos.h"    // for filterCombos
+#include "Common/Indenter.h"        // for Indenter
 #include "Common/utility.h"         // for sort_mins
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
@@ -33 +35 @@
 #include "SynTree/Expression.h"     // for InferredParams
 #include "TypeEnvironment.h"        // for TypeEnvironment, etc.
-#include "typeops.h"                // for adjustExprType
+#include "typeops.h"                // for adjustExprType, specCost
 #include "Unify.h"                  // for unify
 
@@ -56 +58 @@
         using CandidateList = std::vector<AssnCandidate>;
 
-        /// Unique identifier for a yet-to-be-resolved assertion
-        struct AssnId {
-                DeclarationWithType* decl;  ///< Declaration of assertion
-                AssertionSetValue info;     ///< Information about assertion
-
-                AssnId(DeclarationWithType* decl, const AssertionSetValue& info) : decl(decl), info(info) {}
-        };
-
-        /// Cached assertion items
-        struct AssnCacheItem {
-                CandidateList matches;         ///< Possible matches for this assertion
-                std::vector<AssnId> deferIds;  ///< Deferred assertions which resolve to this item
-
-                AssnCacheItem( CandidateList&& m ) : matches(std::move(m)), deferIds() {}
-        };
-
-        /// Cache of resolved assertions
-        using AssnCache = std::unordered_map<std::string, AssnCacheItem>;
-
         /// Reference to single deferred item
         struct DeferRef {
-                const AssnCacheItem& item;
+                const DeclarationWithType* decl;
+                const AssertionSetValue& info;
                 const AssnCandidate& match;
         };
@@ -84 +68 @@
         /// Acts like indexed list of DeferRef
         struct DeferItem {
-                const AssnCache* cache;     ///< Cache storing assertion item
-                std::string key;            ///< Key into cache
-                
-                DeferItem( const AssnCache& cache, const std::string& key ) : cache(&cache), key(key) {}
-
-                bool empty() const { return cache->at(key).matches.empty(); }
-
-                CandidateList::size_type size() const { return cache->at(key).matches.size(); }
-
-                DeferRef operator[] ( unsigned i ) const {
-                        const AssnCacheItem& item = cache->at(key);
-                        return { item, item.matches[i] };
-                }
-
-                // sortable by key
-                // TODO look into optimizing combination process with other sort orders (e.g. by number 
-                // of matches in candidate)
-                bool operator< ( const DeferItem& o ) const { return key < o.key; }
-                bool operator== ( const DeferItem& o ) const { return key == o.key; }
+                const DeclarationWithType* decl;
+                const AssertionSetValue& info;
+                CandidateList matches;
+
+                DeferItem( DeclarationWithType* decl, const AssertionSetValue& info, CandidateList&& matches )
+                : decl(decl), info(info), matches(std::move(matches)) {}
+
+                bool empty() const { return matches.empty(); }
+
+                CandidateList::size_type size() const { return matches.size(); }
+
+                DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
         };
 
@@ -177 +154 @@
                                 for ( const auto& assn : x.assns ) {
                                         k += computeConversionCost( 
-                                                assn.match.adjType, assn.item.deferIds[0].decl->get_type(), indexer, 
-                                                x.env );
+                                                assn.match.adjType, assn.decl->get_type(), indexer, x.env );
+                                        
+                                        // mark vars+specialization cost on function-type assertions
+                                        PointerType* ptr = dynamic_cast< PointerType* >( assn.decl->get_type() );
+                                        if ( ! ptr ) continue;
+                                        FunctionType* func = dynamic_cast< FunctionType* >( ptr->base );
+                                        if ( ! func ) continue;
+                                        
+                                        for ( DeclarationWithType* formal : func->parameters ) {
+                                                k.decSpec( specCost( formal->get_type() ) );
+                                        }
+                                        k.incVar( func->forall.size() );
+                                        for ( TypeDecl* td : func->forall ) {
+                                                k.decSpec( td->assertions.size() );
+                                        }
                                 }
                                 it = cache.emplace_hint( it, &x, k );
@@ -249 +239 @@
 
         /// Resolve a single assertion, in context
-        bool resolveAssertion( AssertionItem& assn, ResnState& resn, AssnCache& cache ) {
+        bool resolveAssertion( AssertionItem& assn, ResnState& resn ) {
                 // skip unused assertions
                 if ( ! assn.info.isUsed ) return true;
 
-                // check cache for this assertion
-                std::string assnKey = SymTab::Mangler::mangleAssnKey( assn.decl, resn.alt.env );
-                auto it = cache.find( assnKey );
-
-                // attempt to resolve assertion if this is the first time seen
-                if ( it == cache.end() ) {
-                        // lookup candidates for this assertion
-                        std::list< SymTab::Indexer::IdData > candidates;
-                        resn.indexer.lookupId( assn.decl->name, candidates );
-
-                        // find the candidates that unify with the desired type
-                        CandidateList matches;
-                        for ( const auto& cdata : candidates ) {
-                                DeclarationWithType* candidate = cdata.id;
-
-                                // build independent unification context for candidate
-                                AssertionSet have, newNeed;
-                                TypeEnvironment newEnv{ resn.alt.env };
-                                OpenVarSet newOpenVars{ resn.alt.openVars };
-                                Type* adjType = candidate->get_type()->clone();
-                                adjustExprType( adjType, newEnv, resn.indexer );
-                                renameTyVars( adjType );
-
-                                // keep unifying candidates
-                                if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars, 
-                                                resn.indexer ) ) {
-                                        // set up binding slot for recursive assertions
-                                        UniqueId crntResnSlot = 0;
-                                        if ( ! newNeed.empty() ) {
-                                                crntResnSlot = ++globalResnSlot;
-                                                for ( auto& a : newNeed ) {
-                                                        a.second.resnSlot = crntResnSlot;
-                                                }
-                                        }
-
-                                        matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have), 
-                                                std::move(newNeed), std::move(newOpenVars), crntResnSlot );
-                                } else {
-                                        delete adjType;
-                                }
+                // lookup candidates for this assertion
+                std::list< SymTab::Indexer::IdData > candidates;
+                resn.indexer.lookupId( assn.decl->name, candidates );
+
+                // find the candidates that unify with the desired type
+                CandidateList matches;
+                for ( const auto& cdata : candidates ) {
+                        DeclarationWithType* candidate = cdata.id;
+
+                        // build independent unification context for candidate
+                        AssertionSet have, newNeed;
+                        TypeEnvironment newEnv{ resn.alt.env };
+                        OpenVarSet newOpenVars{ resn.alt.openVars };
+                        Type* adjType = candidate->get_type()->clone();
+                        adjustExprType( adjType, newEnv, resn.indexer );
+                        renameTyVars( adjType );
+
+                        // keep unifying candidates
+                        if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars, 
+                                        resn.indexer ) ) {
+                                // set up binding slot for recursive assertions
+                                UniqueId crntResnSlot = 0;
+                                if ( ! newNeed.empty() ) {
+                                        crntResnSlot = ++globalResnSlot;
+                                        for ( auto& a : newNeed ) {
+                                                a.second.resnSlot = crntResnSlot;
+                                        }
+                                }
+
+                                matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have), 
+                                        std::move(newNeed), std::move(newOpenVars), crntResnSlot );
+                        } else {
+                                delete adjType;
                         }
-
-                        it = cache.emplace_hint( it, assnKey, AssnCacheItem{ std::move(matches) } );
-                }
-
-                CandidateList& matches = it->second.matches;
+                }
 
                 // break if no suitable assertion
@@ -305 +284 @@
                 // defer if too many suitable assertions
                 if ( matches.size() > 1 ) {
-                        it->second.deferIds.emplace_back( assn.decl, assn.info );
-                        resn.deferred.emplace_back( cache, assnKey );
+                        resn.deferred.emplace_back( assn.decl, assn.info, std::move(matches) );
                         return true;
                 }
@@ -314 +292 @@
                 addToIndexer( match.have, resn.indexer );
                 resn.newNeed.insert( match.need.begin(), match.need.end() );
-                resn.alt.env = match.env;
-                resn.alt.openVars = match.openVars;
+                resn.alt.env = std::move(match.env);
+                resn.alt.openVars = std::move(match.openVars);
 
                 bindAssertion( assn.decl, assn.info, resn.alt, match, resn.inferred );
@@ -364 +342 @@
         static const int recursionLimit = /* 10 */ 4;
 
-        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out ) {
+        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors ) {
                 // finish early if no assertions to resolve
                 if ( alt.need.empty() ) {
@@ -376 +354 @@
                 ResnList resns{ ResnState{ alt, root_indexer } };
                 ResnList new_resns{};
-                AssnCache assnCache;
 
                 // resolve assertions in breadth-first-order up to a limited number of levels deep
@@ -385 +362 @@
                                 for ( auto& assn : resn.need ) {
                                         // fail early if any assertion is not resolvable
-                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) goto nextResn;
+                                        if ( ! resolveAssertion( assn, resn ) ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "Could not satisfy assertion:\n";
+                                                assn.decl->print( ss, ++tabs );
+                                                
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
                                 }
 
@@ -396 +383 @@
                                         }
                                 } else {
-                                        // only resolve each deferred assertion once
-                                        std::sort( resn.deferred.begin(), resn.deferred.end() );
-                                        auto last = std::unique( resn.deferred.begin(), resn.deferred.end() );
-                                        resn.deferred.erase( last, resn.deferred.end() );
                                         // resolve deferred assertions by mutual compatibility
                                         std::vector<CandidateEnvMerger::OutType> compatible = filterCombos(
                                                 resn.deferred, 
                                                 CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
+                                        // fail early if no mutually-compatible assertion satisfaction
+                                        if ( compatible.empty() ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "No mutually-compatible satisfaction for assertions:\n";
+                                                ++tabs;
+                                                for ( const auto& d : resn.deferred ) {
+                                                        d.decl->print( ss, tabs );
+                                                }
+
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
                                         // sort by cost
                                         CandidateCost coster{ resn.indexer };
@@ -429 +427 @@
                                                         new_resn.newNeed.insert( match.need.begin(), match.need.end() );
 
-                                                        // for each deferred assertion with the same form
-                                                        for ( AssnId id : r.item.deferIds ) {
-                                                                bindAssertion( 
-                                                                        id.decl, id.info, new_resn.alt, match, new_resn.inferred );
-                                                        }
+                                                        bindAssertion( r.decl, r.info, new_resn.alt, match, new_resn.inferred );
                                                 }
 

src/ResolvExpr/ResolveAssertions.h

@@ -24 +24 @@
 namespace ResolvExpr {
         /// Recursively resolves all assertions provided in an alternative; returns true iff succeeds
-        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out );
+        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors );
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Fri Oct 05 09:43:00 2018
-// Update Count     : 214
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb 19 18:09:56 2019
+// Update Count     : 240
 //
 
@@ -54 +54 @@
                 }
 
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
-                void previsit( ObjectDecl *objectDecll );
+                void previsit( FunctionDecl * functionDecl );
+                void postvisit( FunctionDecl * functionDecl );
+                void previsit( ObjectDecl * objectDecll );
                 void previsit( EnumDecl * enumDecl );
                 void previsit( StaticAssertDecl * assertDecl );
@@ -63 +63 @@
                 void previsit( PointerType * at );
 
-                void previsit( ExprStmt *exprStmt );
-                void previsit( AsmExpr *asmExpr );
-                void previsit( AsmStmt *asmStmt );
-                void previsit( IfStmt *ifStmt );
-                void previsit( WhileStmt *whileStmt );
-                void previsit( ForStmt *forStmt );
-                void previsit( SwitchStmt *switchStmt );
-                void previsit( CaseStmt *caseStmt );
-                void previsit( BranchStmt *branchStmt );
-                void previsit( ReturnStmt *returnStmt );
-                void previsit( ThrowStmt *throwStmt );
-                void previsit( CatchStmt *catchStmt );
+                void previsit( ExprStmt * exprStmt );
+                void previsit( AsmExpr * asmExpr );
+                void previsit( AsmStmt * asmStmt );
+                void previsit( IfStmt * ifStmt );
+                void previsit( WhileStmt * whileStmt );
+                void previsit( ForStmt * forStmt );
+                void previsit( SwitchStmt * switchStmt );
+                void previsit( CaseStmt * caseStmt );
+                void previsit( BranchStmt * branchStmt );
+                void previsit( ReturnStmt * returnStmt );
+                void previsit( ThrowStmt * throwStmt );
+                void previsit( CatchStmt * catchStmt );
                 void previsit( WaitForStmt * stmt );
 
-                void previsit( SingleInit *singleInit );
-                void previsit( ListInit *listInit );
-                void previsit( ConstructorInit *ctorInit );
+                void previsit( SingleInit * singleInit );
+                void previsit( ListInit * listInit );
+                void previsit( ConstructorInit * ctorInit );
           private:
                 typedef std::list< Initializer * >::iterator InitIterator;
@@ -105 +105 @@
         }
 
-        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+        void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
                 PassVisitor<Resolver> resolver( indexer );
                 maybeAccept( decl, resolver );
@@ -149 +149 @@
                 };
 
-                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->env );
@@ -280 +280 @@
 
         // used in resolveTypeof
-        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
+        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
                 TypeEnvironment env;
                 return resolveInVoidContext( expr, indexer, env );
         }
 
-        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
+        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
                 // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
                 // interpretations, an exception has already been thrown.
                 assertf( expr, "expected a non-null expression." );
 
-                static CastExpr untyped( nullptr ); // cast to void
-                untyped.location = expr->location;
+                CastExpr * untyped = new CastExpr( expr ); // cast to void
+                untyped->location = expr->location;
 
                 // set up and resolve expression cast to void
-                untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
+                findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
+                assert( castExpr );
                 env = std::move( choice.env );
 
@@ -305 +305 @@
 
                 // unlink the arg so that it isn't deleted twice at the end of the program
-                untyped.arg = nullptr;
+                untyped->arg = nullptr;
                 return ret;
         }
 
-        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
                 resetTyVarRenaming();
                 TypeEnvironment env;
@@ -318 +318 @@
         }
 
-        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
                 findKindExpression( untyped, indexer, "", standardAlternativeFilter );
         }
@@ -337 +337 @@
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
                                 return true;
-                        } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
+                        } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
                         } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
@@ -346 +346 @@
                 }
 
-                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
                         findKindExpression( untyped, indexer, "condition", isIntegralType );
                 }
@@ -402 +402 @@
         }
 
-        void Resolver::previsit( ObjectDecl *objectDecl ) {
+        void Resolver::previsit( ObjectDecl * objectDecl ) {
                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
                 // class-variable initContext is changed multiple time because the LHS is analysed twice.
@@ -432 +432 @@
         }
 
-        void Resolver::previsit( FunctionDecl *functionDecl ) {
+        void Resolver::previsit( FunctionDecl * functionDecl ) {
 #if 0
                 std::cerr << "resolver visiting functiondecl ";
@@ -442 +442 @@
         }
 
-        void Resolver::postvisit( FunctionDecl *functionDecl ) {
+        void Resolver::postvisit( FunctionDecl * functionDecl ) {
                 // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
@@ -467 +467 @@
         }
 
-        void Resolver::previsit( ExprStmt *exprStmt ) {
+        void Resolver::previsit( ExprStmt * exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
@@ -473 +473 @@
         }
 
-        void Resolver::previsit( AsmExpr *asmExpr ) {
+        void Resolver::previsit( AsmExpr * asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
@@ -481 +481 @@
         }
 
-        void Resolver::previsit( AsmStmt *asmStmt ) {
+        void Resolver::previsit( AsmStmt * asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
@@ -487 +487 @@
         }
 
-        void Resolver::previsit( IfStmt *ifStmt ) {
+        void Resolver::previsit( IfStmt * ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
         }
 
-        void Resolver::previsit( WhileStmt *whileStmt ) {
+        void Resolver::previsit( WhileStmt * whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
         }
 
-        void Resolver::previsit( ForStmt *forStmt ) {
+        void Resolver::previsit( ForStmt * forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
@@ -505 +505 @@
         }
 
-        void Resolver::previsit( SwitchStmt *switchStmt ) {
+        void Resolver::previsit( SwitchStmt * switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
@@ -512 +512 @@
         }
 
-        void Resolver::previsit( CaseStmt *caseStmt ) {
+        void Resolver::previsit( CaseStmt * caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
@@ -531 +531 @@
         }
 
-        void Resolver::previsit( BranchStmt *branchStmt ) {
+        void Resolver::previsit( BranchStmt * branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
@@ -542 +542 @@
         }
 
-        void Resolver::previsit( ReturnStmt *returnStmt ) {
+        void Resolver::previsit( ReturnStmt * returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
@@ -549 +549 @@
         }
 
-        void Resolver::previsit( ThrowStmt *throwStmt ) {
+        void Resolver::previsit( ThrowStmt * throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
@@ -561 +561 @@
         }
 
-        void Resolver::previsit( CatchStmt *catchStmt ) {
+        void Resolver::previsit( CatchStmt * catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
@@ -725 +725 @@
 
                                                 }
-                                                catch( SemanticErrorException &e ) {
+                                                catch( SemanticErrorException & e ) {
                                                         errors.append( e );
                                                 }
                                         }
                                 }
-                                catch( SemanticErrorException &e ) {
+                                catch( SemanticErrorException & e ) {
                                         errors.append( e );
                                 }
@@ -782 +782 @@
         }
 
-        void Resolver::previsit( SingleInit *singleInit ) {
+        void Resolver::previsit( SingleInit * singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
@@ -814 +814 @@
                                 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
                                         if ( isCharType( pt->get_base() ) ) {
-                                                if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                                if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
                                                         // strip cast if we're initializing a char[] with a char *,
                                                         // e.g.  char x[] = "hello";
@@ -894 +894 @@
         }
 
-        void Resolver::previsit( ConstructorInit *ctorInit ) {
+        void Resolver::previsit( ConstructorInit * ctorInit ) {
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

src/ResolvExpr/Resolver.h

@@ -10 +10 @@
 // Created On       : Sun May 17 12:18:34 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:36:57 2017
-// Update Count     : 3
+// Last Modified On : Mon Feb 18 20:40:38 2019
+// Update Count     : 4
 //
 
@@ -29 +29 @@
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
-        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
-        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
-        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
-        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
-        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer &indexer );
+        void resolveDecl( Declaration *, const SymTab::Indexer & indexer );
+        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer );
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer );
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer );
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/ResolvExpr/TypeEnvironment.cc

@@ -386 +386 @@
         }
 
-        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool TypeEnvironment::bindVarToVar( TypeInstType *var1, TypeInstType *var2, 
+                        TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, 
+                        const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
 
                 auto class1 = internal_lookup( var1->get_name() );
@@ -428 +430 @@
                                         class1->set_type( common );
                                 }
+                                class1->data.isComplete |= data.isComplete;
                                 env.erase( class2 );
                         } else return false;
@@ -435 +438 @@
                                 class1->vars.insert( class2->vars.begin(), class2->vars.end() );
                                 class1->allowWidening = widen1;
+                                class1->data.isComplete |= data.isComplete;
                                 env.erase( class2 );
                         } else {
                                 class2->vars.insert( class1->vars.begin(), class1->vars.end() );
                                 class2->allowWidening = widen2;
+                                class2->data.isComplete |= data.isComplete;
                                 env.erase( class1 );
                         } // if
@@ -445 +450 @@
                         class1->vars.insert( var2->get_name() );
                         class1->allowWidening = widen1;
+                        class1->data.isComplete |= data.isComplete;
                 } else if ( class2 != env.end() ) {
                         // var1 unbound, add to class2
                         class2->vars.insert( var1->get_name() );
                         class2->allowWidening = widen2;
+                        class2->data.isComplete |= data.isComplete;
                 } else {
                         // neither var bound, create new class

src/ResolvExpr/TypeEnvironment.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:24:58 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Mon Jun 18 11:58:00 2018
-// Update Count     : 4
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Apr 30 23:04:10 2019
+// Update Count     : 9
 //
 
@@ -18 +18 @@
 #include <iostream>                    // for ostream
 #include <list>                        // for list, list<>::iterator, list<>...
-#include <map>                         // for map, map<>::value_compare
-#include <set>                         // for set
+#include <map>                                             // for map, map<>::value_compare
+#include <unordered_map>
+#include <set>                                             // for set
 #include <string>                      // for string
 #include <utility>                     // for move, swap
@@ -64 +65 @@
                 AssertionSetValue() : isUsed(false), resnSlot(0) {}
         };
-        typedef std::map< DeclarationWithType*, AssertionSetValue, AssertCompare > AssertionSet;
-        typedef std::map< std::string, TypeDecl::Data > OpenVarSet;
+        typedef std::map< DeclarationWithType *, AssertionSetValue, AssertCompare > AssertionSet;
+        typedef std::unordered_map< std::string, TypeDecl::Data > OpenVarSet;
 
         /// merges one set of open vars into another
@@ -139 +140 @@
                 /// Binds the type classes represented by `var1` and `var2` together; will add 
                 /// one or both classes if needed. Returns false on failure.
-                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+                bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Data && data, AssertionSet &need, AssertionSet &have, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
 
                 /// Disallows widening for all bindings in the environment

src/ResolvExpr/Unify.cc

@@ -21 +21 @@
 #include <string>                 // for string, operator==, operator!=, bas...
 #include <utility>                // for pair, move
-
+#include <vector>
+
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"   // for PassVisitor
 #include "FindOpenVars.h"         // for findOpenVars
@@ -172 +175 @@
                 bool isopen2 = var2 && ( entry2 != openVars.end() );
 
-                if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
-                        result = env.bindVarToVar( var1, var2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                if ( isopen1 && isopen2 ) {
+                        if ( entry1->second.kind != entry2->second.kind ) {
+                                result = false;
+                        } else {
+                                result = env.bindVarToVar( 
+                                        var1, var2, TypeDecl::Data{ entry1->second, entry2->second }, needAssertions, 
+                                        haveAssertions, openVars, widenMode, indexer );
+                        }
                 } else if ( isopen1 ) {
                         result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widenMode, indexer );
@@ -624 +633 @@
         }
 
-        // xxx - compute once and store in the FunctionType?
         Type * extractResultType( FunctionType * function ) {
                 if ( function->get_returnVals().size() == 0 ) {
@@ -638 +646 @@
                 }
         }
+
+        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
+                assert(!"restore after AST added to build");
+                // if ( func->returns.empty() ) return new ast::VoidType{};
+                // if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
+
+                // std::vector<ast::ptr<ast::Type>> tys;
+                // for ( const ast::DeclWithType * decl : func->returns ) {
+                //      tys.emplace_back( decl->get_type() );
+                // }
+                // return new ast::TupleType{ std::move(tys) };
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += ResolvExpr/AlternativeFinder.cc \
-       ResolvExpr/Alternative.cc \
-       ResolvExpr/Unify.cc \
-       ResolvExpr/PtrsAssignable.cc \
-       ResolvExpr/CommonType.cc \
-       ResolvExpr/ConversionCost.cc \
-       ResolvExpr/CastCost.cc \
-       ResolvExpr/PtrsCastable.cc \
-       ResolvExpr/AdjustExprType.cc \
-       ResolvExpr/AlternativePrinter.cc \
-       ResolvExpr/Resolver.cc \
-       ResolvExpr/ResolveTypeof.cc \
-       ResolvExpr/RenameVars.cc \
-       ResolvExpr/FindOpenVars.cc \
-       ResolvExpr/PolyCost.cc \
-       ResolvExpr/Occurs.cc \
-       ResolvExpr/TypeEnvironment.cc \
-       ResolvExpr/CurrentObject.cc \
-       ResolvExpr/ExplodedActual.cc \
-       ResolvExpr/SpecCost.cc \
-       ResolvExpr/ResolveAssertions.cc
+SRC_RESOLVEXPR = \
+      ResolvExpr/AdjustExprType.cc \
+      ResolvExpr/Alternative.cc \
+      ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/CastCost.cc \
+      ResolvExpr/CommonType.cc \
+      ResolvExpr/ConversionCost.cc \
+      ResolvExpr/CurrentObject.cc \
+      ResolvExpr/ExplodedActual.cc \
+      ResolvExpr/FindOpenVars.cc \
+      ResolvExpr/Occurs.cc \
+      ResolvExpr/PolyCost.cc \
+      ResolvExpr/PtrsAssignable.cc \
+      ResolvExpr/PtrsCastable.cc \
+      ResolvExpr/RenameVars.cc \
+      ResolvExpr/ResolveAssertions.cc \
+      ResolvExpr/Resolver.cc \
+      ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/SpecCost.cc \
+      ResolvExpr/TypeEnvironment.cc \
+      ResolvExpr/Unify.cc
+
+SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc
+SRCDEMANGLE += $(SRC_RESOLVEXPR)

src/ResolvExpr/typeops.h

@@ -10 +10 @@
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:36:18 2017
-// Update Count     : 3
+// Last Modified On : Fri Feb  8 09:30:34 2019
+// Update Count     : 4
 //
 
@@ -18 +18 @@
 #include <vector>
 
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
@@ -99 +101 @@
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );
+        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
+        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
 
         // in CommonType.cc
-        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
+        Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
 
         // in PolyCost.cc

src/SymTab/Indexer.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 16:08:40 2017
-// Update Count     : 20
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 21
 //
 
@@ -17 +17 @@
 
 #include <cassert>                 // for assert, strict_dynamic_cast
-#include <iostream>                // for operator<<, basic_ostream, ostream
 #include <string>                  // for string, operator<<, operator!=
+#include <memory>                  // for shared_ptr, make_shared
 #include <unordered_map>           // for operator!=, unordered_map<>::const...
 #include <unordered_set>           // for unordered_set
 #include <utility>                 // for pair, make_pair, move
+#include <vector>                  // for vector
 
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
-#include "GenPoly/GenPoly.h"
+#include "Common/Stats/Counter.h"  // for counters
+#include "GenPoly/GenPoly.h"       // for getFunctionType
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
@@ -38 +40 @@
 #include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
 
-#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
-
 namespace SymTab {
-        std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
-                return out << "(" << data.id << "," << data.baseExpr << ")";
-        }
-
-        typedef std::unordered_map< std::string, Indexer::IdData > MangleTable;
-        typedef std::unordered_map< std::string, MangleTable > IdTable;
-        typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
-        typedef std::unordered_map< std::string, StructDecl* > StructTable;
-        typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
-        typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
-        typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
-
-        void dump( const IdTable &table, std::ostream &os ) {
-                for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
-                        for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
-                                os << mangle->second << std::endl;
-                        }
-                }
-        }
-
-        template< typename Decl >
-        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
-                for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
-                        os << it->second << std::endl;
-                } // for
-        }
-
-        struct Indexer::Impl {
-                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
-                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
-                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                unsigned long refCount;   ///< Number of references to these tables
-                unsigned long scope;      ///< Scope these tables are associated with
-                unsigned long size;       ///< Number of elements stored in this table
-                const Indexer base;       ///< Base indexer this extends
-
-                IdTable idTable;          ///< Identifier namespace
-                TypeTable typeTable;      ///< Type namespace
-                StructTable structTable;  ///< Struct namespace
-                EnumTable enumTable;      ///< Enum namespace
-                UnionTable unionTable;    ///< Union namespace
-                TraitTable traitTable;    ///< Trait namespace
-        };
-
-        Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) {
-                if ( ! toClone ) return 0;
-
-                // shorten the search chain by skipping empty links
-                Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone;
-                if ( ret ) { ++ret->refCount; }
-
-                return ret;
-        }
-
-        void Indexer::deleteRef( Indexer::Impl *toFree ) {
-                if ( ! toFree ) return;
-
-                if ( --toFree->refCount == 0 ) delete toFree;
-        }
-
-        void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const {
-                // only need to perform this step for constructors, destructors, and assignment functions
-                if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
-
-                // helpful data structure to organize properties for a type
-                struct ValueType {
-                        struct DeclBall { // properties for this particular decl
-                                IdData decl;
-                                bool isUserDefinedFunc;
-                                bool isCopyFunc;
+
+        // Statistics block
+        namespace {
+                static inline auto stats() {
+                        using namespace Stats::Counters;
+                        static auto group   = build<CounterGroup>("Indexers");
+                        static struct {
+                                SimpleCounter * count;
+                                AverageCounter<double> * size;
+                                SimpleCounter * new_scopes;
+                                SimpleCounter * lazy_scopes;
+                                AverageCounter<double> * avg_scope_depth;
+                                MaxCounter<size_t> * max_scope_depth;
+                                SimpleCounter * add_calls;
+                                SimpleCounter * lookup_calls;
+                                SimpleCounter * map_lookups;
+                                SimpleCounter * map_mutations;
+                        } ret = {
+                                .count   = build<SimpleCounter>("Count", group),
+                                .size    = build<AverageCounter<double>>("Average Size", group),
+                                .new_scopes = build<SimpleCounter>("Scopes", group),
+                                .lazy_scopes = build<SimpleCounter>("Lazy Scopes", group),
+                                .avg_scope_depth = build<AverageCounter<double>>("Average Scope", group),
+                                .max_scope_depth = build<MaxCounter<size_t>>("Max Scope", group),
+                                .add_calls = build<SimpleCounter>("Add Calls", group),
+                                .lookup_calls = build<SimpleCounter>("Lookup Calls", group),
+                                .map_lookups = build<SimpleCounter>("Map Lookups", group),
+                                .map_mutations = build<SimpleCounter>("Map Mutations", group)
                         };
-                        // properties for this type
-                        bool existsUserDefinedCopyFunc = false;    // user-defined copy ctor found
-                        BaseSyntaxNode * deleteStmt = nullptr;     // non-null if a user-defined function is found
-                        std::list< DeclBall > decls;
-
-                        // another FunctionDecl for the current type was found - determine
-                        // if it has special properties and update data structure accordingly
-                        ValueType & operator+=( IdData data ) {
-                                DeclarationWithType * function = data.id;
-                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
-                                bool isCopyFunc = InitTweak::isCopyFunction( function, function->name );
-                                decls.push_back( DeclBall{ data, isUserDefinedFunc, isCopyFunc } );
-                                existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
-                                if ( isUserDefinedFunc && ! deleteStmt ) {
-                                        // any user-defined function can act as an implicit delete statement for generated constructors.
-                                        // a delete stmt should not act as an implicit delete statement.
-                                        deleteStmt = data.id;
-                                }
-                                return *this;
-                        }
-                }; // ValueType
-
-                std::list< IdData > copy;
-                copy.splice( copy.end(), out );
-
-                // organize discovered declarations by type
-                std::unordered_map< std::string, ValueType > funcMap;
-                for ( auto decl : copy ) {
-                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
-                                std::list< DeclarationWithType * > & params = function->type->parameters;
-                                assert( ! params.empty() );
-                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
-                                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
-                                assert( base );
-                                funcMap[ Mangler::mangle( base ) ] += decl;
-                        } else {
-                                out.push_back( decl );
-                        }
-                }
-
-                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
-                // the set of ctor/dtor/assign that can be used  by the requester. In particular, if the user defines
-                // a default ctor, then the generated default ctor is unavailable, likewise for copy ctor
-                // and dtor. If the user defines any ctor/dtor, then no generated field ctors are available.
-                // If the user defines any ctor then the generated default ctor is unavailable (intrinsic default
-                // ctor must be overridden exactly). If the user defines anything that looks like a copy constructor,
-                // then the generated copy constructor is unavailable, and likewise for the assignment operator.
-                for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
-                        ValueType & val = pair.second;
-                        for ( ValueType::DeclBall ball : val.decls ) {
-                                bool isNotUserDefinedFunc = ! ball.isUserDefinedFunc && ball.decl.id->linkage != LinkageSpec::Intrinsic;
-                                bool isCopyFunc = ball.isCopyFunc;
-                                bool existsUserDefinedCopyFunc = val.existsUserDefinedCopyFunc;
-
-                                // only implicitly delete non-user defined functions that are not intrinsic, and are
-                                // not copy functions (assignment or copy constructor). If a  user-defined copy function exists,
-                                // do not pass along the non-user-defined copy functions since signatures do not have to match,
-                                // and the generated functions will often be cheaper.
-                                if ( isNotUserDefinedFunc ) {
-                                        if ( isCopyFunc ) {
-                                                // Skip over non-user-defined copy functions when there is a user-defined copy function.
-                                                // Since their signatures do not have to be exact, deleting them is the wrong choice.
-                                                if ( existsUserDefinedCopyFunc ) continue;
-                                        } else {
-                                                // delete non-user-defined non-copy functions if applicable.
-                                                // deleteStmt will be non-null only if a user-defined function is found.
-                                                ball.decl.deleteStmt = val.deleteStmt;
-                                        }
-                                }
-                                out.push_back( ball.decl );
-                        }
-                }
-        }
-
-        void Indexer::makeWritable() {
-                if ( ! tables ) {
-                        // create indexer if not yet set
-                        tables = new Indexer::Impl( scope );
-                } else if ( tables->refCount > 1 || tables->scope != scope ) {
-                        // make this indexer the base of a fresh indexer at the current scope
-                        tables = new Indexer::Impl( scope, std::move( *this ) );
-                }
-        }
-
-        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
-
-        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
-
-        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
-                that.tables = 0;
-        }
+                        return ret;
+                }
+        }
+
+        Indexer::Indexer() 
+        : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(), 
+          prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
 
         Indexer::~Indexer() {
-                deleteRef( tables );
-        }
-
-        Indexer& Indexer::operator= ( const Indexer &that ) {
-                deleteRef( tables );
-
-                tables = newRef( that.tables );
-                scope = that.scope;
-                doDebug = that.doDebug;
-
-                return *this;
-        }
-
-        Indexer& Indexer::operator= ( Indexer &&that ) {
-                deleteRef( tables );
-
-                tables = that.tables;
-                scope = that.scope;
-                doDebug = that.doDebug;
-
-                that.tables = 0;
-
-                return *this;
+                stats().size->push( idTable ? idTable->size() : 0 );
+        }
+
+        void Indexer::lazyInitScope() {
+                if ( repScope < scope ) {
+                        ++*stats().lazy_scopes;
+                        // create rollback
+                        prevScope = std::make_shared<Indexer>( *this );
+                        // update repScope
+                        repScope = scope;
+                }
+        }
+
+        void Indexer::enterScope() {
+                ++scope;
+
+                ++*stats().new_scopes;
+                stats().avg_scope_depth->push( scope );
+                stats().max_scope_depth->push( scope );
+        }
+
+        void Indexer::leaveScope() {
+                if ( repScope == scope ) {
+                        Ptr prev = prevScope;           // make sure prevScope stays live
+                        *this = std::move(*prevScope);  // replace with previous scope
+                }
+
+                --scope;
         }
 
         void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
-                std::unordered_set< std::string > foundMangleNames;
-
-                Indexer::Impl *searchTables = tables;
-                while ( searchTables ) {
-
-                        IdTable::const_iterator decls = searchTables->idTable.find( id );
-                        if ( decls != searchTables->idTable.end() ) {
-                                const MangleTable &mangleTable = decls->second;
-                                for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
-                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
-
-                                        out.push_back( decl->second );
-                                }
-                        }
-
-                        // get declarations from base indexers
-                        searchTables = searchTables->base.tables;
-                }
-
-                // some special functions, e.g. constructors and destructors
-                // remove autogenerated functions when they are defined so that
-                // they can never be matched
-                removeSpecialOverrides( id, out );
+                ++*stats().lookup_calls;
+                if ( ! idTable ) return;
+
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return;
+
+                for ( auto decl : *(decls->second) ) {
+                        out.push_back( decl.second );
+                }
         }
 
         NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                TypeTable::const_iterator ret = tables->typeTable.find( id );
-                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
+                ++*stats().lookup_calls;
+                if ( ! typeTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = typeTable->find( id );
+                return it == typeTable->end() ? nullptr : it->second.decl;
         }
 
         StructDecl *Indexer::lookupStruct( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                StructTable::const_iterator ret = tables->structTable.find( id );
-                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
+                ++*stats().lookup_calls;
+                if ( ! structTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = structTable->find( id );
+                return it == structTable->end() ? nullptr : it->second.decl;
+        }
+
+        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! enumTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = enumTable->find( id );
+                return it == enumTable->end() ? nullptr : it->second.decl;
+        }
+
+        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! unionTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = unionTable->find( id );
+                return it == unionTable->end() ? nullptr : it->second.decl;
+        }
+
+        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
+                ++*stats().lookup_calls;
+                if ( ! traitTable ) return nullptr;
+                ++*stats().map_lookups;
+                auto it = traitTable->find( id );
+                return it == traitTable->end() ? nullptr : it->second.decl;
+        }
+
+        const Indexer* Indexer::atScope( unsigned long target ) const {
+                // by lazy construction, final indexer in list has repScope 0, cannot be > target
+                // otherwise, will find first scope representing the target
+                const Indexer* indexer = this;
+                while ( indexer->repScope > target ) {
+                        indexer = indexer->prevScope.get();
+                }
+                return indexer;
         }
 
         NamedTypeDecl *Indexer::globalLookupType( const std::string &id ) const {
-                return lookupTypeAtScope( id, 0 );
+                return atScope( 0 )->lookupType( id );
         }
 
         StructDecl *Indexer::globalLookupStruct( const std::string &id ) const {
-                return lookupStructAtScope( id, 0 );
+                return atScope( 0 )->lookupStruct( id );
         }
 
         UnionDecl *Indexer::globalLookupUnion( const std::string &id ) const {
-                return lookupUnionAtScope( id, 0 );
+                return atScope( 0 )->lookupUnion( id );
         }
 
         EnumDecl *Indexer::globalLookupEnum( const std::string &id ) const {
-                return lookupEnumAtScope( id, 0 );
-        }
-
-        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                EnumTable::const_iterator ret = tables->enumTable.find( id );
-                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
-        }
-
-        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                UnionTable::const_iterator ret = tables->unionTable.find( id );
-                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
-        }
-
-        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                TraitTable::const_iterator ret = tables->traitTable.find( id );
-                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
-        }
-
-        const Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return nullptr;
-                if ( tables->scope < scope ) return nullptr;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        MangleTable::const_iterator decl = mangleTable.find( mangleName );
-                        if ( decl != mangleTable.end() ) return &decl->second;
-                }
-
-                return tables->base.lookupIdAtScope( id, mangleName, scope );
-        }
-
-        Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) {
-                return const_cast<IdData *>(const_cast<const Indexer *>(this)->lookupIdAtScope( id, mangleName, scope ));
-        }
-
-        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return false;
-                if ( tables->scope < scope ) return false;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                // check for C decls with the same name, skipping those with a compatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first != mangleName ) return true;
-                        }
-                }
-
-                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
-        }
-
-        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return false;
-                if ( tables->scope < scope ) return false;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                // check for C decls with the same name, skipping
-                                // those with an incompatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first == mangleName ) return true;
-                        }
-                }
-
-                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
-        }
-
-        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-                if ( tables->scope > scope ) return tables->base.lookupTypeAtScope( id, scope );
-
-                TypeTable::const_iterator ret = tables->typeTable.find( id );
-                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
-        }
-
-        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-                if ( tables->scope > scope ) return tables->base.lookupStructAtScope( id, scope );
-
-                StructTable::const_iterator ret = tables->structTable.find( id );
-                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
-        }
-
-        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-                if ( tables->scope > scope ) return tables->base.lookupEnumAtScope( id, scope );
-
-                EnumTable::const_iterator ret = tables->enumTable.find( id );
-                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
-        }
-
-        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-                if ( tables->scope > scope ) return tables->base.lookupUnionAtScope( id, scope );
-
-                UnionTable::const_iterator ret = tables->unionTable.find( id );
-                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
-        }
-
-        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-                if ( tables->scope > scope ) return tables->base.lookupTraitAtScope( id, scope );
-
-                TraitTable::const_iterator ret = tables->traitTable.find( id );
-                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
+                return atScope( 0 )->lookupEnum( id );
         }
 
@@ -424 +207 @@
         }
 
-        bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
-                // if we're giving the same name mangling to things of different types then there is something wrong
+        
+        bool Indexer::addedIdConflicts( 
+                        const Indexer::IdData & existing, DeclarationWithType *added, 
+                        Indexer::OnConflict handleConflicts, BaseSyntaxNode * deleteStmt ) {
+                // if we're giving the same name mangling to things of different types then there is 
+                // something wrong
                 assert( (isObject( added ) && isObject( existing.id ) )
                         || ( isFunction( added ) && isFunction( existing.id ) ) );
 
-                if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
+                if ( LinkageSpec::isOverridable( existing.id->linkage ) ) {
                         // new definition shadows the autogenerated one, even at the same scope
                         return false;
-                } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing.id->get_type(), Indexer() ) ) {
+                } else if ( LinkageSpec::isMangled( added->linkage ) 
+                                || ResolvExpr::typesCompatible( 
+                                        added->get_type(), existing.id->get_type(), Indexer() ) ) {
 
                         // it is a conflict if one declaration is deleted and the other is not
                         if ( deleteStmt && ! existing.deleteStmt ) {
-                                return handleConflicts( existing, "deletion of defined identifier " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "deletion of defined identifier " );
+                                }
+                                return true;
                         } else if ( ! deleteStmt && existing.deleteStmt ) {
-                                return handleConflicts( existing, "definition of deleted identifier " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "definition of deleted identifier " );
+                                }
+                                return true;
                         }
 
                         if ( isDefinition( added ) && isDefinition( existing.id ) ) {
-                                if ( isFunction( added ) ) {
-                                        return handleConflicts( existing, "duplicate function definition for " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, 
+                                                isFunction( added ) ? 
+                                                        "duplicate function definition for " : 
+                                                        "duplicate object definition for " );
+                                }
+                                return true;
+                        } // if
+                } else {
+                        if ( handleConflicts.mode == OnConflict::Error ) {
+                                SemanticError( added, "duplicate definition for " );
+                        }
+                        return true;
+                } // if
+
+                return true;
+        }
+
+        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with compatible type (by mangleName)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first == mangleName ) {
+                                return true;
+                        }
+                }
+                
+                return false;
+        }
+
+        bool Indexer::hasIncompatibleCDecl( 
+                        const std::string &id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+
+                ++*stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with incompatible type (by manglename)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first != mangleName ) {
+                                return true;
+                        }
+                }
+
+                return false;
+        }
+
+        /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
+        std::string getOtypeKey( FunctionDecl* function ) {
+                auto& params = function->type->parameters;
+                assert( ! params.empty() );
+                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                Type* base = InitTweak::getPointerBase( params.front()->get_type() );
+                assert( base );
+                return Mangler::mangle( base );
+        }
+
+        /// gets the declaration for the function acting on a type specified by otype key, 
+        /// nullptr if none such
+        FunctionDecl * getFunctionForOtype( DeclarationWithType * decl, const std::string& otypeKey ) {
+                FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl );
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                return func;
+        }
+
+        bool Indexer::removeSpecialOverrides( 
+                        Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which 
+                // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular, 
+                // if the user defines a default ctor, then the generated default ctor is unavailable, 
+                // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated 
+                // field ctors are available. If the user defines any ctor then the generated default ctor 
+                // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines 
+                // anything that looks like a copy constructor, then the generated copy constructor is 
+                // unavailable, and likewise for the assignment operator.
+
+                // only relevant on function declarations
+                FunctionDecl * function = dynamic_cast< FunctionDecl * >( data.id );
+                if ( ! function ) return true;
+                // only need to perform this check for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true;
+
+                // set up information for this type
+                bool dataIsUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                bool dataIsCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                std::string dataOtypeKey = getOtypeKey( function );
+
+                if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
+                        // this is a user-defined copy function
+                        // if this is the first such, delete/remove non-user-defined overloads as needed
+                        std::vector< std::string > removed;
+                        std::vector< MangleTable::value_type > deleted;
+                        bool alreadyUserDefinedFunc = false;
+                        
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                bool isCopyFunc = InitTweak::isCopyFunction( decl, decl->name );
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) {
+                                        // matching user-defined function
+                                        if ( isCopyFunc ) {
+                                                // mutation already performed, return early
+                                                return true;
+                                        } else {
+                                                // note that non-copy deletions already performed
+                                                alreadyUserDefinedFunc = true;
+                                        }
                                 } else {
-                                        return handleConflicts( existing, "duplicate object definition for " );
-                                } // if
-                        } // if
-                } else {
-                        return handleConflicts( existing, "duplicate definition for " );
-                } // if
-
+                                        // non-user-defined function; mark for deletion/removal as appropriate
+                                        if ( isCopyFunc ) {
+                                                removed.push_back( entry.first );
+                                        } else if ( ! alreadyUserDefinedFunc ) {
+                                                deleted.push_back( entry );
+                                        }
+                                }
+                        }
+
+                        // perform removals from mangle table, and deletions if necessary
+                        for ( const auto& key : removed ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->erase( key );
+                        }
+                        if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( dataIsUserDefinedFunc ) {
+                        // this is a user-defined non-copy function
+                        // if this is the first user-defined function, delete non-user-defined overloads
+                        std::vector< MangleTable::value_type > deleted;
+                        
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                // exit early if already a matching user-defined function;
+                                // earlier function will have mutated table
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) return true;
+
+                                // skip mutating intrinsic functions
+                                if ( decl->linkage == LinkageSpec::Intrinsic ) continue;
+
+                                // user-defined non-copy functions do not override copy functions
+                                if ( InitTweak::isCopyFunction( decl, decl->name ) ) continue;
+
+                                // this function to be deleted after mangleTable iteration is complete
+                                deleted.push_back( entry );
+                        }
+
+                        // mark deletions to update mangle table
+                        // this needs to be a separate loop because of iterator invalidation
+                        for ( const auto& entry : deleted ) {
+                                ++*stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( function->linkage != LinkageSpec::Intrinsic ) {
+                        // this is an overridable generated function
+                        // if there already exists a matching user-defined function, delete this appropriately
+                        for ( const auto& entry : *mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                // skip non-user-defined functions
+                                if ( LinkageSpec::isOverridable( decl->linkage ) ) continue;
+
+                                if ( dataIsCopyFunc ) {
+                                        // remove current function if exists a user-defined copy function
+                                        // since the signatures for copy functions don't need to match exactly, using 
+                                        // a delete statement is the wrong approach
+                                        if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
+                                } else {
+                                        // mark current function deleted by first user-defined function found
+                                        data.deleteStmt = decl;
+                                        return true;
+                                }
+                        }
+                }
+                
+                // nothing (more) to fix, return true
                 return true;
         }
 
-        void Indexer::addId( DeclarationWithType *decl, ConflictFunction handleConflicts, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) {
-                if ( decl->name == "" ) return;
-                debugPrint( "Adding Id " << decl->name << std::endl );
-                makeWritable();
-
+        void Indexer::addId( 
+                        DeclarationWithType *decl, OnConflict handleConflicts, Expression * baseExpr, 
+                        BaseSyntaxNode * deleteStmt ) {
+                ++*stats().add_calls;
                 const std::string &name = decl->name;
+                if ( name == "" ) return;
+                
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->linkage ) ) {
-                        // mangle the name without including the appropriate suffix, so overridable routines are placed into the
-                        // same "bucket" as their user defined versions.
+                        // mangle the name without including the appropriate suffix, so overridable routines 
+                        // are placed into the same "bucket" as their user defined versions.
                         mangleName = Mangler::mangle( decl, false );
                 } else {
@@ -470 +449 @@
                 } // if
 
-                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-                if ( ! LinkageSpec::isMangled( decl->linkage ) ) {
-                        // NOTE this is broken in Richard's original code in such a way that it never triggers (it
-                        // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
-                        // have their name as their manglename, hence the error can never trigger).
-                        // The code here is closer to correct, but name mangling would have to be completely
-                        // isomorphic to C type-compatibility, which it may not be.
-                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                // this ensures that no two declarations with the same unmangled name at the same scope 
+                // both have C linkage
+                if ( LinkageSpec::isMangled( decl->linkage ) ) {
+                        // Check that a Cforall declaration doesn't override any C declaration
+                        if ( hasCompatibleCDecl( name, mangleName ) ) {
+                                SemanticError( decl, "Cforall declaration hides C function " );
+                        }
+                } else {
+                        // NOTE: only correct if name mangling is completely isomorphic to C 
+                        // type-compatibility, which it may not be.
+                        if ( hasIncompatibleCDecl( name, mangleName ) ) {
                                 SemanticError( decl, "conflicting overload of C function " );
                         }
-                } else {
-                        // Check that a Cforall declaration doesn't override any C declaration
-                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
-                                SemanticError( decl, "Cforall declaration hides C function " );
-                        }
-                }
-
-                // Skip repeat declarations of the same identifier
-                IdData * existing = lookupIdAtScope( name, mangleName, scope );
-                if ( existing && existing->id && addedIdConflicts( *existing, decl, deleteStmt, handleConflicts ) ) return;
-
-                // add to indexer
-                tables->idTable[ name ][ mangleName ] = IdData{ decl, baseExpr, deleteStmt };
-                ++tables->size;
+                }
+
+                // ensure tables exist and add identifier
+                MangleTable::Ptr mangleTable;
+                if ( ! idTable ) {
+                        idTable = IdTable::new_ptr();
+                        mangleTable = MangleTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto decls = idTable->find( name );
+                        if ( decls == idTable->end() ) {
+                                mangleTable = MangleTable::new_ptr();
+                        } else {
+                                mangleTable = decls->second;
+                                // skip in-scope repeat declarations of same identifier
+                                ++*stats().map_lookups;
+                                auto existing = mangleTable->find( mangleName );
+                                if ( existing != mangleTable->end()
+                                                && existing->second.scope == scope
+                                                && existing->second.id ) {
+                                        if ( addedIdConflicts( existing->second, decl, handleConflicts, deleteStmt ) ) {
+                                                if ( handleConflicts.mode == OnConflict::Delete ) {
+                                                        // set delete expression for conflicting identifier
+                                                        lazyInitScope();
+                                                        *stats().map_mutations += 2;
+                                                        idTable = idTable->set(
+                                                                name,
+                                                                mangleTable->set( 
+                                                                        mangleName, 
+                                                                        IdData{ existing->second, handleConflicts.deleteStmt } ) );
+                                                }
+                                                return;
+                                        }
+                                }
+                        }
+                }
+
+                // add/overwrite with new identifier
+                lazyInitScope();
+                IdData data{ decl, baseExpr, deleteStmt, scope };
+                // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+                *stats().map_mutations += 2;
+                idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
         }
 
         void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
+                addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
         }
 
         void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
+                addId( decl, OnConflict::error(), nullptr, deleteStmt );
         }
 
@@ -518 +530 @@
                         }
                 }
-                // does not need to be added to the table if both existing and added have a base that are the same
+                // does not need to be added to the table if both existing and added have a base that are 
+                // the same
                 return true;
         }
 
         void Indexer::addType( NamedTypeDecl *decl ) {
-                debugPrint( "Adding type " << decl->name << std::endl );
-                makeWritable();
-
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
-                TypeTable::iterator existing = tables->typeTable.find( id );
-                if ( existing == tables->typeTable.end() ) {
-                        NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
-                        if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
-                                tables->typeTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedTypeConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
+
+                if ( ! typeTable ) { 
+                        typeTable = TypeTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = typeTable->find( id );
+                        if ( existing != typeTable->end() 
+                                && existing->second.scope == scope 
+                                && addedTypeConflicts( existing->second.decl, decl ) ) return;
+                }
+                
+                lazyInitScope();
+                ++*stats().map_mutations;
+                typeTable = typeTable->set( id, Scoped<NamedTypeDecl>{ decl, scope } );
         }
 
@@ -551 +564 @@
 
         void Indexer::addStruct( const std::string &id ) {
-                debugPrint( "Adding fwd decl for struct " << id << std::endl );
                 addStruct( new StructDecl( id ) );
         }
 
         void Indexer::addStruct( StructDecl *decl ) {
-                debugPrint( "Adding struct " << decl->name << std::endl );
-                makeWritable();
-
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
-                StructTable::iterator existing = tables->structTable.find( id );
-                if ( existing == tables->structTable.end() ) {
-                        StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->structTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
+
+                if ( ! structTable ) {
+                        structTable = StructTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = structTable->find( id );
+                        if ( existing != structTable->end()  
+                                && existing->second.scope == scope 
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++*stats().map_mutations;
+                structTable = structTable->set( id, Scoped<StructDecl>{ decl, scope } );
         }
 
         void Indexer::addEnum( EnumDecl *decl ) {
-                debugPrint( "Adding enum " << decl->name << std::endl );
-                makeWritable();
-
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
-                EnumTable::iterator existing = tables->enumTable.find( id );
-                if ( existing == tables->enumTable.end() ) {
-                        EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->enumTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
+
+                if ( ! enumTable ) {
+                        enumTable = EnumTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = enumTable->find( id );
+                        if ( existing != enumTable->end()  
+                                && existing->second.scope == scope 
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+                
+                lazyInitScope();
+                ++*stats().map_mutations;
+                enumTable = enumTable->set( id, Scoped<EnumDecl>{ decl, scope } );
         }
 
         void Indexer::addUnion( const std::string &id ) {
-                debugPrint( "Adding fwd decl for union " << id << std::endl );
                 addUnion( new UnionDecl( id ) );
         }
 
         void Indexer::addUnion( UnionDecl *decl ) {
-                debugPrint( "Adding union " << decl->name << std::endl );
-                makeWritable();
-
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
-                UnionTable::iterator existing = tables->unionTable.find( id );
-                if ( existing == tables->unionTable.end() ) {
-                        UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->unionTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
+
+                if ( ! unionTable ) {
+                        unionTable = UnionTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = unionTable->find( id );
+                        if ( existing != unionTable->end() 
+                                && existing->second.scope == scope 
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++*stats().map_mutations;
+                unionTable = unionTable->set( id, Scoped<UnionDecl>{ decl, scope } );
         }
 
         void Indexer::addTrait( TraitDecl *decl ) {
-                debugPrint( "Adding trait " << decl->name << std::endl );
-                makeWritable();
-
+                ++*stats().add_calls;
                 const std::string &id = decl->name;
-                TraitTable::iterator existing = tables->traitTable.find( id );
-                if ( existing == tables->traitTable.end() ) {
-                        TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->traitTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction handleConflicts ) {
+
+                if ( ! traitTable ) {
+                        traitTable = TraitTable::new_ptr();
+                } else {
+                        ++*stats().map_lookups;
+                        auto existing = traitTable->find( id );
+                        if ( existing != traitTable->end() 
+                                && existing->second.scope == scope 
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++*stats().map_mutations;
+                traitTable = traitTable->set( id, Scoped<TraitDecl>{ decl, scope } );
+        }
+
+        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr, 
+                        OnConflict handleConflicts ) {
                 for ( Declaration * decl : aggr->members ) {
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
@@ -642 +654 @@
                                 if ( dwt->name == "" ) {
                                         Type * t = dwt->get_type()->stripReferences();
-                                        if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
+                                        if ( dynamic_cast<StructInstType*>( t ) || dynamic_cast<UnionInstType*>( t ) ) {
                                                 Expression * base = expr->clone();
                                                 ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
@@ -659 +671 @@
                                 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
 
-                                addMembers( aggr, expr, [withStmt](IdData & existing, const std::string &) {
-                                        // on conflict, delete the identifier
-                                        existing.deleteStmt = withStmt;
-                                        return true;
-                                });
+                                addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
                         }
                 }
@@ -685 +693 @@
                 addIds( ftype->returnVals );
                 addIds( ftype->parameters );
-        }
-
-        void Indexer::enterScope() {
-                ++scope;
-
-                if ( doDebug ) {
-                        std::cerr << "--- Entering scope " << scope << std::endl;
-                }
-        }
-
-        void Indexer::leaveScope() {
-                using std::cerr;
-
-                assert( scope > 0 && "cannot leave initial scope" );
-                if ( doDebug ) {
-                        cerr << "--- Leaving scope " << scope << " containing" << std::endl;
-                }
-                --scope;
-
-                while ( tables && tables->scope > scope ) {
-                        if ( doDebug ) {
-                                dump( tables->idTable, cerr );
-                                dump( tables->typeTable, cerr );
-                                dump( tables->structTable, cerr );
-                                dump( tables->enumTable, cerr );
-                                dump( tables->unionTable, cerr );
-                                dump( tables->traitTable, cerr );
-                        }
-
-                        // swap tables for base table until we find one at an appropriate scope
-                        Indexer::Impl *base = newRef( tables->base.tables );
-                        deleteRef( tables );
-                        tables = base;
-                }
-        }
-
-        void Indexer::print( std::ostream &os, int indent ) const {
-                using std::cerr;
-
-                if ( tables ) {
-                        os << "--- scope " << tables->scope << " ---" << std::endl;
-
-                        os << "===idTable===" << std::endl;
-                        dump( tables->idTable, os );
-                        os << "===typeTable===" << std::endl;
-                        dump( tables->typeTable, os );
-                        os << "===structTable===" << std::endl;
-                        dump( tables->structTable, os );
-                        os << "===enumTable===" << std::endl;
-                        dump( tables->enumTable, os );
-                        os << "===unionTable===" << std::endl;
-                        dump( tables->unionTable, os );
-                        os << "===contextTable===" << std::endl;
-                        dump( tables->traitTable, os );
-
-                        tables->base.print( os, indent );
-                } else {
-                        os << "--- end ---" << std::endl;
-                }
-
         }
 

src/SymTab/Indexer.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:38:55 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 16:09:12 2017
-// Update Count     : 8
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 9
 //
 
 #pragma once
 
-#include <iosfwd>             // for ostream
-#include <list>               // for list
-#include <string>             // for string
-#include <functional>         // for function
+#include <functional>              // for function
+#include <list>                    // for list
+#include <memory>                  // for shared_ptr, enable_shared_from_this
+#include <string>                  // for string
 
-#include "SynTree/Visitor.h"  // for Visitor
-#include "SynTree/SynTree.h"  // for AST nodes
+#include "Common/PersistentMap.h"  // for PersistentMap
+#include "SynTree/SynTree.h"       // for AST nodes
 
 namespace ResolvExpr {
-class Cost;
+        class Cost;
 }
 
 namespace SymTab {
-        class Indexer {
-          public:
+        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
+        public:
                 explicit Indexer();
+                virtual ~Indexer();
 
-                Indexer( const Indexer &that );
-                Indexer( Indexer &&that );
-                virtual ~Indexer();
-                Indexer& operator= ( const Indexer &that );
-                Indexer& operator= ( Indexer &&that );
-
-                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
-                // explicitly when scopes begin and end
+                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to 
+                // tell the indexer explicitly when scopes begin and end
                 void enterScope();
                 void leaveScope();
@@ -50 +45 @@
                         /// non-null if this declaration is deleted
                         BaseSyntaxNode * deleteStmt = nullptr;
+                        /// scope of identifier
+                        unsigned long scope = 0;
 
                         // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
                         IdData() = default;
-                        IdData( DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
+                        IdData( 
+                                DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt,
+                                unsigned long scope ) 
+                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
+                        IdData( const IdData& o, BaseSyntaxNode * deleteStmt )
+                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}
 
                         Expression * combine( ResolvExpr::Cost & cost ) const;
@@ -80 +82 @@
                 EnumDecl *globalLookupEnum( const std::string &id ) const;
 
-                void print( std::ostream &os, int indent = 0 ) const;
-
-                /// looks up a specific mangled ID at the given scope
-                IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope );
-                const IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
-                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
-                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
-                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
-                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
-                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
-                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
-                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
-
-                typedef std::function<bool(IdData &, const std::string &)> ConflictFunction;
-
                 void addId( DeclarationWithType * decl, Expression * baseExpr = nullptr );
                 void addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt );
@@ -112 +96 @@
                 void addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt );
 
-                /// adds all of the members of the Aggregate (addWith helper)
-                void addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction );
-
                 /// convenience function for adding a list of Ids to the indexer
                 void addIds( const std::list< DeclarationWithType * > & decls );
@@ -124 +105 @@
                 void addFunctionType( FunctionType * ftype );
 
-                bool doDebug = false; ///< Display debugging trace?
           private:
-                struct Impl;
+                /// Wraps a Decl* with a scope
+                template<typename Decl>
+                struct Scoped {
+                        Decl* decl;           ///< declaration
+                        unsigned long scope;  ///< scope of this declaration
 
-                Impl *tables;         ///< Copy-on-write instance of table data structure
-                unsigned long scope;  ///< Scope index of this pointer
+                        Scoped(Decl* d, unsigned long s) : decl(d), scope(s) {}
+                };
 
-                /// Takes a new ref to a table (returns null if null)
-                static Impl *newRef( Impl *toClone );
-                /// Clears a ref to a table (does nothing if null)
-                static void deleteRef( Impl *toFree );
+                using Ptr = std::shared_ptr<const Indexer>;
 
-                // Removes matching autogenerated constructors and destructors
-                // so that they will not be selected
-                // void removeSpecialOverrides( FunctionDecl *decl );
-                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
+                using MangleTable = PersistentMap< std::string, IdData >;
+                using IdTable = PersistentMap< std::string, MangleTable::Ptr >;
+                using TypeTable = PersistentMap< std::string, Scoped<NamedTypeDecl> >;
+                using StructTable = PersistentMap< std::string, Scoped<StructDecl> >;
+                using EnumTable = PersistentMap< std::string, Scoped<EnumDecl> >;
+                using UnionTable = PersistentMap< std::string, Scoped<UnionDecl> >;
+                using TraitTable = PersistentMap< std::string, Scoped<TraitDecl> >;
 
-                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
-                void makeWritable();
+                IdTable::Ptr idTable;          ///< identifier namespace
+                TypeTable::Ptr typeTable;      ///< type namespace
+                StructTable::Ptr structTable;  ///< struct namespace
+                EnumTable::Ptr enumTable;      ///< enum namespace
+                UnionTable::Ptr unionTable;    ///< union namespace
+                TraitTable::Ptr traitTable;    ///< trait namespace
+
+                Ptr prevScope;                 ///< reference to indexer for parent scope
+                unsigned long scope;           ///< Scope index of this indexer
+                unsigned long repScope;        ///< Scope index of currently represented scope
+
+                /// Ensures that a proper backtracking scope exists before a mutation
+                void lazyInitScope();
+
+                /// Gets the indexer at the given scope
+                const Indexer* atScope( unsigned long scope ) const;
+
+                /// Removes matching autogenerated constructors and destructors so that they will not be 
+                /// selected. If returns false, passed decl should not be added.
+                bool removeSpecialOverrides( IdData& decl, MangleTable::Ptr& mangleTable );
+
+                /// Options for handling identifier conflicts
+                struct OnConflict {
+                        enum {
+                                Error,  ///< Throw a semantic error
+                                Delete  ///< Delete the earlier version with the delete statement
+                        } mode;
+                        BaseSyntaxNode * deleteStmt;  ///< Statement that deletes this expression
+
+                private:
+                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
+                        OnConflict( BaseSyntaxNode * d ) : mode(Delete), deleteStmt(d) {}
+                public:
+                        OnConflict( const OnConflict& ) = default;
+
+                        static OnConflict error() { return {}; }
+                        static OnConflict deleteWith( BaseSyntaxNode * d ) { return { d }; }
+                };
+
+                /// true if the existing identifier conflicts with the added identifier
+                bool addedIdConflicts(
+                        const IdData& existing, DeclarationWithType * added, OnConflict handleConflicts, 
+                        BaseSyntaxNode * deleteStmt );
 
                 /// common code for addId, addDeletedId, etc.
-                void addId( DeclarationWithType * decl, ConflictFunction, Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+                void addId( 
+                        DeclarationWithType * decl, OnConflict handleConflicts, 
+                        Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( AggregateDecl * aggr, Expression * expr, OnConflict handleConflicts );
+
+                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
+                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
+                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
+                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
         };
 } // namespace SymTab

src/SymTab/Mangler.cc

@@ -38 +38 @@
                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
-                                Mangler( const ResolvExpr::TypeEnvironment& env );
                                 Mangler( const Mangler & ) = delete;
 
@@ -67 +66 @@
                           private:
                                 std::ostringstream mangleName;  ///< Mangled name being constructed
-                                typedef std::map< std::string, std::pair< std::string, int > > VarMapType;
+                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
                                 VarMapType varNums;             ///< Map of type variables to indices
                                 int nextVarNum;                 ///< Next type variable index
-                                const ResolvExpr::TypeEnvironment* env;  ///< optional environment for substitutions
                                 bool isTopLevel;                ///< Is the Mangler at the top level
                                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
@@ -80 +78 @@
                           public:
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
-                                        int nextVarNum, const ResolvExpr::TypeEnvironment* env, 
-                                        const VarMapType& varNums );
+                                        int nextVarNum, const VarMapType& varNums );
 
                           private:
@@ -109 +106 @@
                 }
 
-                std::string mangleAssnKey( DeclarationWithType* decl, 
-                                const ResolvExpr::TypeEnvironment& env ) {
-                        PassVisitor<Mangler> mangler( env );
-                        maybeAccept( decl, mangler );
-                        return mangler.pass.get_mangleName();
-                }
-
                 namespace {
                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
-                                : nextVarNum( 0 ), env(nullptr), isTopLevel( true ), 
+                                : nextVarNum( 0 ), isTopLevel( true ), 
                                 mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
                                 mangleGenericParams( mangleGenericParams ) {}
                         
-                        Mangler::Mangler( const ResolvExpr::TypeEnvironment& env )
-                                : nextVarNum( 0 ), env( &env ), isTopLevel( true ), mangleOverridable( false ),
-                                typeMode( false ), mangleGenericParams( true ) {}
-                        
                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
-                                int nextVarNum, const ResolvExpr::TypeEnvironment* env, 
-                                const VarMapType& varNums )
-                                : varNums( varNums ), nextVarNum( nextVarNum ), env( env ), isTopLevel( false ), 
+                                int nextVarNum, const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ), 
                                 mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
                                 mangleGenericParams( mangleGenericParams ) {}
@@ -358 +343 @@
                                                         assert( false );
                                                 } // switch
-                                                std::string varName;
-                                                // replace type with substitution name if environment is available and bound
-                                                if ( env ) {
-                                                        const ResolvExpr::EqvClass* varClass = env->lookup( (*i)->name );
-                                                        if ( varClass && varClass->type ) {
-                                                                PassVisitor<Mangler> sub_mangler(
-                                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, 
-                                                                        env, varNums );
-                                                                varClass->type->accept( sub_mangler );
-                                                                varName = std::string{"%"} + sub_mangler.pass.get_mangleName();
-                                                        }
-                                                }
-                                                // otherwise just give type numeric name
-                                                if ( varName.empty() ) {
-                                                        varName = std::to_string( nextVarNum++ );
-                                                }
-                                                varNums[ (*i)->name ] = std::make_pair( varName, (int)(*i)->get_kind() );
+                                                varNums[ (*i)->name ] = std::make_pair( nextVarNum, (int)(*i)->get_kind() );
                                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
                                                         PassVisitor<Mangler> sub_mangler( 
-                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env, 
-                                                                varNums );
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
                                                         (*assert)->accept( sub_mangler );
                                                         assertionNames.push_back( sub_mangler.pass.get_mangleName() );

src/SymTab/Mangler.h

@@ -44 +44 @@
                 /// Mangle ignoring generic type parameters
                 std::string mangleConcrete( Type* ty );
-                /// Mangle for assertion key
-                std::string mangleAssnKey( DeclarationWithType* decl, 
-                        const ResolvExpr::TypeEnvironment& env );
 
                 namespace Encoding {

src/SymTab/ManglerCommon.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:45:30 2017
-// Update Count     : 15
+// Last Modified On : Thu Feb 14 17:06:37 2019
+// Update Count     : 26
 //
 
@@ -23 +23 @@
                         const std::string manglePrefix = "_X";
 
-                        const std::string basicTypes[] = {
-                                "b",  // Bool
-                                "c",  // Char
-                                "a",  // SignedChar
-                                "h",  // UnsignedChar
-                                "s",  // ShortSignedInt
-                                "t",  // ShortUnsignedInt
-                                "i",  // SignedInt
-                                "j",  // UnsignedInt
-                                "l",  // LongSignedInt
-                                "m",  // LongUnsignedInt
-                                "x",  // LongLongSignedInt
-                                "y",  // LongLongUnsignedInt
-                                "f",  // Float
-                                "d",  // Double
-                                "e",  // LongDouble
-                                "Cf", // FloatComplex
-                                "Cd", // DoubleComplex
-                                "Ce", // LongDoubleComplex
-                                // Note: imaginary is not an overloadable type in C++
-                                "If", // FloatImaginary
-                                "Id", // DoubleImaginary
-                                "Ie", // LongDoubleImaginary
-                                "n",  // SignedInt128
-                                "o",  // UnsignedInt128
-                                "Dq",  // Float80 -- TODO: itanium says Float80 and LongDouble both encode to "e", but doing this causes problems with constructing long double, because the cost tables are incorrect
-                                "g",  // Float128
-                                // "z", // ellipsis
-                                // "Dd" // # IEEE 754r decimal floating point (64 bits)
-                                // "De" // # IEEE 754r decimal floating point (128 bits)
-                                // "Df" // # IEEE 754r decimal floating point (32 bits)
-                                // "Dh" // # IEEE 754r half-precision floating point (16 bits)
-                                // "DF"N_ // # ISO/IEC TS 18661 binary floating point type _FloatN (N bits)
-                                // "Di" // char32_t
-                                // "Ds" // char16_t
-                        };
+                        // GENERATED START, DO NOT EDIT
+                        // GENERATED BY BasicTypes-gen.cc
+                        // NOTES ON MANGLING:
+                        // * Itanium spec says that Float80 encodes to "e" (like LongDouble), but the distinct lengths cause resolution problems.
+                        // * Float128 is supposed to encode to "g", but I wanted it to mangle equal to LongDouble.
+                        // * Mangling for non-standard complex types is by best guess
+                        // * _FloatN is supposed to encode as "DF"N"_"; modified for same reason as above.
+                        // * unused mangling identifiers:
+                        //   - "z" ellipsis
+                        //   - "Dd" IEEE 754r 64-bit decimal floating point (borrowed for _Float32x)
+                        //   - "De" IEEE 754r 128-bit decimal floating point
+                        //   - "Df" IEEE 754r 32-bit decimal floating point
+                        //   - "Dh" IEEE 754r 16-bit decimal floating point (borrowed for _Float16)
+                        //   - "DF"N"_" ISO/IEC TS 18661 N-bit binary floating point (_FloatN)
+                        //   - "Di" char32_t
+                        //   - "Ds" char16_t
+                        const std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = {
+                                "b",        // _Bool
+                                "c",        // char
+                                "a",        // signed char
+                                "h",        // unsigned char
+                                "s",        // signed short int
+                                "t",        // unsigned short int
+                                "i",        // signed int
+                                "j",        // unsigned int
+                                "l",        // signed long int
+                                "m",        // unsigned long int
+                                "x",        // signed long long int
+                                "y",        // unsigned long long int
+                                "n",        // __int128
+                                "o",        // unsigned __int128
+                                "DF16_",    // _Float16
+                                "CDF16_",   // _Float16 _Complex
+                                "DF32_",    // _Float32
+                                "CDF32_",   // _Float32 _Complex
+                                "f",        // float
+                                "Cf",       // float _Complex
+                                "DF32x_",   // _Float32x
+                                "CDF32x_",  // _Float32x _Complex
+                                "DF64_",    // _Float64
+                                "CDF64_",   // _Float64 _Complex
+                                "d",        // double
+                                "Cd",       // double _Complex
+                                "DF64x_",   // _Float64x
+                                "CDF64x_",  // _Float64x _Complex
+                                "Dq",       // __float80
+                                "DF128_",   // _Float128
+                                "CDF128_",  // _Float128 _Complex
+                                "g",        // __float128
+                                "e",        // long double
+                                "Ce",       // long double _Complex
+                                "DF128x_",  // _Float128x
+                                "CDF128x_", // _Float128x _Complex
+                        }; // basicTypes
+                        // GENERATED END
                         static_assert(
                                 sizeof(basicTypes)/sizeof(basicTypes[0]) == BasicType::NUMBER_OF_BASIC_TYPES,

src/SymTab/Validate.cc

@@ -49 +49 @@
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
 #include "ControlStruct/Mutate.h"      // for ForExprMutator
+#include "Common/Stats.h"              // for Stats::Heap
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
@@ -298 +299 @@
                 PassVisitor<FixQualifiedTypes> fixQual;
 
-                acceptAll( translationUnit, hoistDecls );
-                ReplaceTypedef::replaceTypedef( translationUnit );
-                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
-                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
-                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
-                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
-                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
-                EliminateTypedef::eliminateTypedef( translationUnit ); //
-                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
-                VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
-                ReturnChecker::checkFunctionReturns( translationUnit );
-                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
-                Concurrency::applyKeywords( translationUnit );
-                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
-                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
-                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
-                Concurrency::implementMutexFuncs( translationUnit );
-                Concurrency::implementThreadStarter( translationUnit );
-                mutateAll( translationUnit, compoundliteral );
-                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
-                FixObjectType::fix( translationUnit );
-                ArrayLength::computeLength( translationUnit );
-                Validate::findSpecialDecls( translationUnit );
-                mutateAll( translationUnit, labelAddrFixer );
-                Validate::handleAttributes( translationUnit );
+                {
+                        Stats::Heap::newPass("validate-A");
+                        Stats::Time::BlockGuard guard("validate-A");
+                        acceptAll( translationUnit, hoistDecls );
+                        ReplaceTypedef::replaceTypedef( translationUnit );
+                        ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                        acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
+                }
+                {
+                        Stats::Heap::newPass("validate-B");
+                        Stats::Time::BlockGuard guard("validate-B");
+                        Stats::Time::TimeBlock("Link Reference To Types", [&]() {
+                                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        });
+                        Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
+                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
+                        });
+                        Stats::Time::TimeBlock("Hoist Structs", [&]() {
+                                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
+                        });
+                        Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
+                                EliminateTypedef::eliminateTypedef( translationUnit ); //
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-C");
+                        Stats::Time::BlockGuard guard("validate-C");
+                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
+                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                        ReturnChecker::checkFunctionReturns( translationUnit );
+                        InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                }
+                {
+                        Stats::Heap::newPass("validate-D");
+                        Stats::Time::BlockGuard guard("validate-D");
+                        Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
+                                Concurrency::applyKeywords( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
+                                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
+                        });
+                        Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
+                                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
+                        });
+                        Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
+                                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-E");
+                        Stats::Time::BlockGuard guard("validate-E");
+                        Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
+                                Concurrency::implementMutexFuncs( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Implement Thread Start", [&]() {
+                                Concurrency::implementThreadStarter( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Compound Literal", [&]() {
+                                mutateAll( translationUnit, compoundliteral );
+                        });
+                        Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
+                                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-F");
+                        Stats::Time::BlockGuard guard("validate-F");
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                Validate::findSpecialDecls( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
+                }
         }
 

src/SymTab/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SymTab/Indexer.cc \
-       SymTab/Mangler.cc \
-       SymTab/ManglerCommon.cc \
-       SymTab/Validate.cc \
-       SymTab/FixFunction.cc \
-       SymTab/Autogen.cc
+SRC_SYMTAB = \
+      SymTab/Autogen.cc \
+      SymTab/FixFunction.cc \
+      SymTab/Indexer.cc \
+      SymTab/Mangler.cc \
+      SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+
+SRC += $(SRC_SYMTAB)
+SRCDEMANGLE += $(SRC_SYMTAB) SymTab/Demangle.cc

src/SynTree/AddressExpr.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 23:54:44 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Apr 26 12:35:13 2016
-// Update Count     : 6
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb 28 13:13:38 2019
+// Update Count     : 10
 //
 
@@ -47 +47 @@
                 } else {
                         // taking address of non-lvalue -- must be a reference, loses one layer of reference
-                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
-                        set_result( addrType( refType->base ) );
+                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( arg->result ) ) {
+                                set_result( addrType( refType->base ) );
+                        } else {
+                                SemanticError( arg->result, "Attempt to take address of non-lvalue expression: " );
+                        } // if
                 }
                 // result of & is never an lvalue

src/SynTree/Attribute.cc

@@ -21 +21 @@
 #include "Expression.h"      // for Expression
 
-Attribute::Attribute( const Attribute &other ) : name( other.name ) {
+Attribute::Attribute( const Attribute &other ) : BaseSyntaxNode( other ), name( other.name ) {
         cloneAll( other.parameters, parameters );
 }

src/SynTree/BaseSyntaxNode.h

@@ -18 +18 @@
 #include "Common/CodeLocation.h"
 #include "Common/Indenter.h"
+#include "Common/Stats.h"
+
 class Visitor;
 class Mutator;
@@ -23 +25 @@
 class BaseSyntaxNode {
   public:
+  static Stats::Counters::SimpleCounter* new_nodes;
+
         CodeLocation location;
+
+  BaseSyntaxNode() { ++*new_nodes; }
+  BaseSyntaxNode( const BaseSyntaxNode& o ) : location(o.location) { ++*new_nodes; }
 
         virtual ~BaseSyntaxNode() {}

src/SynTree/BasicType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 14:14:03 2017
-// Update Count     : 11
+// Last Modified On : Thu Jan 31 21:37:36 2019
+// Update Count     : 12
 //
 
@@ -30 +30 @@
 
 bool BasicType::isInteger() const {
+        return kind <= UnsignedInt128;
+#if 0
         switch ( kind ) {
           case Bool:
@@ -63 +65 @@
         assert( false );
         return false;
+#endif
 }
 

src/SynTree/Constant.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Spt 28 14:49:00 2018
-// Update Count     : 30
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb 13 18:11:22 2019
+// Update Count     : 32
 //
 
@@ -25 +25 @@
 Constant::Constant( Type * type, std::string rep, double val ) : type( type ), rep( rep ), val( val ) {}
 
-Constant::Constant( const Constant &other ) : rep( other.rep ), val( other.val ) {
+Constant::Constant( const Constant &other ) : BaseSyntaxNode( other ), rep( other.rep ), val( other.val ) {
         type = other.type->clone();
 }

src/SynTree/Declaration.cc

@@ -31 +31 @@
 
 Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
-                : name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
+                : name( name ), linkage( linkage ), uniqueId( 0 ), storageClasses( scs ) {
 }
 
 Declaration::Declaration( const Declaration &other )
-        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
+        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), uniqueId( other.uniqueId ), storageClasses( other.storageClasses ) {
 }
 

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 : Sun Sep  3 19:24:06 2017
-// Update Count     : 131
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr May  2 10:47:00 2019
+// Update Count     : 135
 //
 
@@ -19 +19 @@
 #include <iosfwd>                // for ostream
 #include <list>                  // for list
+#include <unordered_map>         // for unordered_map
 #include <string>                // for string, operator+, allocator, to_string
 
@@ -70 +71 @@
         static Declaration *declFromId( UniqueId id );
 
-  private:
+        UniqueId uniqueId;
         Type::StorageClasses storageClasses;
-        UniqueId uniqueId;
+  private:
 };
 
@@ -166 +167 @@
         CompoundStmt *get_statements() const { return statements; }
         void set_statements( CompoundStmt *newValue ) { statements = newValue; }
+        bool has_body() const { return NULL != statements; }
 
         static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
@@ -211 +213 @@
                 TypeDecl::Kind kind;
                 bool isComplete;
+
                 Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
                 Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
                 Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
+                Data( const Data& d1, const Data& d2 )
+                : kind( d1.kind ), isComplete ( d1.isComplete || d2.isComplete ) {}
+
                 bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
                 bool operator!=(const Data & other) const { return !(*this == other);}
@@ -239 +245 @@
         virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 
-  private:
         Kind kind;
 };
@@ -300 +305 @@
         virtual void accept( Visitor &v ) override { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-  private:
         DeclarationNode::Aggregate kind;
+  private:
         virtual std::string typeString() const override;
 };
@@ -330 +335 @@
         virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
-        std::map< std::string, long long int > enumValues;
+        std::unordered_map< std::string, long long int > enumValues;
         virtual std::string typeString() const override;
 };

src/SynTree/Expression.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 25 14:15:47 2017
-// Update Count     : 54
+// Last Modified On : Tue Feb 19 18:10:55 2019
+// Update Count     : 60
 //
 
@@ -33 +33 @@
 #include "GenPoly/Lvalue.h"
 
-void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream & os, Indenter indent, int level ) {
         if ( ! inferParams.empty() ) {
                 os << indent << "with inferred parameters " << level << ":" << std::endl;
@@ -47 +47 @@
 Expression::Expression() : result( 0 ), env( 0 ) {}
 
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
+Expression::Expression( const Expression & other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
 
 void Expression::spliceInferParams( Expression * other ) {
@@ -62 +62 @@
 }
 
-void Expression::print( std::ostream &os, Indenter indent ) const {
+void Expression::print( std::ostream & os, Indenter indent ) const {
         printInferParams( inferParams, os, indent+1, 0 );
 
@@ -79 +79 @@
 }
 
-ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
+ConstantExpr::ConstantExpr( const ConstantExpr & other) : Expression( other ), constant( other.constant ) {
 }
 
 ConstantExpr::~ConstantExpr() {}
 
-void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstantExpr::print( std::ostream & os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
@@ -124 +124 @@
 }
 
-VariableExpr::VariableExpr( const VariableExpr &other ) : Expression( other ), var( other.var ) {
+VariableExpr::VariableExpr( const VariableExpr & other ) : Expression( other ), var( other.var ) {
 }
 
@@ -137 +137 @@
 }
 
-void VariableExpr::print( std::ostream &os, Indenter indent ) const {
+void VariableExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Variable Expression: ";
         var->printShort(os, indent);
@@ -143 +143 @@
 }
 
-SizeofExpr::SizeofExpr( Expression *expr_ ) :
+SizeofExpr::SizeofExpr( Expression * expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( Type *type_ ) :
+SizeofExpr::SizeofExpr( Type * type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( const SizeofExpr &other ) :
+SizeofExpr::SizeofExpr( const SizeofExpr & other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -162 +162 @@
 }
 
-void SizeofExpr::print( std::ostream &os, Indenter indent) const {
+void SizeofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Sizeof Expression on: ";
         if (isType) type->print(os, indent+1);
@@ -169 +169 @@
 }
 
-AlignofExpr::AlignofExpr( Expression *expr_ ) :
+AlignofExpr::AlignofExpr( Expression * expr_ ) :
                 Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( Type *type_ ) :
+AlignofExpr::AlignofExpr( Type * type_ ) :
                 Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
+AlignofExpr::AlignofExpr( const AlignofExpr & other ) :
         Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -188 +188 @@
 }
 
-void AlignofExpr::print( std::ostream &os, Indenter indent) const {
+void AlignofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Alignof Expression on: ";
         if (isType) type->print(os, indent+1);
@@ -195 +195 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type * type, const std::string & member ) :
                 Expression(), type(type), member(member) {
         assert( type );
@@ -201 +201 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr & other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -208 +208 @@
 }
 
-void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void UntypedOffsetofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Untyped Offsetof Expression on member " << member << " of ";
         type->print(os, indent+1);
@@ -214 +214 @@
 }
 
-OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+OffsetofExpr::OffsetofExpr( Type * type, DeclarationWithType * member ) :
                 Expression(), type(type), member(member) {
         assert( member );
@@ -221 +221 @@
 }
 
-OffsetofExpr::OffsetofExpr( const OffsetofExpr &other ) :
+OffsetofExpr::OffsetofExpr( const OffsetofExpr & other ) :
         Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -228 +228 @@
 }
 
-void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void OffsetofExpr::print( std::ostream & os, Indenter indent) const {
         os << "Offsetof Expression on member " << member->name << " of ";
         type->print(os, indent+1);
@@ -234 +234 @@
 }
 
-OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+OffsetPackExpr::OffsetPackExpr( StructInstType * type ) : Expression(), type( type ) {
         assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
-OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr & other ) : Expression( other ), type( maybeClone( other.type ) ) {}
 
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
 
-void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+void OffsetPackExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Offset pack expression on ";
         type->print(os, indent+1);
@@ -249 +249 @@
 }
 
-AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
+AttrExpr::AttrExpr( Expression * attr, Expression * expr_ ) :
                 Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
 }
 
-AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
+AttrExpr::AttrExpr( Expression * attr, Type * type_ ) :
                 Expression(), attr( attr ), expr(0), type(type_), isType(true) {
 }
 
-AttrExpr::AttrExpr( const AttrExpr &other ) :
+AttrExpr::AttrExpr( const AttrExpr & other ) :
                 Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -267 +267 @@
 }
 
-void AttrExpr::print( std::ostream &os, Indenter indent) const {
+void AttrExpr::print( std::ostream & os, Indenter indent) const {
         os << "Attr ";
         attr->print( os, indent+1);
@@ -278 +278 @@
 }
 
-CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -293 +293 @@
 }
 
-void CastExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Cast of:" << std::endl << indent+1;
+void CastExpr::print( std::ostream & os, Indenter indent ) const {
+        os << (isGenerated ? "Generated " : "Explicit ") << "Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
         os << std::endl << indent << "... to:";
@@ -306 +306 @@
 }
 
-KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
-}
-
-KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+KeywordCastExpr::KeywordCastExpr( Expression * arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
 }
 
@@ -327 +327 @@
 }
 
-void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+void KeywordCastExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Keyword Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
@@ -335 +335 @@
 }
 
-VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+VirtualCastExpr::VirtualCastExpr( Expression * arg_, Type * toType ) : Expression(), arg(arg_) {
         set_result(toType);
 }
 
-VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
 }
 
@@ -346 +346 @@
 }
 
-void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+void VirtualCastExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Virtual Cast of:" << std::endl << indent+1;
         arg->print(os, indent+1);
@@ -359 +359 @@
 }
 
-UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression * aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( aggregate );
 }
 
-UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr & other ) :
                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -373 +373 @@
 }
 
-void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
+void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
         member->print(os, indent+1 );
@@ -381 +381 @@
 }
 
-MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+MemberExpr::MemberExpr( DeclarationWithType * member, Expression * aggregate ) :
                 Expression(), member(member), aggregate(aggregate) {
         assert( member );
@@ -395 +395 @@
 }
 
-MemberExpr::MemberExpr( const MemberExpr &other ) :
+MemberExpr::MemberExpr( const MemberExpr & other ) :
                 Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -404 +404 @@
 }
 
-void MemberExpr::print( std::ostream &os, Indenter indent ) const {
+void MemberExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Member Expression, with field:" << std::endl;
         os << indent+1;
@@ -413 +413 @@
 }
 
-UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
+UntypedExpr::UntypedExpr( Expression * function, const std::list<Expression *> & args ) :
                 Expression(), function(function), args(args) {}
 
-UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
+UntypedExpr::UntypedExpr( const UntypedExpr & other ) :
                 Expression( other ), function( maybeClone( other.function ) ) {
         cloneAll( other.args, args );
@@ -455 +455 @@
 
 
-void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
+void UntypedExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Applying untyped:" << std::endl;
         os << indent+1;
@@ -469 +469 @@
 }
 
-NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+NameExpr::NameExpr( const NameExpr & other ) : Expression( other ), name( other.name ) {
 }
 
 NameExpr::~NameExpr() {}
 
-void NameExpr::print( std::ostream &os, Indenter indent ) const {
+void NameExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Name: " << get_name();
         Expression::print( os, indent );
 }
 
-LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
+LogicalExpr::LogicalExpr( Expression * arg1_, Expression * arg2_, bool andp ) :
                 Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
-LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
+LogicalExpr::LogicalExpr( const LogicalExpr & other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
 }
@@ -493 +493 @@
 }
 
-void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+void LogicalExpr::print( std::ostream & os, Indenter indent )const {
         os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
@@ -504 +504 @@
                 Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 
-ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
+ConditionalExpr::ConditionalExpr( const ConditionalExpr & other ) :
                 Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
 }
@@ -514 +514 @@
 }
 
-void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+void ConditionalExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Conditional expression on: " << std::endl << indent+1;
         arg1->print( os, indent+1 );
@@ -527 +527 @@
 
 
-void AsmExpr::print( std::ostream &os, Indenter indent ) const {
+void AsmExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( inout ) inout->print( os, indent+1 );
@@ -549 +549 @@
 }
 
-void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
+void ImplicitCopyCtorExpr::print( std::ostream & os, Indenter indent ) const {
         os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent+1 );
@@ -570 +570 @@
 }
 
-void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstructorExpr::print( std::ostream & os, Indenter indent ) const {
         os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
@@ -583 +583 @@
 }
 
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr & other ) : Expression( other ), initializer( other.initializer->clone() ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -589 +589 @@
 }
 
-void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+void CompoundLiteralExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Compound Literal Expression: " << std::endl << indent+1;
         result->print( os, indent+1 );
@@ -597 +597 @@
 }
 
-RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
-void RangeExpr::print( std::ostream &os, Indenter indent ) const {
+RangeExpr::RangeExpr( Expression * low, Expression * high ) : low( low ), high( high ) {}
+RangeExpr::RangeExpr( const RangeExpr & other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+void RangeExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
@@ -607 +607 @@
 }
 
-StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
+StmtExpr::StmtExpr( CompoundStmt * statements ) : statements( statements ) {
         computeResult();
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
+StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ) {
         cloneAll( other.returnDecls, returnDecls );
         cloneAll( other.dtors, dtors );
@@ -639 +639 @@
         }
 }
-void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+void StmtExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Statement Expression: " << std::endl << indent+1;
         statements->print( os, indent+1 );
@@ -655 +655 @@
 
 long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+UniqueExpr::UniqueExpr( Expression * expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
         assert( expr );
         assert( count != -1 );
@@ -663 +663 @@
         }
 }
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+UniqueExpr::UniqueExpr( const UniqueExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
 }
 UniqueExpr::~UniqueExpr() {
@@ -670 +670 @@
         delete var;
 }
-void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+void UniqueExpr::print( std::ostream & os, Indenter indent ) const {
         os << "Unique Expression with id:" << id << std::endl << indent+1;
         expr->print( os, indent+1 );

src/SynTree/Expression.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Sep  3 19:23:46 2017
-// Update Count     : 48
+// Last Modified On : Mon Feb 18 18:29:51 2019
+// Update Count     : 49
 //
 
@@ -195 +195 @@
   public:
         Expression * arg;
-        bool isGenerated = true; // whether this cast appeared in the source program
+        bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
 
         CastExpr( Expression * arg, bool isGenerated = true );

src/SynTree/Label.h

@@ -35 +35 @@
         operator std::string() const { return name; }
         bool empty() { return name.empty(); }
-  private:
+
         std::string name;
         Statement * labelled;

src/SynTree/Mutator.h

@@ -121 +121 @@
         virtual Initializer * mutate( ConstructorInit * ctorInit ) = 0 ;
 
-        virtual Subrange * mutate( Subrange * subrange ) = 0;
-
         virtual Constant * mutate( Constant * constant ) = 0;
 

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar  8 14:53:02 2018
-// Update Count     : 78
+// Last Modified On : Tue Mar 12 09:01:53 2019
+// Update Count     : 83
 //
 
@@ -19 +19 @@
 #include <list>                    // for list
 #include <memory>                  // for allocator
-#include <vector>                        // for vector
+#include <vector>                                  // for vector
 
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
@@ -43 +43 @@
         const std::list<Label> & get_labels() const { return labels; }
 
-        virtual Statement *clone() const override = 0;
-        virtual void accept( Visitor &v ) override = 0;
-        virtual Statement *acceptMutator( Mutator &m ) override = 0;
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual Statement * clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Statement * acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -55 +55 @@
         CompoundStmt();
         CompoundStmt( std::list<Statement *> stmts );
-        CompoundStmt( const CompoundStmt &other );
+        CompoundStmt( const CompoundStmt & other );
         virtual ~CompoundStmt();
 
@@ -62 +62 @@
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
-        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -72 +72 @@
         NullStmt( const std::list<Label> & labels = {} );
 
-        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual NullStmt * clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class ExprStmt : public Statement {
   public:
-        Expression *expr;
-
-        ExprStmt( Expression *expr );
-        ExprStmt( const ExprStmt &other );
+        Expression * expr;
+
+        ExprStmt( Expression * expr );
+        ExprStmt( const ExprStmt & other );
         virtual ~ExprStmt();
 
-        Expression *get_expr() { return expr; }
-        void set_expr( Expression *newValue ) { expr = newValue; }
-
-        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * get_expr() { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+
+        virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -98 +98 @@
   public:
         bool voltile;
-        Expression *instruction;
+        Expression * instruction;
         std::list<Expression *> output, input;
         std::list<ConstantExpr *> clobber;
         std::list<Label> gotolabels;
 
-        AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
-        AsmStmt( const AsmStmt &other );
+        AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( const AsmStmt & other );
         virtual ~AsmStmt();
 
@@ -114 +114 @@
         void set_output( const std::list<Expression *> & newValue ) { output = newValue; }
         std::list<Expression *> & get_input() { return input; }
-        void set_input( const std::list<Expression *> &newValue ) { input = newValue; }
+        void set_input( const std::list<Expression *> & newValue ) { input = newValue; }
         std::list<ConstantExpr *> & get_clobber() { return clobber; }
-        void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
+        void set_clobber( const std::list<ConstantExpr *> & newValue ) { clobber = newValue; }
         std::list<Label> & get_gotolabels() { return gotolabels; }
-        void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
+        void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
 
         virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
@@ -141 +141 @@
 class IfStmt : public Statement {
   public:
-        Expression *condition;
-        Statement *thenPart;
-        Statement *elsePart;
+        Expression * condition;
+        Statement * thenPart;
+        Statement * elsePart;
         std::list<Statement *> initialization;
 
-        IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
+        IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
                         std::list<Statement *> initialization = std::list<Statement *>() );
-        IfStmt( const IfStmt &other );
+        IfStmt( const IfStmt & other );
         virtual ~IfStmt();
 
-        std::list<Statement *> &get_initialization() { return initialization; }
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-        Statement *get_thenPart() { return thenPart; }
-        void set_thenPart( Statement *newValue ) { thenPart = newValue; }
-        Statement *get_elsePart() { return elsePart; }
-        void set_elsePart( Statement *newValue ) { elsePart = newValue; }
-
-        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        std::list<Statement *> & get_initialization() { return initialization; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+        Statement * get_thenPart() { return thenPart; }
+        void set_thenPart( Statement * newValue ) { thenPart = newValue; }
+        Statement * get_elsePart() { return elsePart; }
+        void set_elsePart( Statement * newValue ) { elsePart = newValue; }
+
+        virtual IfStmt * clone() const override { return new IfStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -170 +170 @@
         std::list<Statement *> statements;
 
-        SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
-        SwitchStmt( const SwitchStmt &other );
+        SwitchStmt( Expression * condition, const std::list<Statement *> & statements );
+        SwitchStmt( const SwitchStmt & other );
         virtual ~SwitchStmt();
 
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
 
         std::list<Statement *> & get_statements() { return statements; }
 
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-
-        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+
+        virtual SwitchStmt * clone() const override { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
 };
@@ -192 +192 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
-        CaseStmt( const CaseStmt &other );
+        CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false ) throw (SemanticErrorException);
+        CaseStmt( const CaseStmt & other );
         virtual ~CaseStmt();
 
@@ -201 +201 @@
         void set_default(bool b) { _isDefault = b; }
 
-        Expression * &get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-
-        std::list<Statement *> &get_statements() { return stmts; }
-        void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
-
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-
-        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * & get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+
+        std::list<Statement *> & get_statements() { return stmts; }
+        void set_statements( std::list<Statement *> & newValue ) { stmts = newValue; }
+
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+
+        virtual CaseStmt * clone() const override { return new CaseStmt( *this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         bool _isDefault;
@@ -218 +218 @@
 class WhileStmt : public Statement {
   public:
-        Expression *condition;
-        Statement *body;
+        Expression * condition;
+        Statement * body;
         std::list<Statement *> initialization;
         bool isDoWhile;
 
-        WhileStmt( Expression *condition,
-               Statement *body, std::list<Statement *> & initialization, bool isDoWhile = false );
-        WhileStmt( const WhileStmt &other );
+        WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
+        WhileStmt( const WhileStmt & other );
         virtual ~WhileStmt();
 
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-        Statement *get_body() { return body; }
-        void set_body( Statement *newValue ) { body = newValue; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+        Statement * get_body() { return body; }
+        void set_body( Statement * newValue ) { body = newValue; }
         bool get_isDoWhile() { return isDoWhile; }
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -244 +243 @@
   public:
         std::list<Statement *> initialization;
-        Expression *condition;
-        Expression *increment;
-        Statement *body;
-
-        ForStmt( std::list<Statement *> initialization,
-             Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
-        ForStmt( const ForStmt &other );
+        Expression * condition;
+        Expression * increment;
+        Statement * body;
+
+        ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
+        ForStmt( const ForStmt & other );
         virtual ~ForStmt();
 
-        std::list<Statement *> &get_initialization() { return initialization; }
-        Expression *get_condition() { return condition; }
-        void set_condition( Expression *newValue ) { condition = newValue; }
-        Expression *get_increment() { return increment; }
-        void set_increment( Expression *newValue ) { increment = newValue; }
-        Statement *get_body() { return body; }
-        void set_body( Statement *newValue ) { body = newValue; }
-
-        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        std::list<Statement *> & get_initialization() { return initialization; }
+        Expression * get_condition() { return condition; }
+        void set_condition( Expression * newValue ) { condition = newValue; }
+        Expression * get_increment() { return increment; }
+        void set_increment( Expression * newValue ) { increment = newValue; }
+        Statement * get_body() { return body; }
+        void set_body( Statement * newValue ) { body = newValue; }
+
+        virtual ForStmt * clone() const override { return new ForStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -274 +272 @@
         const Label originalTarget;
         Label target;
-        Expression *computedTarget;
+        Expression * computedTarget;
         Type type;
 
         BranchStmt( Label target, Type ) throw (SemanticErrorException);
-        BranchStmt( Expression *computedTarget, Type ) throw (SemanticErrorException);
+        BranchStmt( Expression * computedTarget, Type ) throw (SemanticErrorException);
 
         Label get_originalTarget() { return originalTarget; }
@@ -284 +282 @@
         void set_target( Label newValue ) { target = newValue; }
 
-        Expression *get_computedTarget() { return computedTarget; }
+        Expression * get_computedTarget() { return computedTarget; }
         void set_target( Expression * newValue ) { computedTarget = newValue; }
 
         Type get_type() { return type; }
-        const char *get_typename() { return brType[ type ]; }
-
-        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        const char * get_typename() { return brType[ type ]; }
+
+        virtual BranchStmt * clone() const override { return new BranchStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
-        static const char *brType[];
+        static const char * brType[];
 };
 
 class ReturnStmt : public Statement {
   public:
-        Expression *expr;
-
-        ReturnStmt( Expression *expr );
-        ReturnStmt( const ReturnStmt &other );
+        Expression * expr;
+
+        ReturnStmt( Expression * expr );
+        ReturnStmt( const ReturnStmt & other );
         virtual ~ReturnStmt();
 
-        Expression *get_expr() { return expr; }
-        void set_expr( Expression *newValue ) { expr = newValue; }
-
-        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Expression * get_expr() { return expr; }
+        void set_expr( Expression * newValue ) { expr = newValue; }
+
+        virtual ReturnStmt * clone() const override { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -324 +322 @@
 
         ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
-        ThrowStmt( const ThrowStmt &other );
+        ThrowStmt( const ThrowStmt & other );
         virtual ~ThrowStmt();
 
@@ -333 +331 @@
         void set_target( Expression * newTarget ) { target = newTarget; }
 
-        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual ThrowStmt * clone() const override { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -345 +343 @@
         FinallyStmt * finallyBlock;
 
-        TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
-        TryStmt( const TryStmt &other );
+        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
+        TryStmt( const TryStmt & other );
         virtual ~TryStmt();
 
-        CompoundStmt *get_block() const { return block; }
-        void set_block( CompoundStmt *newValue ) { block = newValue; }
+        CompoundStmt * get_block() const { return block; }
+        void set_block( CompoundStmt * newValue ) { block = newValue; }
         std::list<CatchStmt *>& get_catchers() { return handlers; }
 
-        FinallyStmt *get_finally() const { return finallyBlock; }
-        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
-
-        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        FinallyStmt * get_finally() const { return finallyBlock; }
+        void set_finally( FinallyStmt * newValue ) { finallyBlock = newValue; }
+
+        virtual TryStmt * clone() const override { return new TryStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -367 +365 @@
 
         const Kind kind;
-        Declaration *decl;
-        Expression *cond;
-        Statement *body;
-
-        CatchStmt( Kind kind, Declaration *decl,
-                   Expression *cond, Statement *body );
-        CatchStmt( const CatchStmt &other );
+        Declaration * decl;
+        Expression * cond;
+        Statement * body;
+
+        CatchStmt( Kind kind, Declaration * decl,
+                   Expression * cond, Statement * body );
+        CatchStmt( const CatchStmt & other );
         virtual ~CatchStmt();
 
         Kind get_kind() { return kind; }
-        Declaration *get_decl() { return decl; }
-        void set_decl( Declaration *newValue ) { decl = newValue; }
-        Expression *get_cond() { return cond; }
-        void set_cond( Expression *newCond ) { cond = newCond; }
-        Statement *get_body() { return body; }
-        void set_body( Statement *newValue ) { body = newValue; }
-
-        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        Declaration * get_decl() { return decl; }
+        void set_decl( Declaration * newValue ) { decl = newValue; }
+        Expression * get_cond() { return cond; }
+        void set_cond( Expression * newCond ) { cond = newCond; }
+        Statement * get_body() { return body; }
+        void set_body( Statement * newValue ) { body = newValue; }
+
+        virtual CatchStmt * clone() const override { return new CatchStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class FinallyStmt : public Statement {
   public:
-        CompoundStmt *block;
-
-        FinallyStmt( CompoundStmt *block );
-        FinallyStmt( const FinallyStmt &other );
+        CompoundStmt * block;
+
+        FinallyStmt( CompoundStmt * block );
+        FinallyStmt( const FinallyStmt & other );
         virtual ~FinallyStmt();
 
-        CompoundStmt *get_block() const { return block; }
-        void set_block( CompoundStmt *newValue ) { block = newValue; }
-
-        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        CompoundStmt * get_block() const { return block; }
+        void set_block( CompoundStmt * newValue ) { block = newValue; }
+
+        virtual FinallyStmt * clone() const override { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -438 +436 @@
         } orelse;
 
-        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
 };
@@ -464 +462 @@
 class DeclStmt : public Statement {
   public:
-        Declaration *decl;
-
-        DeclStmt( Declaration *decl );
-        DeclStmt( const DeclStmt &other );
+        Declaration * decl;
+
+        DeclStmt( Declaration * decl );
+        DeclStmt( const DeclStmt & other );
         virtual ~DeclStmt();
 
-        Declaration *get_decl() const { return decl; }
-        void set_decl( Declaration *newValue ) { decl = newValue; }
-
-        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-};
-
-
-/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
-/// immediately before and after the call so that qualified objects can be constructed
-/// with the same functions as unqualified objects.
+        Declaration * get_decl() const { return decl; }
+        void set_decl( Declaration * newValue ) { decl = newValue; }
+
+        virtual DeclStmt * clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
+
+/// represents an implicit application of a constructor or destructor. Qualifiers are replaced immediately before and
+/// after the call so that qualified objects can be constructed with the same functions as unqualified objects.
 class ImplicitCtorDtorStmt : public Statement {
   public:
@@ -492 +489 @@
         virtual ~ImplicitCtorDtorStmt();
 
-        Statement *get_callStmt() const { return callStmt; }
+        Statement * get_callStmt() const { return callStmt; }
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
 
-        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
-        virtual void accept( Visitor &v ) override { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 

src/SynTree/SynTree.h

@@ -34 +34 @@
 class NamedTypeDecl;
 class TypeDecl;
-class FtypeDecl;
-class DtypeDecl;
 class TypedefDecl;
 class AsmDecl;
@@ -90 +88 @@
 class ConstructorExpr;
 class CompoundLiteralExpr;
-class UntypedValofExpr;
 class RangeExpr;
 class UntypedTupleExpr;
@@ -132 +129 @@
 class ConstructorInit;
 
-class Subrange;
-
 //template <class T>    // emulate a union with templates?
 class Constant;

src/SynTree/Type.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 22 10:17:19 2018
-// Update Count     : 39
+// Last Modified On : Thu Jan 31 21:54:16 2019
+// Update Count     : 43
 //
 #include "Type.h"
@@ -25 +25 @@
 
 const char *BasicType::typeNames[] = {
+#if 0
         "_Bool",
         "char",
@@ -49 +50 @@
         "unsigned __int128",
         "__float80",
-        "__float128"
+        "__float128",
+        "_Float16",
+        "_Float32",
+        "_Float32x",
+        "_Float64",
+        "_Float64x",
+        "_Float128",
+        "_Float128x",
+        "_Float16 _Complex",
+        "_Float32 _Complex",
+        "_Float32x _Complex",
+        "_Float64 _Complex",
+        "_Float64x _Complex",
+        "_Float128 _Complex",
+        "_Float128x _Complex",
+#endif
+        "_Bool",
+        "char",
+        "signed char",
+        "unsigned char",
+        "signed short int",
+        "unsigned short int",
+        "signed int",
+        "unsigned int",
+        "signed long int",
+        "unsigned long int",
+        "signed long long int",
+        "unsigned long long int",
+        "__int128",
+        "unsigned __int128",
+        "_Float16",
+        "_Float16 _Complex",
+        "_Float32",
+        "_Float32 _Complex",
+        "float",
+        "float _Complex",
+        //"float _Imaginary",
+        "_Float32x",
+        "_Float32x _Complex",
+        "_Float64",
+        "_Float64 _Complex",
+        "double",
+        "double _Complex",
+        //"double _Imaginary",
+        "_Float64x",
+        "_Float64x _Complex",
+        "__float80",
+        "_Float128",
+        "_Float128 _Complex",
+        "__float128",
+        "long double",
+        "long double _Complex",
+        //"long double _Imaginary",
+        "_Float128x",
+        "_Float128x _Complex",
 };
 static_assert(

src/SynTree/Type.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 14:14:01 2017
-// Update Count     : 154
+// Last Modified On : Thu Feb 14 17:11:24 2019
+// Update Count     : 169
 //
 
@@ -207 +207 @@
 class BasicType : public Type {
   public:
+        // GENERATED START, DO NOT EDIT
+        // GENERATED BY BasicTypes-gen.cc
         enum Kind {
                 Bool,
@@ -220 +222 @@
                 LongLongSignedInt,
                 LongLongUnsignedInt,
-                Float,
-                Double,
-                LongDouble,
-                FloatComplex,
-                DoubleComplex,
-                LongDoubleComplex,
-                FloatImaginary,
-                DoubleImaginary,
-                LongDoubleImaginary,
                 SignedInt128,
                 UnsignedInt128,
-                Float80,
-                Float128,
+                uFloat16,
+                uFloat16Complex,
+                uFloat32,
+                uFloat32Complex,
+                Float,
+                FloatComplex,
+                uFloat32x,
+                uFloat32xComplex,
+                uFloat64,
+                uFloat64Complex,
+                Double,
+                DoubleComplex,
+                uFloat64x,
+                uFloat64xComplex,
+                uuFloat80,
+                uFloat128,
+                uFloat128Complex,
+                uuFloat128,
+                LongDouble,
+                LongDoubleComplex,
+                uFloat128x,
+                uFloat128xComplex,
                 NUMBER_OF_BASIC_TYPES
         } kind;
+        // GENERATED END
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind

src/SynTree/TypeSubstitution.cc

@@ -64 +64 @@
 }
 
+void TypeSubstitution::addVar( std::string formalExpr, Expression *actualExpr ) {
+        varEnv[ formalExpr ] = actualExpr;
+}
+
 void TypeSubstitution::remove( std::string formalType ) {
         TypeEnvType::iterator i = typeEnv.find( formalType );
@@ -108 +112 @@
 namespace {
         struct EnvTrimmer {
-                TypeSubstitution * env, * newEnv;
-                EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
+                const TypeSubstitution * env;
+                TypeSubstitution * newEnv;
+                EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
@@ -120 +125 @@
 
 /// reduce environment to just the parts that are referenced in a given expression
-TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, TypeSubstitution * env ) {
+TypeSubstitution * TypeSubstitution::newFromExpr( Expression * expr, const TypeSubstitution * env ) {
         if ( env ) {
                 TypeSubstitution * newEnv = new TypeSubstitution();

src/SynTree/TypeSubstitution.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:52:24 2017
-// Update Count     : 3
+// Last Modified On : Tue Apr 30 22:52:47 2019
+// Update Count     : 9
 //
 
@@ -19 +19 @@
 #include <iosfwd>                  // for ostream
 #include <list>                    // for list<>::iterator, _List_iterator
-#include <map>                     // for _Rb_tree_iterator, map, map<>::val...
-#include <set>                     // for set
+#include <unordered_map>
+#include <unordered_set>
 #include <string>                  // for string, operator!=
 #include <utility>                 // for pair
@@ -39 +39 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass > int apply( SynTreeClass *&input );
-        template< typename SynTreeClass > int applyFree( SynTreeClass *&input );
+        template< typename SynTreeClass > int apply( SynTreeClass *&input ) const;
+        template< typename SynTreeClass > int applyFree( SynTreeClass *&input ) const;
 
         void add( std::string formalType, Type *actualType );
@@ -48 +48 @@
         bool empty() const;
 
+        void addVar( std::string formalExpr, Expression *actualExpr );
+
         template< typename FormalIterator, typename ActualIterator >
         void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
@@ -56 +58 @@
 
         /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
-        static TypeSubstitution * newFromExpr( Expression * expr, TypeSubstitution * env );
+        static TypeSubstitution * newFromExpr( Expression * expr, const TypeSubstitution * env );
 
         void normalize();
@@ -78 +80 @@
         friend class PassVisitor;
 
-        typedef std::map< std::string, Type* > TypeEnvType;
-        typedef std::map< std::string, Expression* > VarEnvType;
+        typedef std::unordered_map< std::string, Type * > TypeEnvType;
+        typedef std::unordered_map< std::string, Expression * > VarEnvType;
         TypeEnvType typeEnv;
         VarEnvType varEnv;
@@ -89 +91 @@
         auto begin() const -> decltype( typeEnv.begin() ) { return typeEnv.begin(); }
         auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
+
+        auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
+        auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
+        auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
+        auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
 };
 
@@ -98 +105 @@
         ActualIterator actualIt = actualBegin;
         for ( ; formalIt != formalEnd; ++formalIt, ++actualIt ) {
-                if ( TypeDecl *formal = dynamic_cast< TypeDecl* >( *formalIt ) ) {
-                        if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
+                if ( TypeDecl *formal = dynamic_cast< TypeDecl * >( *formalIt ) ) {
+                        if ( TypeExpr *actual = dynamic_cast< TypeExpr * >( *actualIt ) ) {
                                 if ( formal->get_name() != "" ) {
                                         TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
@@ -130 +137 @@
 // definitition must happen after PassVisitor is included so that WithGuards can be used
 struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
-                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+                Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 
                 Type * postmutate( TypeInstType * aggregateUseType );
@@ -143 +150 @@
                 void premutate( UnionInstType * aggregateUseType );
 
-                TypeSubstitution & sub;
+                const TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
-                typedef std::set< std::string > BoundVarsType;
+                typedef std::unordered_set< std::string > BoundVarsType;
                 BoundVarsType boundVars;
 };
 
 template< typename SynTreeClass >
-int TypeSubstitution::apply( SynTreeClass *&input ) {
+int TypeSubstitution::apply( SynTreeClass *&input ) const {
         assert( input );
         PassVisitor<Substituter> sub( *this, false );
@@ -163 +170 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::applyFree( SynTreeClass *&input ) {
+int TypeSubstitution::applyFree( SynTreeClass *&input ) const {
         assert( input );
         PassVisitor<Substituter> sub( *this, true );

src/SynTree/Visitor.h

@@ -123 +123 @@
         virtual void visit( ConstructorInit * ctorInit ) = 0;
 
-        virtual void visit( Subrange * subrange ) = 0;
-
         virtual void visit( Constant * constant ) = 0;
 

src/SynTree/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SynTree/Type.cc \
-       SynTree/VoidType.cc \
-       SynTree/BasicType.cc \
-       SynTree/PointerType.cc \
-       SynTree/ArrayType.cc \
-       SynTree/ReferenceType.cc \
-       SynTree/FunctionType.cc \
-       SynTree/ReferenceToType.cc \
-       SynTree/TupleType.cc \
-       SynTree/TypeofType.cc \
-       SynTree/AttrType.cc \
-       SynTree/VarArgsType.cc \
-       SynTree/ZeroOneType.cc \
-       SynTree/Constant.cc \
-       SynTree/Expression.cc \
-       SynTree/TupleExpr.cc \
-       SynTree/CommaExpr.cc \
-       SynTree/TypeExpr.cc \
-       SynTree/ApplicationExpr.cc \
-       SynTree/AddressExpr.cc \
-       SynTree/Statement.cc \
-       SynTree/CompoundStmt.cc \
-       SynTree/DeclStmt.cc \
-       SynTree/Declaration.cc \
-       SynTree/DeclarationWithType.cc \
-       SynTree/ObjectDecl.cc \
-       SynTree/FunctionDecl.cc \
-       SynTree/AggregateDecl.cc \
-       SynTree/NamedTypeDecl.cc \
-       SynTree/TypeDecl.cc \
-       SynTree/Initializer.cc \
-       SynTree/TypeSubstitution.cc \
-       SynTree/Attribute.cc \
-       SynTree/DeclReplacer.cc
+SRC_SYNTREE = \
+      SynTree/Type.cc \
+      SynTree/VoidType.cc \
+      SynTree/BasicType.cc \
+      SynTree/PointerType.cc \
+      SynTree/ArrayType.cc \
+      SynTree/ReferenceType.cc \
+      SynTree/FunctionType.cc \
+      SynTree/ReferenceToType.cc \
+      SynTree/TupleType.cc \
+      SynTree/TypeofType.cc \
+      SynTree/AttrType.cc \
+      SynTree/VarArgsType.cc \
+      SynTree/ZeroOneType.cc \
+      SynTree/Constant.cc \
+      SynTree/Expression.cc \
+      SynTree/TupleExpr.cc \
+      SynTree/CommaExpr.cc \
+      SynTree/TypeExpr.cc \
+      SynTree/ApplicationExpr.cc \
+      SynTree/AddressExpr.cc \
+      SynTree/Statement.cc \
+      SynTree/CompoundStmt.cc \
+      SynTree/DeclStmt.cc \
+      SynTree/Declaration.cc \
+      SynTree/DeclarationWithType.cc \
+      SynTree/ObjectDecl.cc \
+      SynTree/FunctionDecl.cc \
+      SynTree/AggregateDecl.cc \
+      SynTree/NamedTypeDecl.cc \
+      SynTree/TypeDecl.cc \
+      SynTree/Initializer.cc \
+      SynTree/TypeSubstitution.cc \
+      SynTree/Attribute.cc \
+      SynTree/DeclReplacer.cc
 
+SRC += $(SRC_SYNTREE)
+SRCDEMANGLE += $(SRC_SYNTREE)

src/Tuples/TupleExpansion.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 21 17:35:04 2017
-// Update Count     : 19
+// Last Modified On : Wed Feb 13 18:14:12 2019
+// Update Count     : 21
 //
 
@@ -17 +17 @@
 #include <cassert>                // for assert
 #include <list>                   // for list
-
+#include <vector>
+
+#include "AST/CVQualifiers.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"   // for PassVisitor, WithDeclsToAdd, WithGu...
 #include "Common/ScopedMap.h"     // for ScopedMap
@@ -58 +63 @@
                 };
 
-                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithTypeSubstitution {
+                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithConstTypeSubstitution {
                         Type * postmutate( TupleType * tupleType );
 
@@ -314 +319 @@
                 return new TupleType( qualifiers, types );
         }
+        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
+                (void) exprs;
+                #warning Not implemented; needs Type.cpp in build
+                assertf(false, "Not implemented; needs Type.cpp in build");
+                // // produce the TupleType which aggregates the types of the exprs
+                // std::vector<ast::ptr<ast::Type>> types;
+                // ast::CV::Qualifiers quals{
+                //      ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue |
+                //      ast::CV::Atomic | ast::CV::Mutex };
+
+                // for ( const ast::Expr * expr : exprs ) {
+                //      assert( expr->result );
+                //      // if the type of any expr is void, the type of the entire tuple is void
+                //      if ( expr->result->isVoid() ) return new ast::VoidType{};
+
+                //      // qualifiers on the tuple type are the qualifiers that exist on all components
+                //      quals &= expr->result->qualifiers;
+
+                //      types.emplace_back( expr->result );
+                // }
+
+                // if ( exprs.empty() ) { quals = ast::CV::Qualifiers{}; }
+                // return new ast::TupleType{ std::move(types), quals };
+        }
 
         TypeInstType * isTtype( Type * type ) {

src/Tuples/Tuples.h

@@ -19 +19 @@
 #include <vector>
 
+#include "AST/Fwd.hpp"
+#include "AST/Node.hpp"
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
@@ -27 +29 @@
 namespace Tuples {
         // TupleAssignment.cc
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign, 
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign,
                 std::vector< ResolvExpr::AlternativeFinder >& args );
-        
+
         // TupleExpansion.cc
         /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate
@@ -42 +44 @@
         /// returns VoidType if any of the expressions have Voidtype, otherwise TupleType of the Expression result types
         Type * makeTupleType( const std::list< Expression * > & exprs );
+        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs );
 
         /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
         TypeInstType * isTtype( Type * type );
+        const ast::TypeInstType * isTtype( const ast::Type * type );
 
         /// returns true if the expression may contain side-effects.

src/Tuples/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC +=  Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc \
-        Tuples/Explode.cc
+SRC += Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc Tuples/Explode.cc
+SRCDEMANGLE += Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc Tuples/Explode.cc

src/Validate/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Validate/HandleAttributes.cc \
-        Validate/FindSpecialDecls.cc
+SRC += Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
+SRCDEMANGLE += Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc

src/config.h.in

@@ -52 +52 @@
 #undef CFA_VERSION_SHORT
 
-/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
-   systems. This function is required for `alloca.c' support on those systems.
-   */
-#undef CRAY_STACKSEG_END
-
-/* Define to 1 if using `alloca.c'. */
-#undef C_ALLOCA
-
-/* Define to 1 if you have `alloca', as a function or macro. */
-#undef HAVE_ALLOCA
-
-/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
-   */
-#undef HAVE_ALLOCA_H
+/* Have compiler warning cast-function-type. */
+#undef HAVE_CAST_FUNCTION_TYPE
 
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #undef HAVE_DLFCN_H
 
-/* Define to 1 if you have the <fenv.h> header file. */
-#undef HAVE_FENV_H
-
-/* Define to 1 if you have the <float.h> header file. */
-#undef HAVE_FLOAT_H
-
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
+/* Have keywords _FloatXX. */
+#undef HAVE_KEYWORDS_FLOATXX
+
 /* Define to 1 if you have the <libintl.h> header file. */
 #undef HAVE_LIBINTL_H
-
-/* Define to 1 if you have the <limits.h> header file. */
-#undef HAVE_LIMITS_H
 
 /* Define to 1 if you have the <malloc.h> header file. */
@@ -91 +73 @@
 #undef HAVE_MEMORY_H
 
-/* Define to 1 if you have the `memset' function. */
-#undef HAVE_MEMSET
-
-/* Define to 1 if you have the `putenv' function. */
-#undef HAVE_PUTENV
-
-/* Define to 1 if stdbool.h conforms to C99. */
-#undef HAVE_STDBOOL_H
-
-/* Define to 1 if you have the <stddef.h> header file. */
-#undef HAVE_STDDEF_H
-
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
@@ -109 +79 @@
 #undef HAVE_STDLIB_H
 
-/* Define to 1 if you have the `strchr' function. */
-#undef HAVE_STRCHR
-
 /* Define to 1 if you have the <strings.h> header file. */
 #undef HAVE_STRINGS_H
@@ -117 +84 @@
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H
-
-/* Define to 1 if you have the `strtol' function. */
-#undef HAVE_STRTOL
 
 /* Define to 1 if you have the <sys/stat.h> header file. */
@@ -130 +94 @@
 #undef HAVE_UNISTD_H
 
-/* Define to 1 if the system has the type `_Bool'. */
-#undef HAVE__BOOL
+/* Define to 1 if the system has the type `_Float32'. */
+#undef HAVE__FLOAT32
 
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
@@ -157 +121 @@
 #undef PACKAGE_VERSION
 
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at runtime.
-        STACK_DIRECTION > 0 => grows toward higher addresses
-        STACK_DIRECTION < 0 => grows toward lower addresses
-        STACK_DIRECTION = 0 => direction of growth unknown */
-#undef STACK_DIRECTION
-
 /* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS
@@ -180 +136 @@
    `char[]'. */
 #undef YYTEXT_POINTER
-
-/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
-   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
-   #define below would cause a syntax error. */
-#undef _UINT32_T
-
-/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
-   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
-   #define below would cause a syntax error. */
-#undef _UINT8_T
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif
-
-/* Define to the type of a signed integer type of width exactly 16 bits if
-   such a type exists and the standard includes do not define it. */
-#undef int16_t
-
-/* Define to the type of a signed integer type of width exactly 32 bits if
-   such a type exists and the standard includes do not define it. */
-#undef int32_t
-
-/* Define to the type of a signed integer type of width exactly 8 bits if such
-   a type exists and the standard includes do not define it. */
-#undef int8_t
-
-/* Define to the equivalent of the C99 'restrict' keyword, or to
-   nothing if this is not supported.  Do not define if restrict is
-   supported directly.  */
-#undef restrict
-/* Work around a bug in Sun C++: it does not support _Restrict or
-   __restrict__, even though the corresponding Sun C compiler ends up with
-   "#define restrict _Restrict" or "#define restrict __restrict__" in the
-   previous line.  Perhaps some future version of Sun C++ will work with
-   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
-#if defined __SUNPRO_CC && !defined __RESTRICT
-# define _Restrict
-# define __restrict__
-#endif
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t
-
-/* Define to the type of an unsigned integer type of width exactly 16 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint16_t
-
-/* Define to the type of an unsigned integer type of width exactly 32 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint32_t
-
-/* Define to the type of an unsigned integer type of width exactly 8 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint8_t

src/include/cassert

@@ -45 +45 @@
 }
 
+extern void abort(const char *fmt, ...  ) noexcept __attribute__((noreturn, format(printf, 1, 2)));
 // Local Variables: //
 // tab-width: 4 //

src/main.cc

@@ -7 +7 @@
 // main.cc --
 //
-// Author           : Richard C. Bilson
+// Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 26 08:11:19 2018
-// Update Count     : 499
+// Last Modified On : Fri May  3 16:10:52 2019
+// Update Count     : 599
 //
 
@@ -24 +24 @@
 #include <fstream>                          // for ofstream
 #include <iostream>                         // for operator<<, basic_ostream
+#include <iomanip>
 #include <iterator>                         // for back_inserter
 #include <list>                             // for list
@@ -37 +38 @@
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CompilerError.h"           // for CompilerError
-#include "Common/Heap.h"
+#include "Common/Stats.h"
 #include "Common/PassVisitor.h"
+// #include "AST/Pass.hpp"
 #include "Common/SemanticError.h"           // for SemanticError
 #include "Common/UnimplementedError.h"      // for UnimplementedError
@@ -65 +67 @@
 using namespace std;
 
-#define PASS(name, pass)                   \
+static void NewPass( const char * const name ) {
+        Stats::Heap::newPass( name );
+        using namespace Stats::Counters;
+        {
+                static auto group = build<CounterGroup>( "Pass Visitor" );
+                auto pass = build<CounterGroup>( name, group );
+                pass_visitor_stats.depth = 0;
+                pass_visitor_stats.avg = build<AverageCounter<double>>( "Average Depth", pass );
+                pass_visitor_stats.max = build<MaxCounter<double>>( "Max Depth", pass );
+        }
+        {
+                static auto group = build<CounterGroup>( "Syntax Node" );
+                auto pass = build<CounterGroup>( name, group );
+                BaseSyntaxNode::new_nodes = build<SimpleCounter>( "Allocs", pass );
+        }
+}
+
+#define PASS( name, pass )                  \
         if ( errorp ) { cerr << name << endl; } \
-        HeapStats::newPass(name);               \
-        pass;
+        NewPass(name);                          \
+        Stats::Time::StartBlock(name);          \
+        pass;                                   \
+        Stats::Time::StopBlock();
 
 LinkageSpec::Spec linkage = LinkageSpec::Cforall;
@@ -74 +95 @@
 DeclarationNode * parseTree = nullptr;                                  // program parse tree
 
-std::string PreludeDirector = "";
+static std::string PreludeDirector = "";
 
 static void parse_cmdline( int argc, char *argv[], const char *& filename );
@@ -130 +151 @@
 } // backtrace
 
-void sigSegvBusHandler( int sig_num ) {
+static void sigSegvBusHandler( int sig_num ) {
         cerr << "*CFA runtime error* program cfa-cpp terminated with "
                  <<     (sig_num == SIGSEGV ? "segment fault" : "bus error")
@@ -136 +157 @@
         backtrace( 2 );                                                                         // skip first 2 stack frames
         //_exit( EXIT_FAILURE );
-        abort();
+        abort();                                                                                        // cause core dump for debugging
 } // sigSegvBusHandler
 
-void sigAbortHandler( __attribute__((unused)) int sig_num ) {
+static void sigAbortHandler( __attribute__((unused)) int sig_num ) {
         backtrace( 6 );                                                                         // skip first 6 stack frames
         signal( SIGABRT, SIG_DFL);                                                      // reset default signal handler
-    raise( SIGABRT );                                                                   // reraise SIGABRT
+                raise( SIGABRT );                                                                       // reraise SIGABRT
 } // sigAbortHandler
 
@@ -148 +169 @@
 int main( int argc, char * argv[] ) {
         FILE * input;                                                                           // use FILE rather than istream because yyin is FILE
-        ostream *output = & cout;
-        const char *filename = nullptr;
+        ostream * output = & cout;
+        const char * filename = nullptr;
         list< Declaration * > translationUnit;
 
@@ -181 +202 @@
                 } // if
 
+                Stats::Time::StartGlobal();
+                NewPass("Parse");
+                Stats::Time::StartBlock("Parse");
+
                 // read in the builtins, extras, and the prelude
                 if ( ! nopreludep ) {                                                   // include gcc builtins
@@ -215 +240 @@
                         parseTree->printList( cout );
                         delete parseTree;
-                        return 0;
+                        return EXIT_SUCCESS;
                 } // if
 
@@ -224 +249 @@
                 if ( astp ) {
                         dump( translationUnit );
-                        return 0;
+                        return EXIT_SUCCESS;
                 } // if
 
@@ -231 +256 @@
                 // works okay for now.
                 CodeTools::fillLocations( translationUnit );
+                Stats::Time::StopBlock();
 
                 // add the assignment statement after the initialization of a type parameter
-                PASS( "validate", SymTab::validate( translationUnit, symtabp ) );
+                PASS( "Validate", SymTab::validate( translationUnit, symtabp ) );
                 if ( symtabp ) {
                         deleteAll( translationUnit );
-                        return 0;
+                        return EXIT_SUCCESS;
                 } // if
 
@@ -242 +268 @@
                         PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
                         acceptAll( translationUnit, printer );
-                        return 0;
+                        return EXIT_SUCCESS;
                 } // if
 
                 if ( validp ) {
                         dump( translationUnit );
-                        return 0;
-                } // if
-
-                PASS( "fixLabels", ControlStruct::fixLabels( translationUnit ) );
-                PASS( "fixNames", CodeGen::fixNames( translationUnit ) );
-                PASS( "genInit", InitTweak::genInit( translationUnit ) );
-                PASS( "expandMemberTuples" , Tuples::expandMemberTuples( translationUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
+                PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
+                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
                 if ( libcfap ) {
                         // generate the bodies of cfa library functions
@@ -262 +288 @@
                         CodeTools::printDeclStats( translationUnit );
                         deleteAll( translationUnit );
-                        return 0;
-                }
+                        return EXIT_SUCCESS;
+                } // if
 
                 if ( bresolvep ) {
                         dump( translationUnit );
-                        return 0;
+                        return EXIT_SUCCESS;
                 } // if
 
@@ -274 +300 @@
                 if ( resolvprotop ) {
                         CodeTools::dumpAsResolvProto( translationUnit );
-                        return 0;
-                }
-
-                PASS( "resolve", ResolvExpr::resolve( translationUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
                 if ( exprp ) {
                         dump( translationUnit );
-                        return 0;
+                        return EXIT_SUCCESS;
                 } // if
 
                 // fix ObjectDecl - replaces ConstructorInit nodes
-                PASS( "fixInit", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 if ( ctorinitp ) {
                         dump ( translationUnit );
-                        return 0;
-                } // if
-
-                PASS( "expandUniqueExpr", 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( "translateEHM" , ControlStruct::translateEHM( translationUnit ) );
-
-                PASS( "generateWaitfor" , Concurrency::generateWaitFor( translationUnit ) );
-
-                PASS( "convertSpecializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
-
-                PASS( "expandTuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
+                        return EXIT_SUCCESS;
+                } // if
+
+                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( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
+
+                PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
+
+                PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
 
                 if ( tuplep ) {
                         dump( translationUnit );
-                        return 0;
-                }
-
-                PASS( "virtual expandCasts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
-
-                PASS( "instantiateGenerics", GenPoly::instantiateGeneric( translationUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                PASS( "Virtual Expand Casts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
+
+                PASS( "Instantiate Generics", GenPoly::instantiateGeneric( translationUnit ) );
                 if ( genericsp ) {
                         dump( translationUnit );
-                        return 0;
-                }
-                PASS( "convertLvalue", GenPoly::convertLvalue( translationUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Convert L-Value", GenPoly::convertLvalue( translationUnit ) );
 
 
                 if ( bboxp ) {
                         dump( translationUnit );
-                        return 0;
-                } // if
-                PASS( "box", GenPoly::box( translationUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Box", GenPoly::box( translationUnit ) );
 
                 if ( bcodegenp ) {
                         dump( translationUnit );
-                        return 0;
-                }
+                        return EXIT_SUCCESS;
+                } // if
 
                 if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
@@ -331 +357 @@
 
                 CodeTools::fillLocations( translationUnit );
-                PASS( "codegen", CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true, linemarks ) );
+                PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
 
                 CodeGen::FixMain::fix( *output, (PreludeDirector + "/bootloader.c").c_str() );
@@ -347 +373 @@
                         delete output;
                 } // if
-                return 1;
+                return EXIT_FAILURE;
         } catch ( UnimplementedError &e ) {
                 cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
@@ -353 +379 @@
                         delete output;
                 } // if
-                return 1;
+                return EXIT_FAILURE;
         } catch ( CompilerError &e ) {
                 cerr << "Compiler Error: " << e.get_what() << endl;
@@ -360 +386 @@
                         delete output;
                 } // if
-                return 1;
-        } catch(...) {
+                return EXIT_FAILURE;
+        } catch ( ... ) {
                 std::exception_ptr eptr = std::current_exception();
                 try {
                         if (eptr) {
                                 std::rethrow_exception(eptr);
-                        }
-                        else {
-                                std::cerr << "Exception Uncaught and Unkown" << std::endl;
-                        }
+                        } else {
+                                std::cerr << "Exception Uncaught and Unknown" << std::endl;
+                        } // if
                 } catch(const std::exception& e) {
                         std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
-                }
-                return 1;
-        }// try
+                } // try
+                return EXIT_FAILURE;
+        } // try
 
         deleteAll( translationUnit );
-        if(!libcfap && !treep) HeapStats::printStats();
-        return 0;
+        Stats::print();
+        return EXIT_SUCCESS;
 } // main
 
-void parse_cmdline( int argc, char * argv[], const char *& filename ) {
-        enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, PreludeDir, Prototypes, Resolver, ResolvProto, Symbol, Tree, TupleExpansion, Validate, };
-
-        static struct option long_opts[] = {
-                { "ast", no_argument, 0, Ast },
-                { "before-box", no_argument, 0, Bbox },
-                { "before-resolver", no_argument, 0, Bresolver },
-                { "ctorinitfix", no_argument, 0, CtorInitFix },
-                { "decl-stats", no_argument, 0, DeclStats },
-                { "expr", no_argument, 0, Expr },
-                { "expralt", no_argument, 0, ExprAlt },
-                { "grammar", no_argument, 0, Grammar },
-                { "libcfa", no_argument, 0, LibCFA },
-                { "line-marks", no_argument, 0, Linemarks },
-                { "no-line-marks", no_argument, 0, Nolinemarks },
-                { "no-preamble", no_argument, 0, Nopreamble },
-                { "parse", no_argument, 0, Parse },
-                { "prelude-dir", required_argument, 0, PreludeDir },
-                { "no-prototypes", no_argument, 0, Prototypes },
-                { "resolver", no_argument, 0, Resolver },
-                { "resolv-proto", no_argument, 0, ResolvProto },
-                { "symbol", no_argument, 0, Symbol },
-                { "tree", no_argument, 0, Tree },
-                { "tuple-expansion", no_argument, 0, TupleExpansion },
-                { "validate", no_argument, 0, Validate },
-                { 0, 0, 0, 0 }
-        }; // long_opts
-        int long_index;
-
+
+static const char optstring[] = ":hlLmNn:pP:S:twW:D:F:";
+
+enum { PreludeDir = 128 };
+static struct option long_opts[] = {
+        { "help", no_argument, nullptr, 'h' },
+        { "libcfa", no_argument, nullptr, 'l' },
+        { "linemarks", no_argument, nullptr, 'L' },
+        { "no-main", no_argument, 0, 'm' },
+        { "no-linemarks", no_argument, nullptr, 'N' },
+        { "no-prelude", no_argument, nullptr, 'n' },
+        { "prototypes", no_argument, nullptr, 'p' },
+        { "print", required_argument, nullptr, 'P' },
+        { "prelude-dir", required_argument, nullptr, PreludeDir },
+        { "statistics", required_argument, nullptr, 'S' },
+        { "tree", no_argument, nullptr, 't' },
+        { "", no_argument, nullptr, 0 },                                        // -w
+        { "", no_argument, nullptr, 0 },                                        // -W
+        { "", no_argument, nullptr, 0 },                                        // -D
+        { "", no_argument, nullptr, 0 },                                        // -F
+        { nullptr, 0, nullptr, 0 }
+}; // long_opts
+
+static const char * description[] = {
+        "print help message",                                                           // -h
+        "generate libcfa.c",                                                            // -l
+        "generate line marks",                                                          // -L
+        "do not replace main",                                                          // -m
+        "do not generate line marks",                                           // -N
+        "do not read prelude",                                                          // -n
+        "generate prototypes for prelude functions",            // -p
+        "print",                                                                                        // -P
+        "<directory> prelude directory for debug/nodebug",      // no flag
+        "<option-list> enable profiling information:\n          counters,heap,time,all,none", // -S
+        "build in tree",                                                                        // -t
+        "",                                                                                                     // -w
+        "",                                                                                                     // -W
+        "",                                                                                                     // -D
+        "",                                                                                                     // -F
+}; // description
+
+static_assert( sizeof( long_opts ) / sizeof( long_opts[0] ) - 1 == sizeof( description ) / sizeof( description[0] ), "Long opts and description must match" );
+
+static struct Printopts {
+        const char * name;
+        int & flag;
+        int val;
+        const char * descript;
+} printopts[] = {
+        { "altexpr", expraltp, true, "alternatives for expressions" },
+        { "ascodegen", codegenp, true, "as codegen rather than AST" },
+        { "ast", astp, true, "AST after parsing" },
+        { "astdecl", validp, true, "AST after declaration validation pass" },
+        { "asterr", errorp, true, "AST on error" },
+        { "astexpr", exprp, true, "AST after expression analysis" },
+        { "astgen", genericsp, true, "AST after instantiate generics" },
+        { "box", bboxp, true, "before box step" },
+        { "ctordtor", ctorinitp, true, "after ctor/dtor are replaced" },
+        { "codegen", bcodegenp, true, "before code generation" },
+        { "declstats", declstatsp, true, "code property statistics" },
+        { "parse", yydebug, true, "yacc (parsing) debug information" },
+        { "pretty", prettycodegenp, true, "prettyprint for ascodegen flag" },
+        { "resolver", bresolvep, true, "before resolver step" },
+        { "rproto", resolvprotop, true, "resolver-proto instance" },
+        { "rsteps", resolvep, true, "resolver steps" },
+        { "symevt", symtabp, true, "symbol table events" },
+        { "tree", parsep, true, "parse tree" },
+        { "tuple", tuplep, true, "after tuple expansion" },
+};
+enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };
+
+static void usage( char *argv[] ) {
+    cout << "Usage: " << argv[0] << " options are:" << endl;
+        int i = 0, j = 1;                                                                       // j skips starting colon
+        for ( ; long_opts[i].name != 0 && optstring[j] != '\0'; i += 1, j += 1 ) {
+                if ( long_opts[i].name[0] != '\0' ) {                   // hidden option, internal usage only
+                        if ( strcmp( long_opts[i].name, "prelude-dir" ) != 0 ) { // flag
+                                cout << "  -" << optstring[j] << ",";
+                        } else {                                                                        // no flag
+                                j -= 1;                                                                 // compensate
+                                cout << "     ";
+                        } // if
+                        cout << " --" << left << setw(12) << long_opts[i].name << "  ";
+                        if ( strcmp( long_opts[i].name, "print" ) == 0 ) {
+                                cout << "one of: " << endl;
+                                for ( int i = 0; i < printoptsSize; i += 1 ) {
+                                        cout << setw(10) << " " << left << setw(10) << printopts[i].name << "  " << printopts[i].descript << endl;
+                                } // for
+                        } else {
+                                cout << description[i] << endl;
+                        } // if
+                } // if
+                if ( optstring[j + 1] == ':' ) j += 1;
+        } // for
+        if ( long_opts[i].name != 0 || optstring[j] != '\0' ) assertf( false, "internal error, mismatch of option flags and names\n" );
+    exit( EXIT_FAILURE );
+} // usage
+
+static void parse_cmdline( int argc, char * argv[], const char *& filename ) {
         opterr = 0;                                                                                     // (global) prevent getopt from printing error messages
 
         bool Wsuppress = false, Werror = false;
         int c;
-        while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrRstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, optstring, long_opts, nullptr )) != -1 ) {
                 switch ( c ) {
-                  case Ast:
-                  case 'a':                                                                             // dump AST
-                        astp = true;
-                        break;
-                  case Bresolver:
-                  case 'b':                                                                             // print before resolver steps
-                        bresolvep = true;
-                        break;
-                  case 'B':                                                                             // print before box steps
-                        bboxp = true;
-                        break;
-                  case CtorInitFix:
-                  case 'c':                                                                             // print after constructors and destructors are replaced
-                        ctorinitp = true;
-                        break;
-                  case 'C':                                                                             // print before code generation
-                        bcodegenp = true;
-                        break;
-                  case DeclStats:
-                  case 'd':
-                    declstatsp = true;
-                        break;
-                  case Expr:
-                  case 'e':                                                                             // dump AST after expression analysis
-                        exprp = true;
-                        break;
-                  case ExprAlt:
-                  case 'f':                                                                             // print alternatives for expressions
-                        expraltp = true;
-                        break;
-                  case Grammar:
-                  case 'g':                                                                             // bison debugging info (grammar rules)
-                        yydebug = true;
-                        break;
-                  case 'G':                                                                             // dump AST after instantiate generics
-                        genericsp = true;
-                        break;
-                  case LibCFA:
+                  case 'h':                                                                             // help message
+                        usage( argv );                                                          // no return
+                        break;
                   case 'l':                                                                             // generate libcfa.c
                         libcfap = true;
                         break;
-                  case Linemarks:
-                  case 'L':                                                                             // print lines marks
+                  case 'L':                                                                             // generate line marks
                         linemarks = true;
                         break;
-                  case Nopreamble:
-                  case 'n':                                                                             // do not read preamble
+                  case 'm':                                                                             // do not replace main
+                        nomainp = true;
+                        break;
+                  case 'N':                                                                             // do not generate line marks
+                        linemarks = false;
+                        break;
+                  case 'n':                                                                             // do not read prelude
                         nopreludep = true;
                         break;
-                  case Nolinemarks:
-                  case 'N':                                                                             // suppress line marks
-                        linemarks = false;
-                        break;
-                  case Prototypes:
-                  case 'p':                                                                             // generate prototypes for preamble functions
-                        noprotop = true;
-                        break;
-                  case PreludeDir:
-                        PreludeDirector = optarg;
-                        break;
-                  case 'm':                                                                             // don't replace the main
-                        nomainp = true;
-                        break;
-                  case Parse:
-                  case 'q':                                                                             // dump parse tree
-                        parsep = true;
-                        break;
-                  case Resolver:
-                  case 'r':                                                                             // print resolver steps
-                        resolvep = true;
-                        break;
-                  case 'R':                                                                             // dump resolv-proto instance
-                        resolvprotop = true;
-                        break;
-                  case Symbol:
-                  case 's':                                                                             // print symbol table events
-                        symtabp = true;
-                        break;
-                  case Tree:
+                  case 'p':                                                                             // generate prototypes for prelude functions
+                        genproto = true;
+                        break;
+                  case 'P':                                                                             // print options
+                        for ( int i = 0;; i += 1 ) {
+                                if ( i == printoptsSize ) {
+                                        cout << "Unknown --print option " << optarg << endl;
+                                        goto Default;
+                                } // if
+                                if ( strcmp( optarg, printopts[i].name ) == 0 ) {
+                                        printopts[i].flag = printopts[i].val;
+                                        break;
+                                } // if
+                        } // for
+                        break;
+                  case PreludeDir:                                                              // prelude directory for debug/nodebug, hidden
+                        PreludeDirector = optarg;
+                        break;
+                  case 'S':                                                                             // enable profiling information, argument comma separated list of names
+                        Stats::parse_params( optarg );
+                        break;
                   case 't':                                                                             // build in tree
                         treep = true;
                         break;
-                  case TupleExpansion:
-                  case 'T':                                                                             // print after tuple expansion
-                        tuplep = true;
-                        break;
-                  case 'v':                                                                             // dump AST after decl validation pass
-                        validp = true;
-                        break;
-                  case 'w':
+                  case 'w':                                                                             // suppress all warnings, hidden
                         Wsuppress = true;
                         break;
-                  case 'W':
+                  case 'W':                                                                             // coordinate gcc -W with CFA, hidden
                         if ( strcmp( optarg, "all" ) == 0 ) {
                                 SemanticWarning_EnableAll();
@@ -525 +573 @@
                         } // if
                         break;
-                  case 'y':                                                                             // dump AST on error
-                        errorp = true;
-                        break;
-                  case 'z':                                                                             // dump as codegen rather than AST
-                        codegenp = true;
-                        break;
-                        case 'Z':                                                                       // prettyprint during codegen (i.e. print unmangled names, etc.)
-                        prettycodegenp = true;
-                        break;
-                  case 'D':                                                                             // ignore -Dxxx
-                        break;
-                  case 'F':                                                                             // source file-name without suffix
+                  case 'D':                                                                             // ignore -Dxxx, forwarded by cpp, hidden
+                        break;
+                  case 'F':                                                                             // source file-name without suffix, hidden
                         filename = optarg;
                         break;
-                  case '?':
+                  case '?':                                                                             // unknown option
                         if ( optopt ) {                                                         // short option ?
-                                assertf( false, "Unknown option: -%c\n", (char)optopt );
+                                cout << "Unknown option -" << (char)optopt << endl;
                         } else {
-                                assertf( false, "Unknown option: %s\n", argv[optind - 1] );
-                        } // if
-                        #if defined(__GNUC__) && __GNUC__ >= 7
-                                __attribute__((fallthrough));
-                        #endif
+                                cout << "Unknown option " << argv[optind - 1] << endl;
+                        } // if
+                        goto Default;
+                  case ':':                                                                             // missing option
+                        if ( optopt ) {                                                         // short option ?
+                                cout << "Missing option for -" << (char)optopt << endl;
+                        } else {
+                                cout << "Missing option for " << argv[optind - 1] << endl;
+                        } // if
+                        goto Default;
+                  Default:
                   default:
-                        abort();
+                        usage( argv );                                                          // no return
                 } // switch
         } // while
@@ -587 +632 @@
         list< Declaration * > decls;
 
-        if ( noprotop ) {
+        if ( genproto ) {
                 filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), notPrelude );
         } else {
@@ -595 +640 @@
         // depending on commandline options, either generate code or dump the AST
         if ( codegenp ) {
-                CodeGen::generate( decls, out, ! noprotop, prettycodegenp );
+                CodeGen::generate( decls, out, ! genproto, prettycodegenp );
         } else {
                 printAll( decls, out );
-        }
+        } // if
         deleteAll( translationUnit );
 } // dump