Changeset dbae916 for src

Timestamp:

Mar 14, 2023, 4:21:05 PM (14 months ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

1afd9ccb, 360bfe41, 6e6989c

Parents:

5217569 (diff), c19ca4b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/TranslationUnit.hpp (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (17 diffs)
• Parser/ExpressionNode.cc (modified) (17 diffs)
• Parser/InitializerNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (6 diffs)
• Parser/StatementNode.cc (modified) (18 diffs)
• Parser/TypeData.cc (modified) (47 diffs)
• Parser/TypeData.h (modified) (1 diff)
• Parser/TypedefTable.cc (modified) (1 diff)
• Parser/parser.yy (modified) (26 diffs)
• Parser/parserutility.h (modified) (2 diffs)

src/AST/TranslationUnit.hpp

@@ -10 +10 @@
 // Created On       : Tue Jun 11 15:30:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Mar 11 11:19:00 2022
-// Update Count     : 1
+// Last Modified On : Thr Mar  9 16:41:00 2023
+// Update Count     : 2
 //
 
@@ -17 +17 @@
 
 #include <map>
-#include <vector>
+#include <list>
 
 #include "Fwd.hpp"
@@ -28 +28 @@
 
         ptr<Type> sizeType;
-        const FunctionDecl * dereference;
-        const StructDecl * dtorStruct;
-        const FunctionDecl * dtorDestroy;
+        const FunctionDecl * dereference = nullptr;
+        const StructDecl * dtorStruct = nullptr;
+        const FunctionDecl * dtorDestroy = nullptr;
 };
 

src/Parser/DeclarationNode.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 25 12:15:40 2023
-// Update Count     : 1404
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Mar 14 11:56:00 2023
+// Update Count     : 1406
 //
 
@@ -41 +41 @@
 
 // These must harmonize with the corresponding DeclarationNode enumerations.
-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" };
-const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" };
+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"
+};
+const char * DeclarationNode::builtinTypeNames[] = {
+        "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames"
+};
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
@@ -70 +80 @@
         delete variable.initializer;
 
-//      delete type;
+//      delete type;
         delete bitfieldWidth;
 
@@ -504 +514 @@
                         // src is the new item being added and has a single bit
                 } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ?
-                        appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
-                                                 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
+                        appendError( error, string( "conflicting " )
+                                + Type::StorageClassesNames[storageClasses.ffs()]
+                                + " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
                         src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
                 } // if
@@ -589 +600 @@
         } else {
                 switch ( dst->kind ) {
-                  case TypeData::Unknown:
+                case TypeData::Unknown:
                         src->qualifiers |= dst->qualifiers;
                         dst = src;
                         src = nullptr;
                         break;
-                  case TypeData::Basic:
+                case TypeData::Basic:
                         dst->qualifiers |= src->qualifiers;
                         if ( src->kind != TypeData::Unknown ) {
@@ -622 +633 @@
                         } // if
                         break;
-                  default:
+                default:
                         switch ( src->kind ) {
-                          case TypeData::Aggregate:
-                          case TypeData::Enum:
+                        case TypeData::Aggregate:
+                        case TypeData::Enum:
                                 dst->base = new TypeData( TypeData::AggregateInst );
                                 dst->base->aggInst.aggregate = src;
@@ -634 +645 @@
                                 src = nullptr;
                                 break;
-                          default:
+                        default:
                                 if ( dst->forall ) {
                                         dst->forall->appendList( src->forall );
@@ -706 +717 @@
 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
-                if ( variable.assertions ) {
-                        variable.assertions->appendList( assertions );
-                } else {
-                        variable.assertions = assertions;
-                } // if
-                return this;
+                if ( variable.assertions ) {
+                        variable.assertions->appendList( assertions );
+                } else {
+                        variable.assertions = assertions;
+                } // if
+                return this;
         } // if
 
         assert( type );
         switch ( type->kind ) {
-          case TypeData::Symbolic:
+        case TypeData::Symbolic:
                 if ( type->symbolic.assertions ) {
                         type->symbolic.assertions->appendList( assertions );
@@ -723 +734 @@
                 } // if
                 break;
-          default:
+        default:
                 assert( false );
         } // switch
@@ -822 +833 @@
                 if ( type ) {
                         switch ( type->kind ) {
-                          case TypeData::Aggregate:
-                          case TypeData::Enum:
+                        case TypeData::Aggregate:
+                        case TypeData::Enum:
                                 p->type->base = new TypeData( TypeData::AggregateInst );
                                 p->type->base->aggInst.aggregate = type;
@@ -832 +843 @@
                                 break;
 
-                          default:
+                        default:
                                 p->type->base = type;
                         } // switch
@@ -854 +865 @@
 
 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
-  if ( ! a ) return this;
+        if ( ! a ) return this;
         assert( a->type->kind == TypeData::Array );
         TypeData * lastArray = findLast( a->type );
         if ( type ) {
                 switch ( type->kind ) {
-                  case TypeData::Aggregate:
-                  case TypeData::Enum:
+                case TypeData::Aggregate:
+                case TypeData::Enum:
                         lastArray->base = new TypeData( TypeData::AggregateInst );
                         lastArray->base->aggInst.aggregate = type;
@@ -868 +879 @@
                         lastArray->base->qualifiers |= type->qualifiers;
                         break;
-                  default:
+                default:
                         lastArray->base = type;
                 } // switch
@@ -1204 +1215 @@
                 } // if
                 bool isDelete = initializer && initializer->get_isDelete();
-                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+                Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild(initializer), attributes )->set_extension( extension );
                 if ( isDelete ) {
                         DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
@@ -1213 +1224 @@
 
         if ( assert.condition ) {
-                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
+                return new StaticAssertDecl( maybeBuild( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
         }
 
@@ -1227 +1238 @@
         } // if
         assertf( name, "ObjectDecl must a have name\n" );
-        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
+        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild( bitfieldWidth ), nullptr, maybeBuild( initializer ) ))->set_asmName( asmName )->set_extension( extension );
 }
 
@@ -1234 +1245 @@
 
         switch ( type->kind ) {
-          case TypeData::Enum:
-          case TypeData::Aggregate: {
-                  ReferenceToType * ret = buildComAggInst( type, attributes, linkage );
-                  buildList( type->aggregate.actuals, ret->get_parameters() );
-                  return ret;
-          }
-          case TypeData::Symbolic: {
-                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes );
-                  buildList( type->symbolic.actuals, ret->get_parameters() );
-                  return ret;
-          }
-          default:
+        case TypeData::Enum:
+        case TypeData::Aggregate: {
+                ReferenceToType * ret = buildComAggInst( type, attributes, linkage );
+                buildList( type->aggregate.actuals, ret->get_parameters() );
+                return ret;
+        }
+        case TypeData::Symbolic: {
+                TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes );
+                buildList( type->symbolic.actuals, ret->get_parameters() );
+                return ret;
+        }
+        default:
                 Type * simpletypes = typebuild( type );
                 simpletypes->get_attributes() = attributes;             // copy because member is const

src/Parser/ExpressionNode.cc

@@ -9 +9 @@
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 13:17:07 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 11 14:49:00 2023
-// Update Count     : 1079
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Mar 14 12:00:00 2023
+// Update Count     : 1082
 //
 
@@ -71 +71 @@
         size_t end = str.length() - 1;
         if ( posn == end ) { type = 3; return; }                        // no length after 'l' => long
-        
+
         string::size_type next = posn + 1;                                      // advance to length
         if ( str[next] == '3' ) {                                                       // 32
@@ -122 +122 @@
                 if ( str[i] == '1' ) v |= 1;
                 i += 1;
-          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
                 v <<= 1;
         } // for
@@ -157 +157 @@
         } // if
 
-        string::size_type posn;
-
         // 'u' can appear before or after length suffix
         if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
@@ -166 +164 @@
         } else {
                 // At least one digit in integer constant, so safe to backup while looking for suffix.
-
-                posn = str.find_last_of( "pP" );                                // pointer value
-                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
-
-                posn = str.find_last_of( "zZ" );                                // size_t
-                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
-
-                posn = str.rfind( "hh" );                                               // signed char
-                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
-
-                posn = str.rfind( "HH" );                                               // signed char
-                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
-
-                posn = str.find_last_of( "hH" );                                // short
-                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
-
-                posn = str.find_last_of( "nN" );                                // int (natural number)
-                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
-
-                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
-
-                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
-          FINI: ;
+                string::size_type posn;
+                // pointer value
+                if ( posn = str.find_last_of( "pP" ); posn != string::npos ) {
+                        ltype = 5; str.erase( posn, 1 );
+                // size_t
+                } else if ( posn = str.find_last_of( "zZ" ); posn != string::npos ) {
+                        Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 );
+                // signed char
+                } else if ( posn = str.rfind( "hh" ); posn != string::npos ) {
+                        type = 1; str.erase( posn, 2 );
+                // signed char
+                } else if ( posn = str.rfind( "HH" ); posn != string::npos ) {
+                        type = 1; str.erase( posn, 2 );
+                // short
+                } else if ( posn = str.find_last_of( "hH" ); posn != string::npos ) {
+                        type = 0; str.erase( posn, 1 );
+                // int (natural number)
+                } else if ( posn = str.find_last_of( "nN" ); posn != string::npos ) {
+                        type = 2; str.erase( posn, 1 );
+                } else if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) {
+                        type = 4;
+                } else {
+                        lnthSuffix( str, type, ltype );
+                } // if
         } // if
 
@@ -196 +195 @@
         if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str );
 #endif // ! __SIZEOF_INT128__
-        
+
         if ( str[0] == '0' ) {                                                          // radix character ?
                 dec = false;
@@ -206 +205 @@
                                 unsigned int len = str.length();
                                 if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
-                          if ( len <= (2 + 16) ) goto FHEX1;            // hex digits < 2^64
-                                str2 = "0x" + str.substr( len - 16 );
-                                sscanf( (char *)str2.c_str(), "%llx", &v2 );
-                                str = str.substr( 0, len - 16 );
-                          FHEX1: ;
+                                // hex digits < 2^64
+                                if ( len > (2 + 16) ) {
+                                        str2 = "0x" + str.substr( len - 16 );
+                                        sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                        str = str.substr( 0, len - 16 );
+                                } // if
                                 sscanf( (char *)str.c_str(), "%llx", &v );
 #endif // __SIZEOF_INT128__
@@ -309 +309 @@
 //                      ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
                         ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) );
-                        ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
-                                                                                 new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
+                        ret = build_compoundLiteral(
+                                DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
                 } else {                                                                                // explicit length, (length_type)constant
                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
@@ -435 +436 @@
         Type * strtype;
         switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1
-          case 'u':
+        case 'u':
                 if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
                 // lookup type of associated typedef
                 strtype = new TypeInstType( Type::Qualifiers( ), "char16_t", false );
                 break;
-          case 'U':
+        case 'U':
                 strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false );
                 break;
-          case 'L':
+        case 'L':
                 strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false );
                 break;
-          Default:                                                                                      // char default string type
-          default:
+        Default:                                                                                        // char default string type
+        default:
                 strtype = new BasicType( Type::Qualifiers( ), BasicType::Char );
         } // switch
@@ -500 +501 @@
 
 Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
-        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
+        return make_field_name_fraction_constants( fieldName, maybeMoveBuild( fracts ) );
 } // build_field_name_fraction_constants
 
@@ -510 +511 @@
 
 QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
-        Declaration * newDecl = maybeBuild< Declaration >(decl_node);
+        Declaration * newDecl = maybeBuild(decl_node);
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
                 const Type * t = newDeclWithType->get_type();
@@ -548 +549 @@
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
+                return new CastExpr( maybeMoveBuild( expr_node ), false );
         } else {
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
+                return new CastExpr( maybeMoveBuild( expr_node ), targetType, false );
         } // if
 } // build_cast
 
 Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node ) {
-        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+        return new KeywordCastExpr( maybeMoveBuild( expr_node ), target );
 }
 
 Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
-        return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
+        return new VirtualCastExpr( maybeMoveBuild( expr_node ), maybeMoveBuildType( decl_node ) );
 } // build_virtual_cast
 
 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
-        return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
+        return new UntypedMemberExpr( member, maybeMoveBuild( expr_node ) );
 } // build_fieldSel
 
@@ -569 +570 @@
         UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
         deref->location = expr_node->location;
-        deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
+        deref->get_args().push_back( maybeMoveBuild( expr_node ) );
         UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
         return ret;
@@ -581 +582 @@
 
 Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
-        return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
+        return new LogicalExpr( notZeroExpr( maybeMoveBuild( expr_node1 ) ), notZeroExpr( maybeMoveBuild( expr_node2 ) ), kind );
 } // build_and_or
 
 Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
         list< Expression * > args;
-        args.push_back( maybeMoveBuild< Expression >(expr_node) );
+        args.push_back( maybeMoveBuild( expr_node ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_unary_val
 
-Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
-        list< Expression * > args;
-        args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code.
-        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
-} // build_unary_ptr
-
 Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         list< Expression * > args;
-        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
-        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
+        args.push_back( maybeMoveBuild( expr_node1 ) );
+        args.push_back( maybeMoveBuild( expr_node2 ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_binary_val
@@ -605 +600 @@
 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         list< Expression * > args;
-        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
-        args.push_back( maybeMoveBuild< Expression >(expr_node2) );
+        args.push_back( maybeMoveBuild( expr_node1 ) );
+        args.push_back( maybeMoveBuild( expr_node2 ) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_binary_ptr
 
 Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) {
-        return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) );
+        return new ConditionalExpr( notZeroExpr( maybeMoveBuild( expr_node1 ) ), maybeMoveBuild( expr_node2 ), maybeMoveBuild( expr_node3 ) );
 } // build_cond
 
@@ -623 +618 @@
         list< Expression * > args;
         buildMoveList( expr_node, args );
-        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
+        return new UntypedExpr( maybeMoveBuild( function ), args );
 } // build_func
 
 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
-        Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
+        Declaration * newDecl = maybeBuild( decl_node ); // compound literal type
         if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
-                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild( kids ) );
         // these types do not have associated type information
         } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
                 if ( newDeclStructDecl->has_body() ) {
-                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild( kids ) );
                 } else {
-                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild( kids ) );
                 } // if
         } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
                 if ( newDeclUnionDecl->has_body() ) {
-                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild( kids ) );
                 } else {
-                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild( kids ) );
                 } // if
         } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
                 if ( newDeclEnumDecl->has_body() ) {
-                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) );
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild( kids ) );
                 } else {
-                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild( kids ) );
                 } // if
         } else {
@@ -656 +651 @@
 // Local Variables: //
 // tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
 // End: //

src/Parser/InitializerNode.cc

@@ -102 +102 @@
                 if ( get_expression() ) {
                         assertf( get_expression()->expr, "The expression of initializer must have value" );
-                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                        return new SingleInit( maybeBuild( get_expression() ), maybeConstructed );
                 } // if
         } // if

src/Parser/ParseNode.h

@@ -137 +137 @@
         bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
 
-        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
+        Expression * build() const {
+                Expression * node = const_cast<ExpressionNode *>(this)->expr.release();
+                node->set_extension( this->get_extension() );
+                node->location = this->location;
+                return node;
+        }
 
         std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
@@ -143 +148 @@
         bool extension = false;
 }; // ExpressionNode
-
-template< typename T >
-struct maybeBuild_t< Expression, T > {
-        static inline Expression * doit( const T * orig ) {
-                if ( orig ) {
-                        Expression * p = orig->build();
-                        p->set_extension( orig->get_extension() );
-                        p->location = orig->location;
-                        return p;
-                } else {
-                        return nullptr;
-                } // if
-        }
-};
 
 // Must harmonize with OperName.
@@ -199 +190 @@
 Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
 Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
-Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
 Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
@@ -213 +203 @@
 struct DeclarationNode : public ParseNode {
         // 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 };
+        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, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
@@ -401 +394 @@
 
 struct ForCtrl {
-        ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
-                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
-        ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
-                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
+        ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) :
+                init( stmt ), condition( condition ), change( change ) {}
 
         StatementNode * init;
@@ -451 +442 @@
         while ( cur ) {
                 try {
-                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
+                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild( cur ) );
                         if ( result ) {
                                 result->location = cur->location;

src/Parser/StatementNode.cc

@@ -38 +38 @@
         DeclarationNode * agg = decl->extractAggregate();
         if ( agg ) {
-                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
@@ -51 +51 @@
                 agg = decl;
         } // if
-        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
+        stmt.reset( new DeclStmt( maybeMoveBuild( agg ) ) );
 } // StatementNode::StatementNode
 
@@ -73 +73 @@
 
 Statement * build_expr( ExpressionNode * ctl ) {
-        Expression * e = maybeMoveBuild< Expression >( ctl );
+        Expression * e = maybeMoveBuild( ctl );
 
         if ( e ) return new ExprStmt( e );
@@ -87 +87 @@
         if ( ctl->condition ) {
                 // compare the provided condition against 0
-                cond = notZeroExpr( maybeMoveBuild< Expression >(ctl->condition) );
+                cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
         } else {
                 for ( Statement * stmt : init ) {
@@ -134 +134 @@
         } // if
         // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
+        return new SwitchStmt( maybeMoveBuild( ctl ), aststmt );
 } // build_switch
 
 Statement * build_case( ExpressionNode * ctl ) {
-        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
+        return new CaseStmt( maybeMoveBuild( ctl ), {} ); // stmt starts empty and then added to
 } // build_case
 
@@ -168 +168 @@
 
         // do-while cannot have declarations in the contitional, so init is always empty
-        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true );
+        return new WhileDoStmt( notZeroExpr( maybeMoveBuild( ctl ) ), aststmt.front(), astelse.front(), {}, true );
 } // build_do_while
 
@@ -176 +176 @@
 
         Expression * astcond = nullptr;                                         // maybe empty
-        astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
+        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
 
         Expression * astincr = nullptr;                                         // maybe empty
-        astincr = maybeMoveBuild< Expression >(forctl->change);
+        astincr = maybeMoveBuild( forctl->change );
         delete forctl;
 
@@ -199 +199 @@
 Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
         Statement * ret = new BranchStmt( * identifier, kind );
-        delete identifier;                                                                      // allocated by lexer
+        delete identifier;                                                                      // allocated by lexer
         return ret;
 } // build_branch
 
 Statement * build_computedgoto( ExpressionNode * ctl ) {
-        return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+        return new BranchStmt( maybeMoveBuild( ctl ), BranchStmt::Goto );
 } // build_computedgoto
 
@@ -236 +236 @@
         list< CatchStmt * > aststmt;
         buildMoveList< CatchStmt, StatementNode >( catch_, aststmt );
-        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_));
-        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) );
+        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >( maybeMoveBuild( try_ ) );
+        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >( maybeMoveBuild( finally_ ) );
         return new TryStmt( tryBlock, aststmt, finallyBlock );
 } // build_try
@@ -245 +245 @@
         buildMoveList< Statement, StatementNode >( body, aststmt );
         assert( aststmt.size() == 1 );
-        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
+        return new CatchStmt( kind, maybeMoveBuild( decl ), maybeMoveBuild( cond ), aststmt.front() );
 } // build_catch
 
@@ -274 +274 @@
 
         WaitForStmt::Target target;
-        target.function = maybeBuild<Expression>( targetExpr );
+        target.function = maybeBuild( targetExpr );
 
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
@@ -284 +284 @@
         node->clauses.push_back( WaitForStmt::Clause{
                 target,
-                maybeMoveBuild<Statement >( stmt ),
-                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+                maybeMoveBuild( stmt ),
+                notZeroExpr( maybeMoveBuild( when ) )
         });
 
@@ -293 +293 @@
 WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
         WaitForStmt::Target target;
-        target.function = maybeBuild<Expression>( targetExpr );
+        target.function = maybeBuild( targetExpr );
 
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
@@ -303 +303 @@
         node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
                 std::move( target ),
-                maybeMoveBuild<Statement >( stmt ),
-                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+                maybeMoveBuild( stmt ),
+                notZeroExpr( maybeMoveBuild( when ) )
         });
 
@@ -314 +314 @@
 
         if( timeout ) {
-                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
-                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+                node->timeout.time      = maybeMoveBuild( timeout );
+                node->timeout.statement = maybeMoveBuild( stmt    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) );
         } else {
-                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
-                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+                node->orelse.statement  = maybeMoveBuild( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild( when ) );
         } // if
 
@@ -328 +328 @@
         auto node = new WaitForStmt();
 
-        node->timeout.time      = maybeMoveBuild<Expression>( timeout );
-        node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
-
-        node->orelse.statement  = maybeMoveBuild<Statement >( else_ );
-        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
+        node->timeout.time      = maybeMoveBuild( timeout );
+        node->timeout.statement = maybeMoveBuild( stmt    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) );
+
+        node->orelse.statement  = maybeMoveBuild( else_ );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild( else_when ) );
 
         return node;
@@ -341 +341 @@
         list< Expression * > e;
         buildMoveList( exprs, e );
-        Statement * s = maybeMoveBuild<Statement>( stmt );
+        Statement * s = maybeMoveBuild( stmt );
         return new DeclStmt( new WithStmt( e, s ) );
 } // build_with
@@ -384 +384 @@
         list< Expression * > expList;
         buildMoveList( exprs, expList );
-        Statement * body = maybeMoveBuild<Statement>( stmt );
+        Statement * body = maybeMoveBuild( stmt );
         return new MutexStmt( body, expList );
 } // build_mutex

src/Parser/TypeData.cc

@@ -33 +33 @@
 TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {
         switch ( kind ) {
-          case Unknown:
-          case Pointer:
-          case Reference:
-          case EnumConstant:
-          case GlobalScope:
-                // nothing else to initialize
-                break;
-          case Basic:
-                // basic = new Basic_t;
-                break;
-          case Array:
-                // array = new Array_t;
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Basic:
+                // No unique data to initialize.
+                break;
+        case Array:
                 array.dimension = nullptr;
                 array.isVarLen = false;
                 array.isStatic = false;
                 break;
-          case Function:
-                // function = new Function_t;
+        case Function:
                 function.params = nullptr;
                 function.idList = nullptr;
@@ -57 +53 @@
                 function.withExprs = nullptr;
                 break;
-                // Enum is an Aggregate, so both structures are initialized together.
-          case Enum:
-                // enumeration = new Enumeration_t;
+        case Enum:
                 enumeration.name = nullptr;
                 enumeration.constants = nullptr;
@@ -65 +59 @@
                 enumeration.anon = false;
                 break;
-          case Aggregate:
-                // aggregate = new Aggregate_t;
+        case Aggregate:
                 aggregate.kind = AggregateDecl::NoAggregate;
                 aggregate.name = nullptr;
@@ -77 +70 @@
                 aggregate.anon = false;
                 break;
-          case AggregateInst:
-                // aggInst = new AggInst_t;
+        case AggregateInst:
                 aggInst.aggregate = nullptr;
                 aggInst.params = nullptr;
                 aggInst.hoistType = false;
                 break;
-          case Symbolic:
-          case SymbolicInst:
-                // symbolic = new Symbolic_t;
+        case Symbolic:
+        case SymbolicInst:
                 symbolic.name = nullptr;
                 symbolic.params = nullptr;
@@ -91 +82 @@
                 symbolic.assertions = nullptr;
                 break;
-          case Tuple:
-                // tuple = new Tuple_t;
+        case Tuple:
                 tuple = nullptr;
                 break;
-          case Typeof:
-          case Basetypeof:
-                // typeexpr = new Typeof_t;
+        case Typeof:
+        case Basetypeof:
                 typeexpr = nullptr;
                 break;
-          case Vtable:
-                break;
-          case Builtin:
-                // builtin = new Builtin_t;
-                case Qualified:
+        case Builtin:
+        case Vtable:
+                // No unique data to initialize.
+                break;
+        case Qualified:
                 qualified.parent = nullptr;
                 qualified.child = nullptr;
@@ -117 +106 @@
 
         switch ( kind ) {
-          case Unknown:
-          case Pointer:
-          case Reference:
-          case EnumConstant:
-          case GlobalScope:
-                // nothing to destroy
-                break;
-          case Basic:
-                // delete basic;
-                break;
-          case Array:
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+                // No unique data to deconstruct.
+                break;
+        case Basic:
+                break;
+        case Array:
                 delete array.dimension;
-                // delete array;
-                break;
-          case Function:
+                break;
+        case Function:
                 delete function.params;
                 delete function.idList;
@@ -137 +124 @@
                 delete function.body;
                 delete function.withExprs;
-                // delete function;
-                break;
-          case Aggregate:
+                break;
+        case Aggregate:
                 delete aggregate.name;
                 delete aggregate.params;
                 delete aggregate.actuals;
                 delete aggregate.fields;
-                // delete aggregate;
-                break;
-          case AggregateInst:
+                break;
+        case AggregateInst:
                 delete aggInst.aggregate;
                 delete aggInst.params;
-                // delete aggInst;
-                break;
-          case Enum:
+                break;
+        case Enum:
                 delete enumeration.name;
                 delete enumeration.constants;
-                // delete enumeration;
-                break;
-          case Symbolic:
-          case SymbolicInst:
+                break;
+        case Symbolic:
+        case SymbolicInst:
                 delete symbolic.name;
                 delete symbolic.params;
                 delete symbolic.actuals;
                 delete symbolic.assertions;
-                // delete symbolic;
-                break;
-          case Tuple:
-                // delete tuple->members;
+                break;
+        case Tuple:
                 delete tuple;
                 break;
-          case Typeof:
-          case Basetypeof:
-                // delete typeexpr->expr;
+        case Typeof:
+        case Basetypeof:
                 delete typeexpr;
                 break;
-          case Vtable:
-                break;
-          case Builtin:
-                // delete builtin;
-                break;
-          case Qualified:
+        case Vtable:
+        case Builtin:
+                // No unique data to deconstruct.
+                break;
+        case Qualified:
                 delete qualified.parent;
                 delete qualified.child;
+                break;
         } // switch
 } // TypeData::~TypeData
@@ -192 +172 @@
 
         switch ( kind ) {
-          case Unknown:
-          case EnumConstant:
-          case Pointer:
-          case Reference:
-          case GlobalScope:
+        case Unknown:
+        case EnumConstant:
+        case Pointer:
+        case Reference:
+        case GlobalScope:
                 // nothing else to copy
                 break;
-          case Basic:
+        case Basic:
                 newtype->basictype = basictype;
                 newtype->complextype = complextype;
@@ -205 +185 @@
                 newtype->length = length;
                 break;
-          case Array:
+        case Array:
                 newtype->array.dimension = maybeClone( array.dimension );
                 newtype->array.isVarLen = array.isVarLen;
                 newtype->array.isStatic = array.isStatic;
                 break;
-          case Function:
+        case Function:
                 newtype->function.params = maybeClone( function.params );
                 newtype->function.idList = maybeClone( function.idList );
@@ -217 +197 @@
                 newtype->function.withExprs = maybeClone( function.withExprs );
                 break;
-          case Aggregate:
+        case Aggregate:
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
@@ -228 +208 @@
                 newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
                 break;
-          case AggregateInst:
+        case AggregateInst:
                 newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
                 newtype->aggInst.params = maybeClone( aggInst.params );
                 newtype->aggInst.hoistType = aggInst.hoistType;
                 break;
-          case Enum:
+        case Enum:
                 newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
                 newtype->enumeration.constants = maybeClone( enumeration.constants );
@@ -239 +219 @@
                 newtype->enumeration.anon = enumeration.anon;
                 break;
-          case Symbolic:
-          case SymbolicInst:
+        case Symbolic:
+        case SymbolicInst:
                 newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
                 newtype->symbolic.params = maybeClone( symbolic.params );
@@ -247 +227 @@
                 newtype->symbolic.isTypedef = symbolic.isTypedef;
                 break;
-          case Tuple:
+        case Tuple:
                 newtype->tuple = maybeClone( tuple );
                 break;
-          case Typeof:
-          case Basetypeof:
+        case Typeof:
+        case Basetypeof:
                 newtype->typeexpr = maybeClone( typeexpr );
                 break;
-          case Vtable:
-                break;
-          case Builtin:
+        case Vtable:
+                break;
+        case Builtin:
                 assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One );
                 newtype->builtintype = builtintype;
                 break;
-                case Qualified:
+        case Qualified:
                 newtype->qualified.parent = maybeClone( qualified.parent );
                 newtype->qualified.child = maybeClone( qualified.child );
@@ -280 +260 @@
 
         switch ( kind ) {
-          case Basic:
+        case Basic:
                 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
                 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
@@ -286 +266 @@
                 if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " ";
                 break;
-          case Pointer:
+        case Pointer:
                 os << "pointer ";
                 if ( base ) {
@@ -293 +273 @@
                 } // if
                 break;
-          case Reference:
+        case Reference:
                 os << "reference ";
                 if ( base ) {
@@ -300 +280 @@
                 } // if
                 break;
-          case Array:
+        case Array:
                 if ( array.isStatic ) {
                         os << "static ";
@@ -316 +296 @@
                 } // if
                 break;
-          case Function:
+        case Function:
                 os << "function" << endl;
                 if ( function.params ) {
@@ -344 +324 @@
                 } // if
                 break;
-          case Aggregate:
+        case Aggregate:
                 os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
@@ -362 +342 @@
                 } // if
                 break;
-          case AggregateInst:
+        case AggregateInst:
                 if ( aggInst.aggregate ) {
                         os << "instance of " ;
@@ -374 +354 @@
                 } // if
                 break;
-          case Enum:
+        case Enum:
                 os << "enumeration " << *enumeration.name << endl;;
                 if ( enumeration.constants ) {
@@ -388 +368 @@
                 } // if
                 break;
-          case EnumConstant:
+        case EnumConstant:
                 os << "enumeration constant ";
                 break;
-          case Symbolic:
+        case Symbolic:
                 if ( symbolic.isTypedef ) {
                         os << "typedef definition ";
@@ -411 +391 @@
                 } // if
                 break;
-          case SymbolicInst:
+        case SymbolicInst:
                 os << *symbolic.name;
                 if ( symbolic.actuals ) {
@@ -419 +399 @@
                 } // if
                 break;
-          case Tuple:
+        case Tuple:
                 os << "tuple ";
                 if ( tuple ) {
@@ -426 +406 @@
                 } // if
                 break;
-          case Basetypeof:
+        case Basetypeof:
                 os << "base-";
                 #if defined(__GNUC__) && __GNUC__ >= 7
@@ -432 +412 @@
                 #endif
                 // FALL THROUGH
-          case Typeof:
+        case Typeof:
                 os << "type-of expression ";
                 if ( typeexpr ) {
@@ -438 +418 @@
                 } // if
                 break;
-          case Vtable:
+        case Vtable:
                 os << "vtable";
                 break;
-          case Builtin:
+        case Builtin:
                 os << DeclarationNode::builtinTypeNames[builtintype];
                 break;
-          case GlobalScope:
-                break;
-          case Qualified:
+        case GlobalScope:
+                break;
+        case Qualified:
                 qualified.parent->print( os );
                 os << ".";
                 qualified.child->print( os );
                 break;
-          case Unknown:
+        case Unknown:
                 os << "entity of unknown type ";
                 break;
-          default:
+        default:
                 os << "internal error: TypeData::print " << kind << endl;
                 assert( false );
@@ -462 +442 @@
 const std::string * TypeData::leafName() const {
         switch ( kind ) {
-          case Unknown:
-          case Pointer:
-          case Reference:
-          case EnumConstant:
-          case GlobalScope:
-          case Array:
-          case Basic:
-          case Function:
-          case AggregateInst:
-          case Tuple:
-          case Typeof:
-          case Basetypeof:
-          case Builtin:
-          case Vtable:
+        case Unknown:
+        case Pointer:
+        case Reference:
+        case EnumConstant:
+        case GlobalScope:
+        case Array:
+        case Basic:
+        case Function:
+        case AggregateInst:
+        case Tuple:
+        case Typeof:
+        case Basetypeof:
+        case Builtin:
+        case Vtable:
                 assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
                 break;
-          case Aggregate:
+        case Aggregate:
                 return aggregate.name;
-          case Enum:
+        case Enum:
                 return enumeration.name;
-          case Symbolic:
-          case SymbolicInst:
+        case Symbolic:
+        case SymbolicInst:
                 return symbolic.name;
-          case Qualified:
+        case Qualified:
                 return qualified.child->leafName();
         } // switch
@@ -530 +510 @@
         assert( td );
         switch ( td->kind ) {
-          case TypeData::Unknown:
+        case TypeData::Unknown:
                 // fill in implicit int
                 return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
-          case TypeData::Basic:
+        case TypeData::Basic:
                 return buildBasicType( td );
-          case TypeData::Pointer:
+        case TypeData::Pointer:
                 return buildPointer( td );
-          case TypeData::Array:
+        case TypeData::Array:
                 return buildArray( td );
-          case TypeData::Reference:
+        case TypeData::Reference:
                 return buildReference( td );
-          case TypeData::Function:
+        case TypeData::Function:
                 return buildFunction( td );
-          case TypeData::AggregateInst:
+        case TypeData::AggregateInst:
                 return buildAggInst( td );
-          case TypeData::EnumConstant:
+        case TypeData::EnumConstant:
                 return new EnumInstType( buildQualifiers( td ), "" );
-          case TypeData::SymbolicInst:
+        case TypeData::SymbolicInst:
                 return buildSymbolicInst( td );
-          case TypeData::Tuple:
+        case TypeData::Tuple:
                 return buildTuple( td );
-          case TypeData::Typeof:
-          case TypeData::Basetypeof:
+        case TypeData::Typeof:
+        case TypeData::Basetypeof:
                 return buildTypeof( td );
-          case TypeData::Vtable:
+        case TypeData::Vtable:
                 return buildVtable( td );
-          case TypeData::Builtin:
+        case TypeData::Builtin:
                 switch ( td->builtintype ) {
-                  case DeclarationNode::Zero:
+                case DeclarationNode::Zero:
                         return new ZeroType( noQualifiers );
-                  case DeclarationNode::One:
+                case DeclarationNode::One:
                         return new OneType( noQualifiers );
-                  default:
+                default:
                         return new VarArgsType( buildQualifiers( td ) );
                 } // switch
-          case TypeData::GlobalScope:
+        case TypeData::GlobalScope:
                 return new GlobalScopeType();
-          case TypeData::Qualified:
+        case TypeData::Qualified:
                 return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
-          case TypeData::Symbolic:
-          case TypeData::Enum:
-          case TypeData::Aggregate:
+        case TypeData::Symbolic:
+        case TypeData::Enum:
+        case TypeData::Aggregate:
                 assert( false );
         } // switch
@@ -583 +563 @@
 
         switch ( td->kind ) {
-          case TypeData::Aggregate:
+        case TypeData::Aggregate:
                 if ( ! toplevel && td->aggregate.body ) {
                         ret = td->clone();
                 } // if
                 break;
-          case TypeData::Enum:
+        case TypeData::Enum:
                 if ( ! toplevel && td->enumeration.body ) {
                         ret = td->clone();
                 } // if
                 break;
-          case TypeData::AggregateInst:
+        case TypeData::AggregateInst:
                 if ( td->aggInst.aggregate ) {
                         ret = typeextractAggregate( td->aggInst.aggregate, false );
                 } // if
                 break;
-          default:
+        default:
                 if ( td->base ) {
                         ret = typeextractAggregate( td->base, false );
@@ -620 +600 @@
 
         switch ( td->basictype ) {
-          case DeclarationNode::Void:
+        case DeclarationNode::Void:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
@@ -630 +610 @@
                 break;
 
-          case DeclarationNode::Bool:
+        case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
@@ -641 +621 @@
                 break;
 
-          case DeclarationNode::Char:
+        case DeclarationNode::Char:
                 // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the
                 // character types. The implementation shall define char to have the same range, representation, and behavior as
@@ -654 +634 @@
                 break;
 
-          case DeclarationNode::Int:
+        case DeclarationNode::Int:
                 static BasicType::Kind inttype[2][4] = {
                         { BasicType::ShortSignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt },
@@ -660 +640 @@
                 };
 
-          Integral: ;
+        Integral: ;
                 if ( td->signedness == DeclarationNode::NoSignedness ) {
                         const_cast<TypeData *>(td)->signedness = DeclarationNode::Signed;
@@ -667 +647 @@
                 break;
 
-          case DeclarationNode::Int128:
+        case DeclarationNode::Int128:
                 ret = td->signedness == DeclarationNode::Unsigned ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
                 if ( td->length != DeclarationNode::NoLength ) {
@@ -674 +654 @@
                 break;
 
-          case DeclarationNode::Float:
-          case DeclarationNode::Double:
-          case DeclarationNode::LongDouble:                                     // not set until below
-          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:
+        case DeclarationNode::Float:
+        case DeclarationNode::Double:
+        case DeclarationNode::LongDouble:                                       // not set until below
+        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, },
@@ -691 +671 @@
                 };
 
-          FloatingPoint: ;
+        FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
@@ -715 +695 @@
                 break;
 
-          case DeclarationNode::NoBasicType:
+        case DeclarationNode::NoBasicType:
                 // No basic type in declaration => default double for Complex/Imaginary and int type for integral types
                 if ( td->complextype == DeclarationNode::Complex || td->complextype == DeclarationNode::Imaginary ) {
@@ -724 +704 @@
                 const_cast<TypeData *>(td)->basictype = DeclarationNode::Int;
                 goto Integral;
-          default:
-                assertf( false, "unknown basic type" );
+        default:
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
@@ -750 +730 @@
         ArrayType * at;
         if ( td->base ) {
-                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ),
+                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild( td->array.dimension ),
                                                         td->array.isVarLen, td->array.isStatic );
         } else {
                 at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
-                                                        maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic );
+                                                        maybeBuild( td->array.dimension ), td->array.isVarLen, td->array.isStatic );
         } // if
         buildForall( td->forall, at->get_forall() );
@@ -777 +757 @@
         AggregateDecl * at;
         switch ( td->aggregate.kind ) {
-          case AggregateDecl::Struct:
-          case AggregateDecl::Coroutine:
-          case AggregateDecl::Exception:
-          case AggregateDecl::Generator:
-          case AggregateDecl::Monitor:
-          case AggregateDecl::Thread:
+        case AggregateDecl::Struct:
+        case AggregateDecl::Coroutine:
+        case AggregateDecl::Exception:
+        case AggregateDecl::Generator:
+        case AggregateDecl::Monitor:
+        case AggregateDecl::Thread:
                 at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
-          case AggregateDecl::Union:
+        case AggregateDecl::Union:
                 at = new UnionDecl( *td->aggregate.name, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
-          case AggregateDecl::Trait:
+        case AggregateDecl::Trait:
                 at = new TraitDecl( *td->aggregate.name, attributes, linkage );
                 buildList( td->aggregate.params, at->get_parameters() );
                 break;
-          default:
+        default:
                 assert( false );
         } // switch
@@ -807 +787 @@
 ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         switch ( type->kind ) {
-          case TypeData::Enum: {
-                  if ( type->enumeration.body ) {
-                          EnumDecl * typedecl = buildEnum( type, attributes, linkage );
-                          return new EnumInstType( buildQualifiers( type ), typedecl );
-                  } else {
-                          return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
-                  } // if
-          }
-          case TypeData::Aggregate: {
-                  ReferenceToType * ret;
-                  if ( type->aggregate.body ) {
-                          AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
-                          switch ( type->aggregate.kind ) {
-                                case AggregateDecl::Struct:
-                                case AggregateDecl::Coroutine:
-                                case AggregateDecl::Monitor:
-                                case AggregateDecl::Thread:
-                                  ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
-                                  break;
-                                case AggregateDecl::Union:
-                                  ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
-                                  break;
-                                case AggregateDecl::Trait:
-                                  assert( false );
-                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
-                                  break;
-                                default:
-                                  assert( false );
-                          } // switch
-                  } else {
-                          switch ( type->aggregate.kind ) {
-                                case AggregateDecl::Struct:
-                                case AggregateDecl::Coroutine:
-                                case AggregateDecl::Monitor:
-                                case AggregateDecl::Thread:
-                                  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
-                                  break;
-                                case AggregateDecl::Union:
-                                  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
-                                  break;
-                                case AggregateDecl::Trait:
-                                  ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
-                                  break;
-                                default:
-                                  assert( false );
-                          } // switch
-                  } // if
-                  return ret;
-          }
-          default:
+        case TypeData::Enum:
+                if ( type->enumeration.body ) {
+                        EnumDecl * typedecl = buildEnum( type, attributes, linkage );
+                        return new EnumInstType( buildQualifiers( type ), typedecl );
+                } else {
+                        return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+                } // if
+        case TypeData::Aggregate:
+                if ( type->aggregate.body ) {
+                        AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
+                        switch ( type->aggregate.kind ) {
+                        case AggregateDecl::Struct:
+                        case AggregateDecl::Coroutine:
+                        case AggregateDecl::Monitor:
+                        case AggregateDecl::Thread:
+                                return new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
+                        case AggregateDecl::Union:
+                                return new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
+                        case AggregateDecl::Trait:
+                                assert( false );
+                                //return new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
+                                break;
+                        default:
+                                assert( false );
+                        } // switch
+                } else {
+                        switch ( type->aggregate.kind ) {
+                        case AggregateDecl::Struct:
+                        case AggregateDecl::Coroutine:
+                        case AggregateDecl::Monitor:
+                        case AggregateDecl::Thread:
+                                return new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                        case AggregateDecl::Union:
+                                return new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                        case AggregateDecl::Trait:
+                                return new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                        default:
+                                assert( false );
+                        } // switch
+                } // if
+                return nullptr;
+        default:
                 assert( false );
         } // switch
@@ -869 +841 @@
         TypeData * type = td->aggInst.aggregate;
         switch ( type->kind ) {
-          case TypeData::Enum: {
-                  return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
-          }
-          case TypeData::Aggregate: {
-                  switch ( type->aggregate.kind ) {
-                        case AggregateDecl::Struct:
-                        case AggregateDecl::Coroutine:
-                        case AggregateDecl::Monitor:
-                        case AggregateDecl::Thread:
-                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
-                          break;
-                        case AggregateDecl::Union:
-                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
-                          break;
-                        case AggregateDecl::Trait:
-                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
-                          break;
-                        default:
-                          assert( false );
-                  } // switch
-          }
-          break;
-          default:
+        case TypeData::Enum:
+                return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+        case TypeData::Aggregate:
+                switch ( type->aggregate.kind ) {
+                case AggregateDecl::Struct:
+                case AggregateDecl::Coroutine:
+                case AggregateDecl::Monitor:
+                case AggregateDecl::Thread:
+                        ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                        break;
+                case AggregateDecl::Union:
+                        ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                        break;
+                case AggregateDecl::Trait:
+                        ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                        break;
+                default:
+                        assert( false );
+                } // switch
+                break;
+        default:
                 assert( false );
         } // switch
@@ -931 +901 @@
                 } else if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
-                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
+                        member->set_init( new SingleInit( maybeMoveBuild( cur->consume_enumeratorValue() ) ) );
                 } else if ( !cur->initializer ) {
                         if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isInteger())) {
@@ -985 +955 @@
 
                 FunctionDecl * decl;
-                Statement * stmt = maybeBuild<Statement>( td->function.body );
+                Statement * stmt = maybeBuild( td->function.body );
                 CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
                 decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
@@ -1010 +980 @@
         if ( td->base ) {
                 switch ( td->base->kind ) {
-                  case TypeData::Tuple:
+                case TypeData::Tuple:
                         buildList( td->base->tuple, ft->returnVals );
                         break;
-                  default:
+                default:
                         ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
                 } // switch

src/Parser/TypeData.h

@@ -130 +130 @@
 TypeofType * buildTypeof( const TypeData * );
 VTableType * buildVtable( const TypeData * );
-Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName,
-                                                 Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+Declaration * buildDecl(
+        const TypeData *, const std::string &, Type::StorageClasses, Expression *,
+        Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName,
+        Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
 Declaration * addEnumBase( Declaration *, const TypeData * );

src/Parser/TypedefTable.cc

@@ -31 +31 @@
         static const char *kindName( int kind ) {
                 switch ( kind ) {
-                  case IDENTIFIER: return "identifier";
-                  case TYPEDIMname: return "typedim";
-                  case TYPEDEFname: return "typedef";
-                  case TYPEGENname: return "typegen";
-                  default:
+                case IDENTIFIER: return "identifier";
+                case TYPEDIMname: return "typedim";
+                case TYPEDEFname: return "typedef";
+                case TYPEGENname: return "typegen";
+                default:
                         cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
                         abort();

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 25 13:23:16 2023
-// Update Count     : 5989
+// Last Modified On : Tue Mar 14 09:37:58 2023
+// Update Count     : 5990
 //
 
@@ -206 +206 @@
 #define MISSING_HIGH "Missing high value for down-to range so index is uninitialized."
 
+static ForCtrl * makeForCtrl(
+                DeclarationNode * init,
+                enum OperKinds compop,
+                ExpressionNode * comp,
+                ExpressionNode * inc ) {
+        // Wrap both comp/inc if they are non-null.
+        if ( comp ) comp = new ExpressionNode( build_binary_val(
+                compop,
+                new ExpressionNode( build_varref( new string( *init->name ) ) ),
+                comp ) );
+        if ( inc ) inc = new ExpressionNode( build_binary_val(
+                // choose += or -= for upto/downto
+                compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn,
+                new ExpressionNode( build_varref( new string( *init->name ) ) ),
+                inc ) );
+        // The StatementNode call frees init->name, it must happen later.
+        return new ForCtrl( new StatementNode( init ), comp, inc );
+}
+
 ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
@@ -213 +232 @@
                 SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." );
         } // if
-        return new ForCtrl( index->addInitializer( new InitializerNode( start ) ),
-                // NULL comp/inc => leave blank
-                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index->name ) ) ), comp ) ) : nullptr,
-                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->name ) ) ), inc ) ) : nullptr );
+        DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) );
+        return makeForCtrl( initDecl, compop, comp, inc );
 } // forCtrl
 
@@ -223 +239 @@
         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 ) ) );
+                type = new ExpressionNode( new CastExpr( maybeMoveBuild( type ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
         } // if
-//      type = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__for_control_index_constraints__" ) ) ), type ) );
-        return new ForCtrl(
-                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
-                // NULL comp/inc => leave blank
-                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : nullptr,
-                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 ) ) : nullptr );
+        DeclarationNode * initDecl = distAttr(
+                DeclarationNode::newTypeof( type, true ),
+                DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) )
+        );
+        return makeForCtrl( initDecl, compop, comp, inc );
 } // forCtrl
 
@@ -649 +663 @@
                 { $$ = $2; }
         | '(' compound_statement ')'                                            // GCC, lambda expression
-                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
+                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild( $2 ) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
                 { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
@@ -657 +671 @@
                 {
                         // add the missing control expression to the GenericExpr and return it
-                        $5->control = maybeMoveBuild<Expression>( $3 );
+                        $5->control = maybeMoveBuild( $3 );
                         $$ = new ExpressionNode( $5 );
                 }
@@ -693 +707 @@
                 {
                         // create a GenericExpr wrapper with one association pair
-                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>( $3 ) } } );
+                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild( $3 ) } } );
                 }
         | DEFAULT ':' assignment_expression
-                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>( $3 ) } } ); }
+                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild( $3 ) } } ); }
         ;
 
@@ -751 +765 @@
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ICR
-                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
-                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
@@ -793 +807 @@
         field_name
         | FLOATING_DECIMALconstant field
-                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
         | field_name '.' field
-                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild( $3 ) ) ); }
         | field_name '.' '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | field_name ARROW field
-                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild( $3 ) ) ); }
         | field_name ARROW '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
@@ -843 +857 @@
                         switch ( $1 ) {
                           case OperKinds::AddressOf:
-                                $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) );
+                                $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild( $2 ) ) );
                                 break;
                           case OperKinds::PointTo:
@@ -849 +863 @@
                                 break;
                           case OperKinds::And:
-                                $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) ) );
+                                $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild( $2 ) ) ) );
                                 break;
                           default:
@@ -858 +872 @@
                 { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
         | ICR unary_expression
-                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::Incr, $2 ) ); }
         | DECR unary_expression
-                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
-                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
-                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
@@ -901 +915 @@
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
-                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
-                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
@@ -1092 +1106 @@
         assignment_expression
         | comma_expression ',' assignment_expression
-                { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         ;
 
@@ -1230 +1244 @@
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
-                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
         ;
@@ -1298 +1312 @@
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
         | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
-                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+                { $$ = new StatementNode( build_for( new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( $4 ) ) ); }
         | FOR '(' ')' statement ELSE statement                          // CFA
                 {
-                        $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
+                        $$ = new StatementNode( build_for( new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
@@ -1335 +1349 @@
 for_control_expression:
         ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+                { $$ = new ForCtrl( nullptr, $2, $4 ); }
         | comma_expression ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( $1, $3, $5 ); }
+                {
+                        StatementNode * init = $1 ? new StatementNode( new ExprStmt( maybeMoveBuild( $1 ) ) ) : nullptr;
+                        $$ = new ForCtrl( init, $3, $5 );
+                }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
-                { $$ = new ForCtrl( $1, $2, $4 ); }
+                { $$ = new ForCtrl( new StatementNode( $1 ), $2, $4 ); }
 
         | '@' ';' comma_expression                                                      // CFA, empty loop-index
-                { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, nullptr ); }
+                { $$ = new ForCtrl( nullptr, $3, nullptr ); }
         | '@' ';' comma_expression ';' comma_expression         // CFA, empty loop-index
-                { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, $5 ); }
+                { $$ = new ForCtrl( nullptr, $3, $5 ); }
 
         | comma_expression                                                                      // CFA, anonymous loop-index
@@ -1732 +1749 @@
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
-                { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
-                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild<Expression>( $6 ) ) ); }
+                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild( $6 ) ) ); }
         ;
 
@@ -2038 +2055 @@
         basic_type_specifier
         | sue_type_specifier
-                {
-                        // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
-                        //   printf( "\tattr %s\n", attr->name.c_str() );
-                        // } // for
-                }
         | type_type_specifier
         ;
@@ -2383 +2394 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
-                        // printf( "aggregate_type1 %s\n", $3.str->c_str() );
-                        // if ( $2 )
-                        //      for ( Attribute * attr: reverseIterate( $2->attributes ) ) {
-                        //              printf( "copySpecifiers12 %s\n", attr->name.c_str() );
-                        //      } // for
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
-                        // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
-                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
-                        //      printf( "aggregate_type3 %s\n", attr->name.c_str() );
-                        // } // for
                 }
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
@@ -2401 +2403 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
-                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2412 +2413 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
-                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2439 +2439 @@
                         // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
                         // delete newFromTypeGen.
-                        $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
-                        $3->type->symbolic.name = nullptr;
-                        $3->type->symbolic.actuals = nullptr;
-                        delete $3;
+                        if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) {
+                                $$ = $3->addQualifiers( $2 );
+                        } else {
+                                $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
+                                $3->type->symbolic.name = nullptr;                      // copied to $$
+                                $3->type->symbolic.actuals = nullptr;
+                                delete $3;
+                        }
                 }
         ;
@@ -2779 +2783 @@
 type_no_function:                                                                               // sizeof, alignof, cast (constructor)
         cfa_abstract_declarator_tuple                                           // CFA
-        | type_specifier
+        | type_specifier                                                                        // cannot be type_specifier_nobody, e.g., (struct S {}){} is a thing
         | type_specifier abstract_declarator
                 { $$ = $2->addType( $1 ); }
@@ -2843 +2847 @@
                 { $$ = $3; }
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
-                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $3 ), maybeMoveBuild<Expression>( $5 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
         | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
@@ -3231 +3235 @@
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
-                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         ;
 

src/Parser/parserutility.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Feb 16 12:34:00 2023
-// Update Count     : 5
+// Last Modified On : Thr Mar  9 12:16:00 2023
+// Update Count     : 6
 //
 
@@ -20 +20 @@
 Expression *notZeroExpr( Expression *orig );
 
-template< typename T, typename U >
-struct maybeBuild_t {
-        static T * doit( const U *orig ) {
-                if ( orig ) {
-                        return orig->build();
-                } else {
-                        return 0;
-                }
-        }
-};
-
-template< typename T, typename U >
-static inline T * maybeBuild( const U *orig ) {
-        return maybeBuild_t<T,U>::doit(orig);
+template< typename T >
+static inline auto maybeBuild( const T *orig ) -> decltype(orig->build()) {
+        return (orig) ? orig->build() : nullptr;
 }
 
-template< typename T, typename U >
-static inline T * maybeMoveBuild( const U *orig ) {
-        T* ret = maybeBuild<T>(orig);
+template< typename T >
+static inline auto maybeMoveBuild( const T *orig ) -> decltype(orig->build()) {
+        auto ret = maybeBuild<T>(orig);
         delete orig;
         return ret;