Changeset 24d6572 for src/Parser

src/Parser/DeclarationNode.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  8 17:07:00 2022
 // Update Count     : 1185
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Apr 20 11:46:00 2023
+// Update Count     : 1393
 //
+#include "DeclarationNode.h"
 #include <cassert>                 // for assert, assertf, strict_dynamic_cast
 …
 #include <string>                  // for string, operator+, allocator, char...
+#include "AST/Attribute.hpp"       // for Attribute
+#include "AST/Copy.hpp"            // for shallowCopy
+#include "AST/Decl.hpp"            // for Decl
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Print.hpp"           // for print
+#include "AST/Stmt.hpp"            // for AsmStmt, DirectiveStmt
+#include "AST/StorageClasses.hpp"  // for Storage::Class
+#include "AST/Type.hpp"            // for Type
+#include "Common/CodeLocation.h"   // for CodeLocation
+#include "Common/Iterate.hpp"      // for reverseIterate
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild, CodeLocation
+#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
+#include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
+#include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineMemberDecl, Declaration
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr
+#include "SynTree/Statement.h"     // for AsmStmt
+#include "SynTree/Type.h"          // for Type, Type::StorageClasses, Type::...
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/ExpressionNode.h" // for ExpressionNode
+#include "Parser/InitializerNode.h"// for InitializerNode
+#include "Parser/StatementNode.h"  // for StatementNode
 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
 #include "TypedefTable.h"          // for TypedefTable
 …
 // 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" );
 extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
+extern ast::Linkage::Spec linkage;                                              // defined in parser.yy
 DeclarationNode::DeclarationNode() :
 …
 //      variable.name = nullptr;
         variable.tyClass = TypeDecl::NUMBER_OF_KINDS;
+        variable.tyClass = ast::TypeDecl::NUMBER_OF_KINDS;
         variable.assertions = nullptr;
         variable.initializer = nullptr;
-//      attr.name = nullptr;
-        attr.expr = nullptr;
-        attr.type = nullptr;
         assert.condition = nullptr;
         assert.message = nullptr;
 …
 DeclarationNode::~DeclarationNode() {
-//      delete attr.name;
-        delete attr.expr;
-        delete attr.type;
 //      delete variable.name;
         delete variable.assertions;
         delete variable.initializer;
 //      delete type;
+//      delete type;
         delete bitfieldWidth;
 …
         newnode->hasEllipsis = hasEllipsis;
         newnode->linkage = linkage;
         newnode->asmName = maybeClone( asmName );
         cloneAll( attributes, newnode->attributes );
+        newnode->asmName = maybeCopy( asmName );
+        newnode->attributes = attributes;
         newnode->initializer = maybeClone( initializer );
         newnode->extension = extension;
 …
         newnode->variable.initializer = maybeClone( variable.initializer );
-//      newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
-        newnode->attr.expr = maybeClone( attr.expr );
-        newnode->attr.type = maybeClone( attr.type );
         newnode->assert.condition = maybeClone( assert.condition );
         newnode->assert.message = maybeClone( assert.message );
+        newnode->assert.message = maybeCopy( assert.message );
         return newnode;
 } // DeclarationNode::clone
 …
         } // if
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::name( linkage ) << " ";
         } // if
         storageClasses.print( os );
         funcSpecs.print( os );
+        if ( linkage != ast::Linkage::Cforall ) {
+                os << ast::Linkage::name( linkage ) << " ";
+        } // if
+        ast::print( os, storageClasses );
+        ast::print( os, funcSpecs );
         if ( type ) {
 …
         } // if
+        for ( Attribute * attr: reverseIterate( attributes ) ) {
+                os << string( indent + 2, ' ' ) << "attr " << attr->name.c_str();
+        } // for
+        if ( ! attributes.empty() ) {
+                os << string( indent + 2, ' ' ) << "with attributes " << endl;
+                for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( attributes ) ) {
+                        os << string( indent + 4, ' ' ) << attr->name.c_str() << endl;
+                } // for
+        } // if
         os << endl;
 …
+}
 DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
+DeclarationNode * DeclarationNode::newStorageClass( ast::Storage::Classes sc ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->storageClasses = sc;
 …
 } // DeclarationNode::newStorageClass
 DeclarationNode * DeclarationNode::newFuncSpecifier( Type::FuncSpecifiers fs ) {
+DeclarationNode * DeclarationNode::newFuncSpecifier( ast::Function::Specs fs ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->funcSpecs = fs;
 …
 } // DeclarationNode::newFuncSpecifier
 DeclarationNode * DeclarationNode::newTypeQualifier( Type::Qualifiers tq ) {
+DeclarationNode * DeclarationNode::newTypeQualifier( ast::CV::Qualifiers tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
 …
+}
 DeclarationNode * DeclarationNode::newAggregate( AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+DeclarationNode * DeclarationNode::newAggregate( ast::AggregateDecl::Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
+        newnode->type->aggregate.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->aggregate.anon = name == nullptr;
+        newnode->type->aggregate.name = newnode->type->aggregate.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
 …
         newnode->type->aggregate.tagged = false;
         newnode->type->aggregate.parent = nullptr;
-        newnode->type->aggregate.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
+        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->enumeration.anon = name == nullptr;
+        newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
-        newnode->type->enumeration.anon = name == nullptr;
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
         if ( base && base->type)  {
+        if ( base && base->type )  {
                 newnode->type->base = base->type;
         } // if
 …
         return newnode;
 } // DeclarationNode::newEnum
 DeclarationNode * DeclarationNode::newName( const string * name ) {
 …
 } // DeclarationNode::newFromTypeGen
 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
+DeclarationNode * DeclarationNode::newTypeParam( ast::TypeDecl::Kind tc, const string * name ) {
         DeclarationNode * newnode = newName( name );
         newnode->type = nullptr;
 …
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.name = name;
         newnode->type->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggregate.kind = ast::AggregateDecl::Trait;
         newnode->type->aggregate.params = params;
         newnode->type->aggregate.fields = asserts;
 …
         newnode->type = new TypeData( TypeData::AggregateInst );
         newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
         newnode->type->aggInst.aggregate->aggregate.kind = AggregateDecl::Trait;
+        newnode->type->aggInst.aggregate->aggregate.kind = ast::AggregateDecl::Trait;
         newnode->type->aggInst.aggregate->aggregate.name = name;
         newnode->type->aggInst.params = params;
 …
         newnode->type->array.dimension = size;
         newnode->type->array.isStatic = isStatic;
         if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
+        if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ast::ConstantExpr *>() ) {
                 newnode->type->array.isVarLen = false;
         } else {
 …
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = nullptr;
         std::list< Expression * > exprs;
+        std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
+        newnode->attributes.push_back( new Attribute( *name, exprs ) );
+        newnode->attributes.push_back(
+                new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
 …
+}
 DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, Expression * message ) {
+DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, ast::Expr * message ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->assert.condition = condition;
 …
+}
+void appendError( string & dst, const string & src ) {
+static void appendError( string & dst, const string & src ) {
         if ( src.empty() ) return;
         if ( dst.empty() ) { dst = src; return; }
 …
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
+        const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        if ( (qsrc & qdst).any() ) {                                            // duplicates ?
+                for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
+                        if ( qsrc[i] && qdst[i] ) {
+                                appendError( error, string( "duplicate " ) + Type::QualifiersNames[i] );
+                        } // if
+                } // for
+        const ast::CV::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        const ast::CV::Qualifiers duplicates = qsrc & qdst;
+        if ( duplicates.any() ) {
+                std::stringstream str;
+                str << "duplicate ";
+                ast::print( str, duplicates );
+                str << "qualifier(s)";
+                appendError( error, str.str() );
         } // for
 } // DeclarationNode::checkQualifiers
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
+        if ( (funcSpecs & src->funcSpecs).any() ) {                     // duplicates ?
+                for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
+                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
+                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiersNames[i] );
+                        } // if
+                } // for
+        } // if
+        if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
+                if ( (storageClasses & src->storageClasses ).any() ) { // duplicates ?
+                        for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
+                                if ( storageClasses[i] && src->storageClasses[i] ) {
+                                        appendError( error, string( "duplicate " ) + Type::StorageClassesNames[i] );
+                                } // if
+                        } // for
+                        // 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()] );
+                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
+                } // if
+        ast::Function::Specs fsDups = funcSpecs & src->funcSpecs;
+        if ( fsDups.any() ) {
+                std::stringstream str;
+                str << "duplicate ";
+                ast::print( str, fsDups );
+                str << "function specifier(s)";
+                appendError( error, str.str() );
+        } // if
+        // Skip if everything is unset.
+        if ( storageClasses.any() && src->storageClasses.any() ) {
+                ast::Storage::Classes dups = storageClasses & src->storageClasses;
+                // Check for duplicates.
+                if ( dups.any() ) {
+                        std::stringstream str;
+                        str << "duplicate ";
+                        ast::print( str, dups );
+                        str << "storage class(es)";
+                        appendError( error, str.str() );
+                // Check for conflicts.
+                } else if ( !src->storageClasses.is_threadlocal_any() ) {
+                        std::stringstream str;
+                        str << "conflicting ";
+                        ast::print( str, ast::Storage::Classes( 1 << storageClasses.ffs() ) );
+                        str << "& ";
+                        ast::print( str, ast::Storage::Classes( 1 << src->storageClasses.ffs() ) );
+                        str << "storage classes";
+                        appendError( error, str.str() );
+                        // FIX to preserve invariant of one basic storage specifier
+                        src->storageClasses.reset();
+                }
         } // if
 …
         storageClasses |= q->storageClasses;
+        for ( Attribute * attr: reverseIterate( q->attributes ) ) {
+                attributes.push_front( attr->clone() );
+        } // for
+        std::vector<ast::ptr<ast::Attribute>> tmp;
+        tmp.reserve( q->attributes.size() );
+        for ( auto const & attr : q->attributes ) {
+                tmp.emplace_back( ast::shallowCopy( attr.get() ) );
+        }
+        spliceBegin( attributes, tmp );
         return this;
 } // DeclarationNode::copySpecifiers
 …
         checkQualifiers( type, q->type );
         if ( (builtin == Zero || builtin == One) && q->type->qualifiers.val != 0 && error.length() == 0 ) {
                 SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, Type::QualifiersNames[ilog2( q->type->qualifiers.val )], builtinTypeNames[builtin] );
+        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.any() && error.length() == 0 ) {
+                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, builtinTypeNames[builtin] );
         } // if
         addQualifiersToType( q->type, type );
 …
         } 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 ) {
 …
                         } // 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;
 …
                                 src = nullptr;
                                 break;
                           default:
+                        default:
                                 if ( dst->forall ) {
                                         dst->forall->appendList( src->forall );
 …
 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.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
+                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 );
 …
                 } // if
                 break;
           default:
+        default:
                 assert( false );
         } // switch
 …
 DeclarationNode * DeclarationNode::copyAttribute( DeclarationNode * a ) {
         if ( a ) {
+                for ( Attribute *attr: reverseIterate( a->attributes ) ) {
+                        attributes.push_front( attr );
+                } // for
+                spliceBegin( attributes, a->attributes );
                 a->attributes.clear();
         } // if
 …
                 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;
 …
                                 break;
                           default:
+                        default:
                                 p->type->base = type;
                         } // switch
 …
 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;
 …
                         lastArray->base->qualifiers |= type->qualifiers;
                         break;
                   default:
+                default:
                         lastArray->base = type;
                 } // switch
 …
 DeclarationNode * DeclarationNode::addTypeInitializer( DeclarationNode * init ) {
         assertf( variable.tyClass != TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
+        assertf( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS, "Called addTypeInitializer on something that isn't a type variable." );
         variable.initializer = init;
         return this;
 …
+}
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList ) {
+// If a typedef wraps an anonymous declaration, name the inner declaration
+// so it has a consistent name across translation units.
+static void nameTypedefedDecl(
+                DeclarationNode * innerDecl,
+                const DeclarationNode * outerDecl ) {
+        TypeData * outer = outerDecl->type;
+        assert( outer );
+        // First make sure this is a typedef:
+        if ( outer->kind != TypeData::Symbolic || !outer->symbolic.isTypedef ) {
+                return;
+        }
+        TypeData * inner = innerDecl->type;
+        assert( inner );
+        // Always clear any CVs associated with the aggregate:
+        inner->qualifiers.reset();
+        // Handle anonymous aggregates: typedef struct { int i; } foo
+        if ( inner->kind == TypeData::Aggregate && inner->aggregate.anon ) {
+                delete inner->aggregate.name;
+                inner->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
+                inner->aggregate.anon = false;
+                assert( outer->base );
+                delete outer->base->aggInst.aggregate->aggregate.name;
+                outer->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *outerDecl->name );
+                outer->base->aggInst.aggregate->aggregate.anon = false;
+                outer->base->aggInst.aggregate->qualifiers.reset();
+        // Handle anonymous enumeration: typedef enum { A, B, C } foo
+        } else if ( inner->kind == TypeData::Enum && inner->enumeration.anon ) {
+                delete inner->enumeration.name;
+                inner->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
+                inner->enumeration.anon = false;
+                assert( outer->base );
+                delete outer->base->aggInst.aggregate->enumeration.name;
+                outer->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *outerDecl->name );
+                outer->base->aggInst.aggregate->enumeration.anon = false;
+                // No qualifiers.reset() here.
+        }
+}
+// This code handles a special issue with the attribute transparent_union.
+//
+//    typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union ))
+//
+// Here the attribute aligned goes with the typedef_name, so variables declared of this type are
+// aligned.  However, the attribute transparent_union must be moved from the typedef_name to
+// alias union U.  Currently, this is the only know attribute that must be moved from typedef to
+// alias.
+static void moveUnionAttribute( ast::Decl * decl, ast::UnionDecl * unionDecl ) {
+        if ( auto typedefDecl = dynamic_cast<ast::TypedefDecl *>( decl ) ) {
+                // Is the typedef alias a union aggregate?
+                if ( nullptr == unionDecl ) return;
+                // If typedef is an alias for a union, then its alias type was hoisted above and remembered.
+                if ( auto unionInstType = typedefDecl->base.as<ast::UnionInstType>() ) {
+                        auto instType = ast::mutate( unionInstType );
+                        // Remove all transparent_union attributes from typedef and move to alias union.
+                        for ( auto attr = instType->attributes.begin() ; attr != instType->attributes.end() ; ) {
+                                assert( *attr );
+                                if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) {
+                                        unionDecl->attributes.emplace_back( attr->release() );
+                                        attr = instType->attributes.erase( attr );
+                                } else {
+                                        attr++;
+                                }
+                        }
+                        typedefDecl->base = instType;
+                }
+        }
+}
+// Get the non-anonymous name of the instance type of the declaration,
+// if one exists.
+static const std::string * getInstTypeOfName( ast::Decl * decl ) {
+        if ( auto dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
+                if ( auto aggr = dynamic_cast<ast::BaseInstType const *>( dwt->get_type() ) ) {
+                        if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                return &aggr->name;
+                        }
+                }
+        }
+        return nullptr;
+}
+void buildList( DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< std::list< Declaration * > > out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
                 try {
+                        bool extracted = false;
+                        bool anon = false;
+                        bool extracted_named = false;
+                        ast::UnionDecl * unionDecl = nullptr;
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
+                                // handle the case where a structure declaration is contained within an object or type declaration
+                                Declaration * decl = extr->build();
+                                if ( decl ) {
+                                        // hoist the structure declaration
+                                        decl->location = cur->location;
+                                        * out++ = decl;
+                                assert( cur->type );
+                                nameTypedefedDecl( extr, cur );
+                                if ( ast::Decl * decl = extr->build() ) {
+                                        // Remember the declaration if it is a union aggregate ?
+                                        unionDecl = dynamic_cast<ast::UnionDecl *>( decl );
+                                        *out++ = decl;
                                         // need to remember the cases where a declaration contains an anonymous aggregate definition
-                                        extracted = true;
                                         assert( extr->type );
                                         if ( extr->type->kind == TypeData::Aggregate ) {
+                                                anon = extr->type->aggregate.anon;
+                                                // typedef struct { int A } B is the only case?
+                                                extracted_named = !extr->type->aggregate.anon;
                                         } else if ( extr->type->kind == TypeData::Enum ) {
+                                                // xxx - is it useful to have an implicit anonymous enum member?
+                                                anon = extr->type->enumeration.anon;
+                                                // typedef enum { A } B is the only case?
+                                                extracted_named = !extr->type->enumeration.anon;
+                                        } else {
+                                                extracted_named = true;
+                                        }
                                 } // if
 …
                         } // if
+                        Declaration * decl = cur->build();
+                        if ( decl ) {
+                                // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
+                                // struct S {
+                                //   struct T { int x; }; // no anonymous member
+                                //   struct { int y; };   // anonymous member
+                                //   struct T;            // anonymous member
+                                // };
+                                if ( ! (extracted && decl->name == "" && ! anon && ! cur->get_inLine()) ) {
+                                        if ( decl->name == "" ) {
+                                                if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>( decl ) ) {
+                                                        if ( ReferenceToType * aggr = dynamic_cast<ReferenceToType *>( dwt->get_type() ) ) {
+                                                                if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                                                        if ( ! cur->get_inLine() ) {
+                                                                                // temporary: warn about anonymous member declarations of named types, since
+                                                                                // this conflicts with the syntax for the forward declaration of an anonymous type
+                                                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, aggr->name.c_str() );
+                                                                        } // if
+                                                                } // if
+                                                        } // if
+                                                } // if
+                                        } // if
+                                        decl->location = cur->location;
+                                        *out++ = decl;
+                        if ( ast::Decl * decl = cur->build() ) {
+                                moveUnionAttribute( decl, unionDecl );
+                                if ( "" == decl->name && !cur->get_inLine() ) {
+                                        // Don't include anonymous declaration for named aggregates,
+                                        // but do include them for anonymous aggregates, e.g.:
+                                        // struct S {
+                                        //   struct T { int x; }; // no anonymous member
+                                        //   struct { int y; };   // anonymous member
+                                        //   struct T;            // anonymous member
+                                        // };
+                                        if ( extracted_named ) {
+                                                continue;
+                                        }
+                                        if ( auto name = getInstTypeOfName( decl ) ) {
+                                                // Temporary: warn about anonymous member declarations of named types, since
+                                                // this conflicts with the syntax for the forward declaration of an anonymous type.
+                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, name->c_str() );
+                                        }
                                 } // if
+                                *out++ = decl;
                         } // if
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
 …
 // currently only builds assertions, function parameters, and return values
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList ) {
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::DeclWithType>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::DeclWithType>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
                 try {
                         Declaration * decl = cur->build();
                         assert( decl );
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        ast::Decl * decl = cur->build();
+                        assertf( decl, "buildList: build for ast::DeclWithType." );
+                        if ( ast::DeclWithType * dwt = dynamic_cast<ast::DeclWithType *>( decl ) ) {
                                 dwt->location = cur->location;
                                 *out++ = dwt;
                         } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
+                        } else if ( ast::StructDecl * agg = dynamic_cast<ast::StructDecl *>( decl ) ) {
                                 // e.g., int foo(struct S) {}
                                 StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;
+                                auto inst = new ast::StructInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location, "", inst );
+                                obj->linkage = linkage;
                                 *out++ = obj;
                                 delete agg;
                         } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                        } else if ( ast::UnionDecl * agg = dynamic_cast<ast::UnionDecl *>( decl ) ) {
                                 // e.g., int foo(union U) {}
+                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                auto inst = new ast::UnionInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location,
+                                        "", inst, nullptr, ast::Storage::Classes(),
+                                        linkage );
                                 *out++ = obj;
                         } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
+                        } else if ( ast::EnumDecl * agg = dynamic_cast<ast::EnumDecl *>( decl ) ) {
                                 // e.g., int foo(enum E) {}
+                                EnumInstType * inst = new EnumInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                auto inst = new ast::EnumInstType( agg->name );
+                                auto obj = new ast::ObjectDecl( cur->location,
+                                        "",
+                                        inst,
+                                        nullptr,
+                                        ast::Storage::Classes(),
+                                        linkage
+                                );
                                 *out++ = obj;
+                        } else {
+                                assertf( false, "buildList: Could not convert to ast::DeclWithType." );
                         } // if
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
 …
 } // buildList
+void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList ) {
+void buildTypeList( const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Type>> & outputList ) {
         SemanticErrorException errors;
+        std::back_insert_iterator< std::list< Type * > > out( outputList );
+        const DeclarationNode * cur = firstNode;
+        while ( cur ) {
+        std::back_insert_iterator<std::vector<ast::ptr<ast::Type>>> out( outputList );
+        for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
                 try {
                         * out++ = cur->buildType();
                 } catch( SemanticErrorException & e ) {
+                } catch ( SemanticErrorException & e ) {
                         errors.append( e );
                 } // try
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
+        } // while
+        } // for
         if ( ! errors.isEmpty() ) {
 …
 } // buildTypeList
 Declaration * DeclarationNode::build() const {
+ast::Decl * DeclarationNode::build() const {
         if ( ! error.empty() ) SemanticError( this, error + " in declaration of " );
         if ( asmStmt ) {
+                return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
+                auto stmt = strict_dynamic_cast<ast::AsmStmt *>( asmStmt->build() );
+                return new ast::AsmDecl( stmt->location, stmt );
         } // if
         if ( directiveStmt ) {
+                return new DirectiveDecl( strict_dynamic_cast<DirectiveStmt *>( directiveStmt->build() ) );
+        } // if
+        if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
+                auto stmt = strict_dynamic_cast<ast::DirectiveStmt *>( directiveStmt->build() );
+                return new ast::DirectiveDecl( stmt->location, stmt );
+        } // if
+        if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
                 // otype is internally converted to dtype + otype parameters
                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dimension };
                 static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
+                static const ast::TypeDecl::Kind kindMap[] = { ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Dtype, ast::TypeDecl::Ftype, ast::TypeDecl::Ttype, ast::TypeDecl::Dimension };
+                static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == ast::TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype || variable.tyClass == TypeDecl::DStype, variable.initializer ? variable.initializer->buildType() : nullptr );
+                buildList( variable.assertions, ret->get_assertions() );
+                ast::TypeDecl * ret = new ast::TypeDecl( location,
+                        *name,
+                        ast::Storage::Classes(),
+                        (ast::Type *)nullptr,
+                        kindMap[ variable.tyClass ],
+                        variable.tyClass == ast::TypeDecl::Otype || variable.tyClass == ast::TypeDecl::DStype,
+                        variable.initializer ? variable.initializer->buildType() : nullptr
+                );
+                buildList( variable.assertions, ret->assertions );
                 return ret;
         } // if
 …
                 } // 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 );
+                ast::Decl * decl = buildDecl(
+                        type,
+                        name ? *name : string( "" ),
+                        storageClasses,
+                        maybeBuild( bitfieldWidth ),
+                        funcSpecs,
+                        linkage,
+                        asmName,
+                        isDelete ? nullptr : maybeBuild( initializer ),
+                        copy( attributes )
+                )->set_extension( extension );
                 if ( isDelete ) {
                         DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl );
+                        auto dwt = strict_dynamic_cast<ast::DeclWithType *>( decl );
                         dwt->isDeleted = true;
+                }
 …
         if ( assert.condition ) {
+                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
+                auto cond = maybeBuild( assert.condition );
+                auto msg = strict_dynamic_cast<ast::ConstantExpr *>( maybeCopy( assert.message ) );
+                return new ast::StaticAssertDecl( location, cond, msg );
+        }
 …
         } // if
         if ( enumInLine ) {
+                return new InlineMemberDecl( *name, storageClasses, linkage, nullptr );
+                return new ast::InlineMemberDecl( location,
+                        *name, (ast::Type*)nullptr, storageClasses, linkage );
         } // 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 );
+}
+Type * DeclarationNode::buildType() const {
+        auto ret = new ast::ObjectDecl( location,
+                *name,
+                (ast::Type*)nullptr,
+                maybeBuild( initializer ),
+                storageClasses,
+                linkage,
+                maybeBuild( bitfieldWidth )
+        );
+        ret->asmName = asmName;
+        ret->extension = extension;
+        return ret;
+}
+ast::Type * DeclarationNode::buildType() const {
         assert( type );
-        if ( attr.expr ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
-        } else if ( attr.type ) {
-                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
-        } // if
         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:
+                Type * simpletypes = typebuild( type );
+                simpletypes->get_attributes() = attributes;             // copy because member is const
+        case TypeData::Enum:
+        case TypeData::Aggregate: {
+                ast::BaseInstType * ret =
+                        buildComAggInst( type, copy( attributes ), linkage );
+                buildList( type->aggregate.actuals, ret->params );
+                return ret;
+        }
+        case TypeData::Symbolic: {
+                ast::TypeInstType * ret = new ast::TypeInstType(
+                        *type->symbolic.name,
+                        // This is just a default, the true value is not known yet.
+                        ast::TypeDecl::Dtype,
+                        buildQualifiers( type ),
+                        copy( attributes ) );
+                buildList( type->symbolic.actuals, ret->params );
+                return ret;
+        }
+        default:
+                ast::Type * simpletypes = typebuild( type );
+                // copy because member is const
+                simpletypes->attributes = attributes;
                 return simpletypes;
         } // switch

src/Parser/ExpressionNode.cc

-              r34b4268
+              r24d6572
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 13:17:07 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Aug  7 09:18:56 2021
+// Update Count     : 1077
+//
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:07:00 2023
+// Update Count     : 1083
+//
+#include "ExpressionNode.h"
 #include <cassert>                 // for assert
 …
 #include <string>                  // for string, operator+, operator==
+#include "AST/Expr.hpp"            // for NameExpr
+#include "AST/Type.hpp"            // for BaseType, SueInstType
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild, CodeLo...
+#include "ParseNode.h"             // for ExpressionNode, maybeMoveBuildType
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for EnumDecl, StructDecl, UnionDecl
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr, NameExpr
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement
+#include "SynTree/Type.h"          // for BasicType, Type, Type::Qualifiers
+#include "DeclarationNode.h"       // for DeclarationNode
+#include "InitializerNode.h"       // for InitializerNode
 #include "parserutility.h"         // for notZeroExpr
-class Initializer;
 using namespace std;
 …
 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
 // type.
-extern const Type::Qualifiers noQualifiers;                             // no qualifiers on constants
 // static inline bool checkH( char c ) { return c == 'h' || c == 'H'; }
 …
         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
 …
                 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
 } // scanbin
+Expression * build_constantInteger( string & str ) {
+        static const BasicType::Kind kind[2][6] = {
+ast::Expr * build_constantInteger(
+                const CodeLocation & location, string & str ) {
+        static const ast::BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh) because shorter type has the longer suffix
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ BasicType::LongLongSignedInt, },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ BasicType::LongLongUnsignedInt, },
+                { ast::BasicType::ShortSignedInt, ast::BasicType::SignedChar, ast::BasicType::SignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ ast::BasicType::LongLongSignedInt, },
+                { ast::BasicType::ShortUnsignedInt, ast::BasicType::UnsignedChar, ast::BasicType::UnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ ast::BasicType::LongLongUnsignedInt, },
         };
 …
         string str2( "0x0" );
         unsigned long long int v, v2 = 0;                                       // converted integral value
         Expression * ret, * ret2;
+        ast::Expr * ret, * ret2;
         int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
 …
         // special constants
         if ( str == "0" ) {
                 ret = new ConstantExpr( Constant( (Type *)new ZeroType( noQualifiers ), str, (unsigned long long int)0 ) );
+                ret = new ast::ConstantExpr( location, new ast::ZeroType(), str, 0 );
                 goto CLEANUP;
         } // if
         if ( str == "1" ) {
                 ret = new ConstantExpr( Constant( (Type *)new OneType( noQualifiers ), str, (unsigned long long int)1 ) );
+                ret = new ast::ConstantExpr( location, new ast::OneType(), str, 1 );
                 goto CLEANUP;
         } // if
-        string::size_type posn;
         // 'u' can appear before or after length suffix
 …
         } else {
                 // At least one digit in integer constant, so safe to backup while looking for suffix.
+                posn = str.find_last_of( "pP" );                                // pointer value
+                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "zZ" );                                // size_t
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+                posn = str.rfind( "hh" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.rfind( "HH" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.find_last_of( "hH" );                                // short
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "nN" );                                // int (natural number)
+                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
+                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
+                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
+          FINI: ;
+                // This declaration and the comma expressions in the conditions mimic
+                // the declare and check pattern allowed in later compiler versions.
+                // (Only some early compilers/C++ standards do not support it.)
+                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
 …
         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;
 …
                                 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__
 …
         // Constant type is correct for overload resolving.
+        ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][type] ), str, v ) );
+        ret = new ast::ConstantExpr( location,
+                new ast::BasicType( kind[Unsigned][type] ), str, v );
         if ( Unsigned && type < 2 ) {                                           // hh or h, less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                ret = new ast::CastExpr( location,
+                        ret,
+                        new ast::BasicType( kind[Unsigned][type] ),
+                        ast::ExplicitCast );
         } else if ( ltype != -1 ) {                                                     // explicit length ?
                 if ( ltype == 6 ) {                                                             // int128, (int128)constant
+//                      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 ) );
+                        ret2 = new ast::ConstantExpr( location,
+                                new ast::BasicType( ast::BasicType::LongLongSignedInt ),
+                                str2,
+                                v2 );
+                        ret = build_compoundLiteral( location,
+                                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 );
+                        ret = new ast::CastExpr( location,
+                                ret,
+                                new ast::TypeInstType( lnthsInt[Unsigned][ltype], ast::TypeDecl::Dtype ),
+                                ast::ExplicitCast );
                         if ( ltype == 5 ) {                                                     // pointer, intptr( (uintptr_t)constant )
+                                ret = build_func( new ExpressionNode( build_varref( new string( "intptr" ) ) ), new ExpressionNode( ret ) );
+                                ret = build_func( location,
+                                        new ExpressionNode(
+                                                build_varref( location, new string( "intptr" ) ) ),
+                                        new ExpressionNode( ret ) );
                         } // if
                 } // if
 …
+Expression * build_constantFloat( string & str ) {
+        static const BasicType::Kind kind[2][12] = {
+                { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x },
+                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::NUMBER_OF_BASIC_TYPES, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex },
+ast::Expr * build_constantFloat(
+                const CodeLocation & location, string & str ) {
+        static const ast::BasicType::Kind kind[2][12] = {
+                { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x },
+                { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::NUMBER_OF_BASIC_TYPES, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex },
         };
 …
         assert( 0 <= type && type < 12 );
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][type] ), str, v ) );
+        if ( explnth ) {                                                                        // explicit length ?
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][type] ), false );
+        ast::Expr * ret = new ast::ConstantExpr( location,
+                new ast::BasicType( kind[complx][type] ),
+                str,
+                v );
+        // explicit length ?
+        if ( explnth ) {
+                ret = new ast::CastExpr( location,
+                        ret,
+                        new ast::BasicType( kind[complx][type] ),
+                        ast::ExplicitCast );
         } // if
 …
 } // sepString
 Expression * build_constantChar( string & str ) {
+ast::Expr * build_constantChar( const CodeLocation & location, string & str ) {
         string units;                                                                           // units
         sepString( str, units, '\'' );                                          // separate constant from units
+        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::Char ), str, (unsigned long long int)(unsigned char)str[1] ) );
+        ast::Expr * ret = new ast::ConstantExpr( location,
+                new ast::BasicType( ast::BasicType::Char ),
+                str,
+                (unsigned long long int)(unsigned char)str[1] );
         if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new ast::UntypedExpr( location,
+                        new ast::NameExpr( location, units ),
+                        { ret } );
         } // if
 …
 } // build_constantChar
+Expression * build_constantStr( string & str ) {
+ast::Expr * build_constantStr(
+                const CodeLocation & location,
+                string & str ) {
         assert( str.length() > 0 );
         string units;                                                                           // units
         sepString( str, units, '"' );                                           // separate constant from units
         Type * strtype;
+        ast::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 );
+                strtype = new ast::TypeInstType( "char16_t", ast::TypeDecl::Dtype );
                 break;
           case 'U':
                 strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false );
+        case 'U':
+                strtype = new ast::TypeInstType( "char32_t", ast::TypeDecl::Dtype );
                 break;
           case 'L':
                 strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false );
+        case 'L':
+                strtype = new ast::TypeInstType( "wchar_t", ast::TypeDecl::Dtype );
                 break;
           Default:                                                                                      // char default string type
           default:
                 strtype = new BasicType( Type::Qualifiers( ), BasicType::Char );
+        Default:                                                                                        // char default string type
+        default:
+                strtype = new ast::BasicType( ast::BasicType::Char );
         } // switch
+        ArrayType * at = new ArrayType( noQualifiers, strtype,
+                                                                        new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
+                                                                        false, false );
+        Expression * ret = new ConstantExpr( Constant( at, str, std::nullopt ) );
+        ast::ArrayType * at = new ast::ArrayType(
+                strtype,
+                // Length is adjusted: +1 for '\0' and -2 for '"'
+                ast::ConstantExpr::from_ulong( location, str.size() + 1 - 2 ),
+                ast::FixedLen,
+                ast::DynamicDim );
+        ast::Expr * ret = new ast::ConstantExpr( location, at, str, std::nullopt );
         if ( units.length() != 0 ) {
+                ret = new UntypedExpr( new NameExpr( units ), { ret } );
+                ret = new ast::UntypedExpr( location,
+                        new ast::NameExpr( location, units ),
+                        { ret } );
         } // if
 …
 } // build_constantStr
+Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATING_FRACTIONconstant(
+                const CodeLocation & location, const string & str ) {
         if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) SemanticError( yylloc, "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
+        ast::Expr * ret = build_constantInteger( location,
+                *new string( str.substr(1) ) );
         delete &str;
         return ret;
 } // build_field_name_FLOATING_FRACTIONconstant
+Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATING_DECIMALconstant(
+                const CodeLocation & location, const string & str ) {
         if ( str[str.size() - 1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
+        Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
+        ast::Expr * ret = build_constantInteger(
+                location, *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;
         return ret;
 } // build_field_name_FLOATING_DECIMALconstant
+Expression * build_field_name_FLOATINGconstant( const string & str ) {
+ast::Expr * build_field_name_FLOATINGconstant( const CodeLocation & location,
+                const string & str ) {
         // str is of the form A.B -> separate at the . and return member expression
         int a, b;
 …
         stringstream ss( str );
         ss >> a >> dot >> b;
+        UntypedMemberExpr * ret = new UntypedMemberExpr( new ConstantExpr( Constant::from_int( b ) ), new ConstantExpr( Constant::from_int( a ) ) );
+        auto ret = new ast::UntypedMemberExpr( location,
+                ast::ConstantExpr::from_int( location, b ),
+                ast::ConstantExpr::from_int( location, a )
+        );
         delete &str;
         return ret;
 } // build_field_name_FLOATINGconstant
+Expression * make_field_name_fraction_constants( Expression * fieldName, Expression * fracts ) {
+        if ( fracts ) {
+                if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( fracts ) ) {
+                        memberExpr->set_member( make_field_name_fraction_constants( fieldName, memberExpr->get_aggregate() ) );
+                        return memberExpr;
+                } else {
+                        return new UntypedMemberExpr( fracts, fieldName );
+                } // if
+        } // if
+        return fieldName;
+ast::Expr * make_field_name_fraction_constants( const CodeLocation & location,
+                ast::Expr * fieldName,
+                ast::Expr * fracts ) {
+        if ( nullptr == fracts ) {
+                return fieldName;
+        } else if ( auto memberExpr = dynamic_cast<ast::UntypedMemberExpr *>( fracts ) ) {
+                memberExpr->member = make_field_name_fraction_constants( location,
+                        fieldName,
+                        ast::mutate( memberExpr->aggregate.get() ) );
+                return memberExpr;
+        } else {
+                return new ast::UntypedMemberExpr( location, fracts, fieldName );
+        } // if
 } // make_field_name_fraction_constants
+Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
+        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
+ast::Expr * build_field_name_fraction_constants( const CodeLocation & location,
+                ast::Expr * fieldName,
+                ExpressionNode * fracts ) {
+        return make_field_name_fraction_constants( location, fieldName, maybeMoveBuild( fracts ) );
 } // build_field_name_fraction_constants
+NameExpr * build_varref( const string * name ) {
+        NameExpr * expr = new NameExpr( *name );
+ast::NameExpr * build_varref( const CodeLocation & location,
+                const string * name ) {
+        ast::NameExpr * expr = new ast::NameExpr( location, *name );
         delete name;
         return expr;
 } // build_varref
+QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) {
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node);
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) {
+                const Type * t = newDeclWithType->get_type();
+                if ( t ) {
+                        if ( const TypeInstType * typeInst = dynamic_cast<const TypeInstType *>( t ) ) {
+                                newDecl= new EnumDecl( typeInst->name );
+ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation & location,
+                const DeclarationNode * decl_node,
+                const ast::NameExpr * name ) {
+        ast::Decl * newDecl = maybeBuild( decl_node );
+        if ( ast::DeclWithType * newDeclWithType = dynamic_cast<ast::DeclWithType *>( newDecl ) ) {
+                if ( const ast::Type * t = newDeclWithType->get_type() ) {
+                        if ( auto typeInst = dynamic_cast<const ast::TypeInstType *>( t ) ) {
+                                newDecl = new ast::EnumDecl( location, typeInst->name );
+                        }
+                }
+        }
         return new QualifiedNameExpr( newDecl, name->name );
+        return new ast::QualifiedNameExpr( location, newDecl, name->name );
+}
+QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl_node, const NameExpr * name ) {
+        EnumDecl * newDecl = const_cast< EnumDecl * >( decl_node );
+        return new QualifiedNameExpr( newDecl, name->name );
+ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation & location,
+                const ast::EnumDecl * decl,
+                const ast::NameExpr * name ) {
+        return new ast::QualifiedNameExpr( location, decl, name->name );
+}
+DimensionExpr * build_dimensionref( const string * name ) {
+        DimensionExpr * expr = new DimensionExpr( *name );
+ast::DimensionExpr * build_dimensionref( const CodeLocation & location,
+                const string * name ) {
+        ast::DimensionExpr * expr = new ast::DimensionExpr( location, *name );
         delete name;
         return expr;
 …
 }; // OperName
+Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node, CastExpr::CastKind kind ) {
+        Type * targetType = maybeMoveBuildType( decl_node );
+        if ( dynamic_cast< VoidType * >( targetType ) ) {
+ast::Expr * build_cast( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ExpressionNode * expr_node,
+                ast::CastExpr::CastKind kind ) {
+        ast::Type * targetType = maybeMoveBuildType( decl_node );
+        if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
                 delete targetType;
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false, kind );
+                return new ast::CastExpr( location,
+                        maybeMoveBuild( expr_node ),
+                        ast::ExplicitCast, kind );
         } else {
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false, kind );
+                return new ast::CastExpr( location,
+                        maybeMoveBuild( expr_node ),
+                        targetType,
+                        ast::ExplicitCast, kind );
         } // if
 } // build_cast
+Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node ) {
+        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
+ast::Expr * build_keyword_cast( const CodeLocation & location,
+                ast::AggregateDecl::Aggregate target,
+                ExpressionNode * expr_node ) {
+        return new ast::KeywordCastExpr( location,
+                maybeMoveBuild( expr_node ),
+                target
+        );
+}
+Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+        return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
+ast::Expr * build_virtual_cast( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ExpressionNode * expr_node ) {
+        return new ast::VirtualCastExpr( location,
+                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) );
+ast::Expr * build_fieldSel( const CodeLocation & location,
+                ExpressionNode * expr_node,
+                ast::Expr * member ) {
+        return new ast::UntypedMemberExpr( location,
+                member,
+                maybeMoveBuild( expr_node )
+        );
 } // build_fieldSel
+Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member ) {
+        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+ast::Expr * build_pfieldSel( const CodeLocation & location,
+                ExpressionNode * expr_node,
+                ast::Expr * member ) {
+        auto deref = new ast::UntypedExpr( location,
+                new ast::NameExpr( location, "*?" )
+        );
         deref->location = expr_node->location;
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
         UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref );
+        deref->args.push_back( maybeMoveBuild( expr_node ) );
+        auto ret = new ast::UntypedMemberExpr( location, member, deref );
         return ret;
 } // build_pfieldSel
+Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
+        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
+ast::Expr * build_offsetOf( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                ast::NameExpr * member ) {
+        ast::Expr * ret = new ast::UntypedOffsetofExpr( location,
+                maybeMoveBuildType( decl_node ),
+                member->name
+        );
+        ret->result = new ast::BasicType( ast::BasicType::LongUnsignedInt );
         delete member;
         return ret;
 } // build_offsetOf
+Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) {
+        return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind );
+ast::Expr * build_and_or( const CodeLocation & location,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2,
+                ast::LogicalFlag flag ) {
+        return new ast::LogicalExpr( location,
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                notZeroExpr( maybeMoveBuild( expr_node2 ) ),
+                flag
+        );
 } // build_and_or
+Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) {
+        list< Expression * > args;
+        args.push_back( maybeMoveBuild< Expression >(expr_node) );
+        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+ast::Expr * build_unary_val( const CodeLocation & location,
+                OperKinds op,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> args;
+        args.push_back( maybeMoveBuild( expr_node ) );
+        return new ast::UntypedExpr( location,
+                new ast::NameExpr( location, OperName[ (int)op ] ),
+                std::move( 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) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
+ast::Expr * build_binary_val( const CodeLocation & location,
+                OperKinds op,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2 ) {
+        std::vector<ast::ptr<ast::Expr>> args;
+        args.push_back( maybeMoveBuild( expr_node1 ) );
+        args.push_back( maybeMoveBuild( expr_node2 ) );
+        return new ast::UntypedExpr( location,
+                new ast::NameExpr( location, OperName[ (int)op ] ),
+                std::move( args )
+        );
 } // build_binary_val
+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) );
         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) );
+ast::Expr * build_cond( const CodeLocation & location,
+                ExpressionNode * expr_node1,
+                ExpressionNode * expr_node2,
+                ExpressionNode * expr_node3 ) {
+        return new ast::ConditionalExpr( location,
+                notZeroExpr( maybeMoveBuild( expr_node1 ) ),
+                maybeMoveBuild( expr_node2 ),
+                maybeMoveBuild( expr_node3 )
+        );
 } // build_cond
+Expression * build_tuple( ExpressionNode * expr_node ) {
+        list< Expression * > exprs;
+ast::Expr * build_tuple( const CodeLocation & location,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> exprs;
         buildMoveList( expr_node, exprs );
         return new UntypedTupleExpr( exprs );;
+        return new ast::UntypedTupleExpr( location, std::move( exprs ) );
 } // build_tuple
+Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
+        list< Expression * > args;
+ast::Expr * build_func( const CodeLocation & location,
+                ExpressionNode * function,
+                ExpressionNode * expr_node ) {
+        std::vector<ast::ptr<ast::Expr>> args;
         buildMoveList( expr_node, args );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
+        return new ast::UntypedExpr( location,
+                maybeMoveBuild( function ),
+                std::move( args )
+        );
 } // build_func
+Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
+        Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
+        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) );
+ast::Expr * build_compoundLiteral( const CodeLocation & location,
+                DeclarationNode * decl_node,
+                InitializerNode * kids ) {
+        // compound literal type
+        ast::Decl * newDecl = maybeBuild( decl_node );
+        // non-sue compound-literal type
+        if ( ast::DeclWithType * newDeclWithType = dynamic_cast<ast::DeclWithType *>( newDecl ) ) {
+                return new ast::CompoundLiteralExpr( location,
+                        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) );
+        } else if ( auto newDeclStructDecl = dynamic_cast<ast::StructDecl *>( newDecl ) ) {
+                if ( newDeclStructDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::StructInstType( newDeclStructDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(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 ast::CompoundLiteralExpr( location,
+                                new ast::StructInstType( newDeclStructDecl->name ),
+                                maybeMoveBuild( kids ) );
+                } // if
+        } else if ( auto newDeclUnionDecl = dynamic_cast<ast::UnionDecl *>( newDecl )  ) {
+                if ( newDeclUnionDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::UnionInstType( newDeclUnionDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(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 ast::CompoundLiteralExpr( location,
+                                new ast::UnionInstType( newDeclUnionDecl->name ),
+                                maybeMoveBuild( kids ) );
+                } // if
+        } else if ( auto newDeclEnumDecl = dynamic_cast<ast::EnumDecl *>( newDecl )  ) {
+                if ( newDeclEnumDecl->body ) {
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::EnumInstType( newDeclEnumDecl ),
+                                maybeMoveBuild( kids ) );
                 } else {
+                        return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) );
+                        return new ast::CompoundLiteralExpr( location,
+                                new ast::EnumInstType( newDeclEnumDecl->name ),
+                                maybeMoveBuild( kids ) );
                 } // if
         } else {
 …
 // Local Variables: //
 // tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
 // End: //

src/Parser/InitializerNode.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 28 23:27:20 2017
 // Update Count     : 26
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 11:18:00 2023
+// Update Count     : 27
 //
+#include "InitializerNode.h"
 #include <iostream>                // for operator<<, ostream, basic_ostream
 …
 #include <string>                  // for operator<<, string
+#include "AST/Expr.hpp"            // for Expr
+#include "AST/Init.hpp"            // for Designator, Init, ListInit, Sing...
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ExpressionNode.h"        // for ExpressionNode
+#include "DeclarationNode.h"       // for buildList
 using namespace std;
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeBuild
+#include "ParseNode.h"             // for InitializerNode, ExpressionNode
+#include "SynTree/Expression.h"    // for Expression
+#include "SynTree/Initializer.h"   // for Initializer, ListInit, SingleInit
+static ast::ConstructFlag toConstructFlag( bool maybeConstructed ) {
+        return maybeConstructed ? ast::MaybeConstruct : ast::NoConstruct;
+}
 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des )
 …
         if ( kids )
                 set_last( nullptr );
 } // InitializerNode::InitializerNode
+} // InitializerNode::InitializerNode
 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des )
 …
 } // InitializerNode::printOneLine
 Initializer * InitializerNode::build() const {
+ast::Init * InitializerNode::build() const {
         assertf( ! isDelete, "Should not build delete stmt InitializerNode" );
         if ( aggregate ) {
                 // steal designators from children
                 std::list< Designation * > designlist;
+                std::vector<ast::ptr<ast::Designation>> designlist;
                 InitializerNode * child = next_init();
+                for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::list< Expression * > desList;
+                        buildList< Expression, ExpressionNode >( child->designator, desList );
+                        designlist.push_back( new Designation( desList ) );
+                for ( ; child != nullptr ; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) {
+                        std::deque<ast::ptr<ast::Expr>> desList;
+                        buildList( child->designator, desList );
+                        designlist.push_back(
+                                new ast::Designation( location, std::move( desList ) ) );
                 } // for
+                std::list< Initializer * > initlist;
+                buildList< Initializer, InitializerNode >( next_init(), initlist );
+                return new ListInit( initlist, designlist, maybeConstructed );
+        } else {
+                if ( get_expression() ) {
+                        assertf( get_expression()->expr, "The expression of initializer must have value" );
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed );
+                } // if
+                std::vector<ast::ptr<ast::Init>> initlist;
+                buildList( next_init(), initlist );
+                return new ast::ListInit( location,
+                        std::move( initlist ),
+                        std::move( designlist ),
+                        toConstructFlag( maybeConstructed )
+                );
+        } else if ( get_expression() ) {
+                assertf( get_expression()->expr, "The expression of initializer must have value" );
+                return new ast::SingleInit( location,
+                        maybeBuild( get_expression() ),
+                        toConstructFlag( maybeConstructed )
+                );
         } // if
         return nullptr;

src/Parser/ParseNode.h

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Nov  2 21:27:07 2022
 // Update Count     : 939
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr  3 17:55:00 2023
+// Update Count     : 942
 //
 …
 #include <string>                  // for string
+#include "AST/Expr.hpp"            // for Expr, NameExpr LogicalFlag
+#include "AST/Fwd.hpp"             // for ptr, Decl, DeclWithType,
+#include "AST/Stmt.hpp"            // for Stmt
 #include "Common/CodeLocation.h"   // for CodeLocation
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
+#include "Common/utility.h"        // for maybeClone, maybeBuild
+#include "SynTree/LinkageSpec.h"   // for Spec
+#include "SynTree/Declaration.h"   // for Aggregate
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
+#include "SynTree/Label.h"         // for Label
+#include "SynTree/Statement.h"     // for Statement, BranchStmt, BranchStmt:...
+#include "SynTree/Type.h"          // for Type, Type::FuncSpecifiers, Type::...
+#include "Common/utility.h"        // for maybeClone
+#include "Parser/parserutility.h"  // for maybeBuild, maybeCopy
 class Attribute;
 …
 class DeclarationWithType;
 class Initializer;
+class InitializerNode;
 class ExpressionNode;
 struct StatementNode;
 …
 }; // ParseNode
-//##############################################################################
-class InitializerNode : public ParseNode {
-  public:
-        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
-        InitializerNode( bool isDelete );
-        ~InitializerNode();
-        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
-        ExpressionNode * get_expression() const { return expr; }
-        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
-        ExpressionNode * get_designators() const { return designator; }
-        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
-        bool get_maybeConstructed() const { return maybeConstructed; }
-        bool get_isDelete() const { return isDelete; }
-        InitializerNode * next_init() const { return kids; }
-        void print( std::ostream & os, int indent = 0 ) const;
-        void printOneLine( std::ostream & ) const;
-        virtual Initializer * build() const;
-  private:
-        ExpressionNode * expr;
-        bool aggregate;
-        ExpressionNode * designator;                                            // may be list
-        InitializerNode * kids;
-        bool maybeConstructed;
-        bool isDelete;
-}; // InitializerNode
-//##############################################################################
-class ExpressionNode final : public ParseNode {
-  public:
-        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
-        virtual ~ExpressionNode() {}
-        virtual ExpressionNode * clone() const override { return expr ? static_cast<ExpressionNode*>((new ExpressionNode( expr->clone() ))->set_next( maybeClone( get_next() ) )) : nullptr; }
-        bool get_extension() const { return extension; }
-        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
-        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
-                os << expr.get();
+        }
-        void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
-        template<typename T>
-        bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
-        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
-        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
-  private:
-        bool extension = false;
-}; // 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.
 enum class OperKinds {
 …
 struct LabelNode {
         std::list< Label > labels;
+        std::vector<ast::Label> labels;
 };
-Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
-Expression * build_constantFloat( std::string & str );
-Expression * build_constantChar( std::string & str );
-Expression * build_constantStr( std::string & str );
-Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
-Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
-Expression * build_field_name_FLOATINGconstant( const std::string & str );
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
-NameExpr * build_varref( const std::string * name );
-QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
-QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
-DimensionExpr * build_dimensionref( const std::string * name );
-Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node, CastExpr::CastKind kind = CastExpr::Default );
-Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
-Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
-Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
-Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
-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 );
-Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
-Expression * build_tuple( ExpressionNode * expr_node = nullptr );
-Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
-Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
-//##############################################################################
-struct TypeData;
-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 };
-        static const char * basicTypeNames[];
-        enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
-        static const char * complexTypeNames[];
-        enum Signedness { Signed, Unsigned, NoSignedness };
-        static const char * signednessNames[];
-        enum Length { Short, Long, LongLong, NoLength };
-        static const char * lengthNames[];
-        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
-        static const char * builtinTypeNames[];
-        static DeclarationNode * newStorageClass( Type::StorageClasses );
-        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
-        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
-        static DeclarationNode * newBasicType( BasicType );
-        static DeclarationNode * newComplexType( ComplexType );
-        static DeclarationNode * newSignedNess( Signedness );
-        static DeclarationNode * newLength( Length );
-        static DeclarationNode * newBuiltinType( BuiltinType );
-        static DeclarationNode * newForall( DeclarationNode * );
-        static DeclarationNode * newFromTypedef( const std::string * );
-        static DeclarationNode * newFromGlobalScope();
-        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
-        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
-        static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
-        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
-        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
-        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
-        static DeclarationNode * newEnumInLine( const std::string name );
-        static DeclarationNode * newName( const std::string * );
-        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
-        static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
-        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
-        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
-        static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
-        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
-        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
-        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
-        static DeclarationNode * newBitfield( ExpressionNode * size );
-        static DeclarationNode * newTuple( DeclarationNode * members );
-        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
-        static DeclarationNode * newVtableType( DeclarationNode * expr );
-        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
-        static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
-        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
-        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
-        DeclarationNode();
-        ~DeclarationNode();
-        DeclarationNode * clone() const override;
-        DeclarationNode * addQualifiers( DeclarationNode * );
-        void checkQualifiers( const TypeData *, const TypeData * );
-        void checkSpecifiers( DeclarationNode * );
-        DeclarationNode * copySpecifiers( DeclarationNode * );
-        DeclarationNode * addType( DeclarationNode * );
-        DeclarationNode * addTypedef();
-        DeclarationNode * addEnumBase( DeclarationNode * );
-        DeclarationNode * addAssertions( DeclarationNode * );
-        DeclarationNode * addName( std::string * );
-        DeclarationNode * addAsmName( DeclarationNode * );
-        DeclarationNode * addBitfield( ExpressionNode * size );
-        DeclarationNode * addVarArgs();
-        DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
-        DeclarationNode * addOldDeclList( DeclarationNode * list );
-        DeclarationNode * setBase( TypeData * newType );
-        DeclarationNode * copyAttribute( DeclarationNode * attr );
-        DeclarationNode * addPointer( DeclarationNode * qualifiers );
-        DeclarationNode * addArray( DeclarationNode * array );
-        DeclarationNode * addNewPointer( DeclarationNode * pointer );
-        DeclarationNode * addNewArray( DeclarationNode * array );
-        DeclarationNode * addParamList( DeclarationNode * list );
-        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
-        DeclarationNode * addInitializer( InitializerNode * init );
-        DeclarationNode * addTypeInitializer( DeclarationNode * init );
-        DeclarationNode * cloneType( std::string * newName );
-        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
-        DeclarationNode * appendList( DeclarationNode * node ) {
-                return (DeclarationNode *)set_last( node );
+        }
-        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
-        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
-        Declaration * build() const;
-        Type * buildType() const;
-        LinkageSpec::Spec get_linkage() const { return linkage; }
-        DeclarationNode * extractAggregate() const;
-        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
-        bool get_extension() const { return extension; }
-        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
-        bool get_inLine() const { return inLine; }
-        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
-        DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
-        struct Variable_t {
-//              const std::string * name;
-                TypeDecl::Kind tyClass;
-                DeclarationNode * assertions;
-                DeclarationNode * initializer;
-        };
-        Variable_t variable;
-        struct Attr_t {
-//              const std::string * name;
-                ExpressionNode * expr;
-                DeclarationNode * type;
-        };
-        Attr_t attr;
-        struct StaticAssert_t {
-                ExpressionNode * condition;
-                Expression * message;
-        };
-        StaticAssert_t assert;
-        BuiltinType builtin = NoBuiltinType;
-        TypeData * type = nullptr;
-        bool inLine = false;
-        bool enumInLine = false;
-        Type::FuncSpecifiers funcSpecs;
-        Type::StorageClasses storageClasses;
-        ExpressionNode * bitfieldWidth = nullptr;
-        std::unique_ptr<ExpressionNode> enumeratorValue;
-        bool hasEllipsis = false;
-        LinkageSpec::Spec linkage;
-        Expression * asmName = nullptr;
-        std::list< Attribute * > attributes;
-        InitializerNode * initializer = nullptr;
-        bool extension = false;
-        std::string error;
-        StatementNode * asmStmt = nullptr;
-        StatementNode * directiveStmt = nullptr;
-        static UniqueName anonymous;
-}; // DeclarationNode
-Type * buildType( TypeData * type );
-static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
-        Type * ret = orig ? orig->buildType() : nullptr;
-        delete orig;
-        return ret;
+}
-//##############################################################################
-struct StatementNode final : public ParseNode {
-        StatementNode() { stmt = nullptr; }
-        StatementNode( Statement * stmt ) : stmt( stmt ) {}
-        StatementNode( DeclarationNode * decl );
-        virtual ~StatementNode() {}
-        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
-        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
-        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
-                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
-                delete attr;
-                delete name;
-                return this;
+        }
-        virtual StatementNode * append_last_case( StatementNode * );
-        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
-                os << stmt.get() << std::endl;
+        }
-        std::unique_ptr<Statement> stmt;
-}; // StatementNode
-Statement * build_expr( ExpressionNode * ctl );
-struct CondCtl {
-        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
-                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
-        StatementNode * init;
-        ExpressionNode * condition;
-};
-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 ) {}
-        StatementNode * init;
-        ExpressionNode * condition;
-        ExpressionNode * change;
-};
-Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
-Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
-Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
-Statement * build_case( ExpressionNode * ctl );
-Statement * build_default();
-Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
-Statement * build_branch( BranchStmt::Type kind );
-Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
-Statement * build_computedgoto( ExpressionNode * ctl );
-Statement * build_return( ExpressionNode * ctl );
-Statement * build_throw( ExpressionNode * ctl );
-Statement * build_resume( ExpressionNode * ctl );
-Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
-Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
-Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
-Statement * build_finally( StatementNode * stmt );
-Statement * build_compound( StatementNode * first );
-StatementNode * maybe_build_compound( StatementNode * first );
-Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
-Statement * build_directive( std::string * directive );
-SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
-Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
-Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
-//##############################################################################
-template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
-void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
-        SemanticErrorException errors;
-        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
-        const NodeType * cur = firstNode;
-        while ( cur ) {
-                try {
-                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
-                        if ( result ) {
-                                result->location = cur->location;
-                                * out++ = result;
-                        } else {
-                                SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
-                        } // if
-                } catch( SemanticErrorException & e ) {
-                        errors.append( e );
-                } // try
-                const ParseNode * temp = (cur->get_next());
-                cur = dynamic_cast< const NodeType * >( temp ); // should not return nullptr
-                if ( ! cur && temp ) {                                                  // non-homogeneous nodes ?
-                        SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
-                } // if
-        } // while
-        if ( ! errors.isEmpty() ) {
-                throw errors;
-        } // if
+}
-// in DeclarationNode.cc
-void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList );
-void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList );
-void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList );
-template< typename SynTreeType, typename NodeType >
-void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
-        buildList( firstNode, outputList );
-        delete firstNode;
+}
-// in ParseNode.cc
 std::ostream & operator<<( std::ostream & out, const ParseNode * node );

src/Parser/ParserTypes.h

-              r34b4268
+              r24d6572
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // parser.hh --
 //
+//
+// parser.hh --
+//
 // Author           : Peter A. Buhr
 // Created On       : Sat Sep 22 08:58:10 2001

src/Parser/StatementNode.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb  2 20:29:30 2022
 // Update Count     : 425
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr 11 10:16:00 2023
+// Update Count     : 428
 //
+#include "StatementNode.h"
 #include <cassert>                 // for assert, strict_dynamic_cast, assertf
-#include <list>                    // for list
 #include <memory>                  // for unique_ptr
 #include <string>                  // for string
+#include "AST/Label.hpp"           // for Label
+#include "AST/Stmt.hpp"            // for Stmt, AsmStmt, BranchStmt, CaseCla...
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild
+#include "ParseNode.h"             // for StatementNode, ExpressionNode, bui...
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr
+#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Declaration.h"
+#include "SynTree/Statement.h"     // for Statement, BranchStmt, CaseStmt
+#include "DeclarationNode.h"       // for DeclarationNode
+#include "ExpressionNode.h"        // for ExpressionNode
 #include "parserutility.h"         // for notZeroExpr
 …
 using namespace std;
+// Some helpers for cases that really want a single node but check for lists.
+static const ast::Stmt * buildMoveSingle( StatementNode * node ) {
+        std::vector<ast::ptr<ast::Stmt>> list;
+        buildMoveList( node, list );
+        assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" );
+        return list.front().release();
+}
+static const ast::Stmt * buildMoveOptional( StatementNode * node ) {
+        std::vector<ast::ptr<ast::Stmt>> list;
+        buildMoveList( node, list );
+        assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" );
+        return list.empty() ? nullptr : list.front().release();
+}
 StatementNode::StatementNode( DeclarationNode * decl ) {
 …
         DeclarationNode * agg = decl->extractAggregate();
         if ( agg ) {
+                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode * nextStmt = new StatementNode(
+                        new ast::DeclStmt( decl->location, maybeBuild( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
 …
                 agg = decl;
         } // if
+        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
+        // Local copy to avoid accessing the pointer after it is moved from.
+        CodeLocation declLocation = agg->location;
+        stmt.reset( new ast::DeclStmt( declLocation, maybeMoveBuild( agg ) ) );
 } // StatementNode::StatementNode
+StatementNode * StatementNode::append_last_case( StatementNode * stmt ) {
+        StatementNode * prev = this;
+StatementNode * StatementNode::add_label(
+                const CodeLocation & location,
+                const std::string * name,
+                DeclarationNode * attr ) {
+        stmt->labels.emplace_back( location,
+                *name,
+                attr ? std::move( attr->attributes )
+                        : std::vector<ast::ptr<ast::Attribute>>{} );
+        delete attr;
+        delete name;
+        return this;
+}
+ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) {
+        ClauseNode * prev = this;
         // find end of list and maintain previous pointer
         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
                 StatementNode * node = strict_dynamic_cast< StatementNode * >(curr);
                 assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
+        for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) {
+                ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr);
+                assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) );
                 prev = curr;
         } // for
+        ClauseNode * node = dynamic_cast< ClauseNode * >(prev);
         // convert from StatementNode list to Statement list
+        StatementNode * node = dynamic_cast< StatementNode * >(prev);
+        list< Statement * > stmts;
+        std::vector<ast::ptr<ast::Stmt>> stmts;
         buildMoveList( stmt, stmts );
         // splice any new Statements to end of current Statements
+        CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt.get());
+        caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
+        auto caseStmt = strict_dynamic_cast<ast::CaseClause *>( node->clause.get() );
+        for ( auto const & newStmt : stmts ) {
+                caseStmt->stmts.emplace_back( newStmt );
+        }
+        stmts.clear();
         return this;
+} // StatementNode::append_last_case
+Statement * build_expr( ExpressionNode * ctl ) {
+        Expression * e = maybeMoveBuild< Expression >( ctl );
+        if ( e ) return new ExprStmt( e );
+        else return new NullStmt();
+} // ClauseNode::append_last_case
+ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) {
+        if ( ast::Expr * e = maybeMoveBuild( ctl ) ) {
+                return new ast::ExprStmt( location, e );
+        } else {
+                return new ast::NullStmt( location );
+        }
 } // build_expr
+Expression * build_if_control( CondCtl * ctl, list< Statement * > & init ) {
+        if ( ctl->init != 0 ) {
+                buildMoveList( ctl->init, init );
+static ast::Expr * build_if_control( CondCtl * ctl,
+                std::vector<ast::ptr<ast::Stmt>> & inits ) {
+        assert( inits.empty() );
+        if ( nullptr != ctl->init ) {
+                buildMoveList( ctl->init, inits );
         } // if
         Expression * cond = nullptr;
+        ast::Expr * cond = nullptr;
         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 ) {
+                for ( ast::ptr<ast::Stmt> & stmt : inits ) {
                         // build the && of all of the declared variables compared against 0
                         DeclStmt * declStmt = strict_dynamic_cast< DeclStmt * >( stmt );
                         DeclarationWithType * dwt = strict_dynamic_cast< DeclarationWithType * >( declStmt->decl );
                         Expression * nze = notZeroExpr( new VariableExpr( dwt ) );
                         cond = cond ? new LogicalExpr( cond, nze, true ) : nze;
+                        auto declStmt = stmt.strict_as<ast::DeclStmt>();
+                        auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
+                        ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
+                        cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze;
+                }
+        }
 …
 } // build_if_control
+Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        Statement * astthen, * astelse = nullptr;
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( then, aststmt );
+        assert( aststmt.size() == 1 );
+        astthen = aststmt.front();
+        if ( else_ ) {
+                list< Statement * > aststmt;
+                buildMoveList< Statement, StatementNode >( else_, aststmt );
+                assert( aststmt.size() == 1 );
+                astelse = aststmt.front();
+        } // if
+        return new IfStmt( astcond, astthen, astelse, astinit );
+ast::Stmt * build_if( const CodeLocation & location, CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        ast::Stmt const * astthen = buildMoveSingle( then );
+        ast::Stmt const * astelse = buildMoveOptional( else_ );
+        return new ast::IfStmt( location, astcond, astthen, astelse,
+                std::move( astinit )
+        );
 } // build_if
+Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        if ( ! isSwitch ) {                                                                     // choose statement
+                for ( Statement * stmt : aststmt ) {
+                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
+                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
+                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
+                                block->kids.push_back( new BranchStmt( "", BranchStmt::Break ) );
+ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) {
+        std::vector<ast::ptr<ast::CaseClause>> aststmt;
+        buildMoveList( stmt, aststmt );
+        // If it is not a switch it is a choose statement.
+        if ( ! isSwitch ) {
+                for ( ast::ptr<ast::CaseClause> & stmt : aststmt ) {
+                        // Code after "case" is the end of case list.
+                        if ( !stmt->stmts.empty() ) {
+                                auto mutStmt = ast::mutate( stmt.get() );
+                                // I believe the stmts are actually always one block.
+                                auto stmts = mutStmt->stmts.front().get_and_mutate();
+                                auto block = strict_dynamic_cast<ast::CompoundStmt *>( stmts );
+                                block->kids.push_back( new ast::BranchStmt( block->location,
+                                        ast::BranchStmt::Break,
+                                        ast::Label( block->location ) ) );
+                                stmt = mutStmt;
                         } // if
                 } // for
         } // if
         // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
+        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
+        return new ast::SwitchStmt( location,
+                maybeMoveBuild( ctl ), std::move( aststmt ) );
 } // build_switch
+Statement * build_case( ExpressionNode * ctl ) {
+        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
+ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) {
+        // stmt starts empty and then added to
+        auto expr = maybeMoveBuild( ctl );
+        return new ast::CaseClause( location, expr, {} );
 } // build_case
+Statement * build_default() {
+        return new CaseStmt( nullptr, {}, true );                       // stmt starts empty and then added to
+ast::CaseClause * build_default( const CodeLocation & location ) {
+        // stmt starts empty and then added to
+        return new ast::CaseClause( location, nullptr, {} );
 } // build_default
+Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+        return new WhileDoStmt( astcond, aststmt.front(), astelse.front(), astinit, false );
+ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+        return new ast::WhileDoStmt( location,
+                astcond,
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ ),
+                std::move( astinit ),
+                ast::While
+        );
 } // build_while
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );                                          // compound created if empty
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
         // 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 ast::WhileDoStmt( location,
+                notZeroExpr( maybeMoveBuild( ctl ) ),
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ ),
+                {},
+                ast::DoWhile
+        );
 } // build_do_while
 Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
         list< Statement * > astinit;                                            // maybe empty
+ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
         buildMoveList( forctl->init, astinit );
         Expression * astcond = nullptr;                                         // maybe empty
         astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
         Expression * astincr = nullptr;                                         // maybe empty
         astincr = maybeMoveBuild< Expression >(forctl->change);
+        ast::Expr * astcond = nullptr;                                          // maybe empty
+        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        ast::Expr * astincr = nullptr;                                          // maybe empty
+        astincr = maybeMoveBuild( forctl->change );
         delete forctl;
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+        return new ForStmt( astinit, astcond, astincr, aststmt.front(), astelse.front() );
+        return new ast::ForStmt( location,
+                std::move( astinit ),
+                astcond,
+                astincr,
+                buildMoveSingle( stmt ),
+                buildMoveOptional( else_ )
+        );
 } // build_for
+Statement * build_branch( BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( "", kind );
+        return ret;
+ast::Stmt * build_branch( const CodeLocation & location, ast::BranchStmt::Kind kind ) {
+        return new ast::BranchStmt( location,
+                kind,
+                ast::Label( location )
+        );
 } // build_branch
+Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( * identifier, kind );
+ast::Stmt * build_branch( const CodeLocation & location, string * identifier, ast::BranchStmt::Kind kind ) {
+        ast::Stmt * ret = new ast::BranchStmt( location,
+                kind,
+                ast::Label( location, *identifier )
+        );
         delete identifier;                                                                      // allocated by lexer
         return ret;
 } // build_branch
+Statement * build_computedgoto( ExpressionNode * ctl ) {
+        return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+ast::Stmt * build_computedgoto( ExpressionNode * ctl ) {
+        ast::Expr * expr = maybeMoveBuild( ctl );
+        return new ast::BranchStmt( expr->location, expr );
 } // build_computedgoto
 Statement * build_return( ExpressionNode * ctl ) {
         list< Expression * > exps;
+ast::Stmt * build_return( const CodeLocation & location, ExpressionNode * ctl ) {
+        std::vector<ast::ptr<ast::Expr>> exps;
         buildMoveList( ctl, exps );
+        return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
+        return new ast::ReturnStmt( location,
+                exps.size() > 0 ? exps.back().release() : nullptr
+        );
 } // build_return
+Statement * build_throw( ExpressionNode * ctl ) {
+        list< Expression * > exps;
+static ast::Stmt * build_throw_stmt(
+                const CodeLocation & location,
+                ExpressionNode * ctl,
+                ast::ExceptionKind kind ) {
+        std::vector<ast::ptr<ast::Expr>> exps;
         buildMoveList( ctl, exps );
         assertf( exps.size() < 2, "CFA internal error: leaking memory" );
+        return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+        return new ast::ThrowStmt( location,
+                kind,
+                !exps.empty() ? exps.back().release() : nullptr,
+                (ast::Expr *)nullptr
+        );
+}
+ast::Stmt * build_throw( const CodeLocation & loc, ExpressionNode * ctl ) {
+        return build_throw_stmt( loc, ctl, ast::Terminate );
 } // build_throw
+Statement * build_resume( ExpressionNode * ctl ) {
+        list< Expression * > exps;
+        buildMoveList( ctl, exps );
+        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
+        return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+ast::Stmt * build_resume( const CodeLocation & loc, ExpressionNode * ctl ) {
+        return build_throw_stmt( loc, ctl, ast::Resume );
 } // build_resume
 Statement * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
+ast::Stmt * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
         (void)ctl;
         (void)target;
 …
 } // build_resume_at
+Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) {
+        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_) );
+        return new TryStmt( tryBlock, aststmt, finallyBlock );
+ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) {
+        std::vector<ast::ptr<ast::CatchClause>> aststmt;
+        buildMoveList( catch_, aststmt );
+        ast::CompoundStmt * tryBlock = strict_dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( try_ ) );
+        ast::FinallyClause * finallyBlock = nullptr;
+        if ( finally_ ) {
+                finallyBlock = dynamic_cast<ast::FinallyClause *>( finally_->clause.release() );
+        }
+        return new ast::TryStmt( location,
+                tryBlock,
+                std::move( aststmt ),
+                finallyBlock
+        );
 } // build_try
+Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( body, aststmt );
+        assert( aststmt.size() == 1 );
+        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
+ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        return new ast::CatchClause( location,
+                kind,
+                maybeMoveBuild( decl ),
+                maybeMoveBuild( cond ),
+                buildMoveSingle( body )
+        );
 } // build_catch
+Statement * build_finally( StatementNode * stmt ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        return new FinallyStmt( dynamic_cast< CompoundStmt * >( aststmt.front() ) );
+ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) {
+        return new ast::FinallyClause( location,
+                strict_dynamic_cast<const ast::CompoundStmt *>(
+                        buildMoveSingle( stmt )
+                )
+        );
 } // build_finally
+SuspendStmt * build_suspend( StatementNode * then, SuspendStmt::Type type ) {
+        auto node = new SuspendStmt();
+        node->type = type;
+        list< Statement * > stmts;
+        buildMoveList< Statement, StatementNode >( then, stmts );
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                node->then = dynamic_cast< CompoundStmt * >( stmts.front() );
+        }
+        return node;
+}
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) {
+        return new ast::SuspendStmt( location,
+                strict_dynamic_cast<const ast::CompoundStmt *, nullptr>(
+                        buildMoveOptional( then )
+                ),
+                kind
+        );
+} // build_suspend
+ast::WaitForStmt * build_waitfor( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
+        auto clause = new ast::WaitForClause( location );
+        clause->target = maybeBuild( targetExpr );
+        clause->stmt = maybeMoveBuild( stmt );
+        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
         targetExpr->set_next( nullptr );
         buildMoveList< Expression >( next, target.arguments );
+        buildMoveList( next, clause->target_args );
         delete targetExpr;
+        node->clauses.push_back( WaitForStmt::Clause{
+                target,
+                maybeMoveBuild<Statement >( stmt ),
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+        });
+        return node;
+        existing->clauses.insert( existing->clauses.begin(), clause );
+        return existing;
 } // build_waitfor
+WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
+        WaitForStmt::Target target;
+        target.function = maybeBuild<Expression>( targetExpr );
+        ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
+        targetExpr->set_next( nullptr );
+        buildMoveList< Expression >( next, target.arguments );
+        delete targetExpr;
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
+                std::move( target ),
+                maybeMoveBuild<Statement >( stmt ),
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+        });
+        return node;
+} // build_waitfor
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when ) {
+        auto node = new WaitForStmt();
+        if( timeout ) {
+                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
+                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        } else {
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        } // if
+        return node;
+ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) {
+        existing->else_stmt = maybeMoveBuild( stmt );
+        existing->else_cond = notZeroExpr( maybeMoveBuild( when ) );
+        (void)location;
+        return existing;
+} // build_waitfor_else
+ast::WaitForStmt * build_waitfor_timeout( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
+        existing->timeout_time = maybeMoveBuild( timeout );
+        existing->timeout_stmt = maybeMoveBuild( stmt );
+        existing->timeout_cond = notZeroExpr( maybeMoveBuild( when ) );
+        (void)location;
+        return existing;
 } // build_waitfor_timeout
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_, ExpressionNode * else_when ) {
+        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 ) );
+        return node;
+} // build_waitfor_timeout
+Statement * build_with( ExpressionNode * exprs, StatementNode * stmt ) {
+        list< Expression * > e;
+ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    clause->target = maybeMoveBuild( targetExpr );
+    return new ast::WaitUntilStmt::ClauseNode( clause );
+}
+ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
+}
+ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    clause->target = maybeMoveBuild( timeout );
+    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::TIMEOUT, clause );
+}
+ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
+    ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );
+    retStmt->predicateTree = root;
+    // iterative tree traversal
+    std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal
+    ast::WaitUntilStmt::ClauseNode * currNode = nullptr;
+    ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr;
+    ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout
+    nodeStack.push_back(root);
+    do {
+        currNode = nodeStack.back();
+        nodeStack.pop_back(); // remove node since it will be processed
+        switch (currNode->op) {
+            case ast::WaitUntilStmt::ClauseNode::LEAF:
+                retStmt->clauses.push_back(currNode->leaf);
+                break;
+            case ast::WaitUntilStmt::ClauseNode::ELSE:
+                retStmt->else_stmt = currNode->leaf->stmt
+                    ? ast::deepCopy( currNode->leaf->stmt )
+                    : nullptr;
+                retStmt->else_cond = currNode->leaf->when_cond
+                    ? ast::deepCopy( currNode->leaf->when_cond )
+                    : nullptr;
+                delete currNode->leaf;
+                break;
+            case ast::WaitUntilStmt::ClauseNode::TIMEOUT:
+                retStmt->timeout_time = currNode->leaf->target
+                    ? ast::deepCopy( currNode->leaf->target )
+                    : nullptr;
+                retStmt->timeout_stmt = currNode->leaf->stmt
+                    ? ast::deepCopy( currNode->leaf->stmt )
+                    : nullptr;
+                retStmt->timeout_cond = currNode->leaf->when_cond
+                    ? ast::deepCopy( currNode->leaf->when_cond )
+                    : nullptr;
+                delete currNode->leaf;
+                break;
+            default:
+                nodeStack.push_back( currNode->right ); // process right after left
+                nodeStack.push_back( currNode->left );
+                // Cut else/timeout out of the tree
+                if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) {
+                    if ( lastInternalNode )
+                        lastInternalNode->right = currNode->left;
+                    else    // if not set then root is LEFT_OR
+                        retStmt->predicateTree = currNode->left;
+                    currNode->left = nullptr;
+                    cleanup = currNode;
+                }
+                lastInternalNode = currNode;
+                break;
+        }
+    } while ( !nodeStack.empty() );
+    if ( cleanup ) delete cleanup;
+    return retStmt;
+}
+ast::Stmt * build_with( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Expr>> e;
         buildMoveList( exprs, e );
         Statement * s = maybeMoveBuild<Statement>( stmt );
         return new DeclStmt( new WithStmt( e, s ) );
+        ast::Stmt * s = maybeMoveBuild( stmt );
+        return new ast::DeclStmt( location, new ast::WithStmt( location, std::move( e ), s ) );
 } // build_with
 Statement * build_compound( StatementNode * first ) {
         CompoundStmt * cs = new CompoundStmt();
         buildMoveList( first, cs->get_kids() );
+ast::Stmt * build_compound( const CodeLocation & location, StatementNode * first ) {
+        auto cs = new ast::CompoundStmt( location );
+        buildMoveList( first, cs->kids );
         return cs;
 } // build_compound
 …
 // statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a
 // conical form for code generation.
 StatementNode * maybe_build_compound( StatementNode * first ) {
+StatementNode * maybe_build_compound( const CodeLocation & location, StatementNode * first ) {
         // Optimization: if the control-structure statement is a compound statement, do not wrap it.
         // e.g., if (...) {...} do not wrap the existing compound statement.
+        if ( ! dynamic_cast<CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                CompoundStmt * cs = new CompoundStmt();
+                buildMoveList( first, cs->get_kids() );
+                return new StatementNode( cs );
+        if ( !dynamic_cast<ast::CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                return new StatementNode( build_compound( location, first ) );
         } // if
         return first;
 …
 // Question
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         list< Expression * > out, in;
         list< ConstantExpr * > clob;
+ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
+        std::vector<ast::ptr<ast::Expr>> out, in;
+        std::vector<ast::ptr<ast::ConstantExpr>> clob;
         buildMoveList( output, out );
         buildMoveList( input, in );
         buildMoveList( clobber, clob );
+        return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+        return new ast::AsmStmt( location,
+                is_volatile,
+                maybeMoveBuild( instruction ),
+                std::move( out ),
+                std::move( in ),
+                std::move( clob ),
+                gotolabels ? gotolabels->labels : std::vector<ast::Label>()
+        );
 } // build_asm
+Statement * build_directive( string * directive ) {
+        return new DirectiveStmt( *directive );
+ast::Stmt * build_directive( const CodeLocation & location, string * directive ) {
+        auto stmt = new ast::DirectiveStmt( location, *directive );
+        delete directive;
+        return stmt;
 } // build_directive
 Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
         list< Expression * > expList;
+ast::Stmt * build_mutex( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Expr>> expList;
         buildMoveList( exprs, expList );
         Statement * body = maybeMoveBuild<Statement>( stmt );
         return new MutexStmt( body, expList );
+        ast::Stmt * body = maybeMoveBuild( stmt );
+        return new ast::MutexStmt( location, body, std::move( expList ) );
 } // build_mutex

src/Parser/TypeData.cc

-              r34b4268
+              r24d6572
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:36:52 2022
 // Update Count     : 677
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 13:39:00 2023
+// Update Count     : 680
 //
+#include "TypeData.h"
 #include <cassert>                 // for assert
 #include <ostream>                 // for operator<<, ostream, basic_ostream
+#include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
+#include "AST/Init.hpp"            // for SingleInit, ListInit
+#include "AST/Print.hpp"           // for print
 #include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for maybeClone, maybeBuild, maybeMoveB...
+#include "Parser/ParseNode.h"      // for DeclarationNode, ExpressionNode
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, FunctionDecl
+#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
+#include "SynTree/Initializer.h"   // for SingleInit, Initializer (ptr only)
+#include "SynTree/Statement.h"     // for CompoundStmt, Statement
+#include "SynTree/Type.h"          // for BasicType, Type, Type::ForallList
+#include "TypeData.h"
+#include "Common/utility.h"        // for splice, spliceBegin
+#include "Parser/ExpressionNode.h" // for ExpressionNode
+#include "Parser/StatementNode.h"  // for StatementNode
 class Attribute;
 …
 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;
 …
                 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;
 …
                 enumeration.anon = false;
                 break;
+          case Aggregate:
+                // aggregate = new Aggregate_t;
+                aggregate.kind = AggregateDecl::NoAggregate;
+        case Aggregate:
+                aggregate.kind = ast::AggregateDecl::NoAggregate;
                 aggregate.name = nullptr;
                 aggregate.params = nullptr;
 …
                 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;
 …
                 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 Vtable:
+        case Builtin:
+                // No unique data to initialize.
+                break;
+        case Qualified:
                 qualified.parent = nullptr;
                 qualified.child = nullptr;
 …
         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:
+        case Basic:
+                // No unique data to deconstruct.
+                break;
+        case Array:
                 delete array.dimension;
+                // delete array;
+                break;
+          case Function:
+                break;
+        case Function:
                 delete function.params;
                 delete function.idList;
 …
                 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
 …
         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;
 …
                 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 );
 …
                 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;
 …
                 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 );
 …
                 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 );
 …
                 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 );
 …
 void TypeData::print( ostream &os, int indent ) const {
+        for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
+                if ( qualifiers[i] ) os << Type::QualifiersNames[ i ] << ' ';
+        } // for
+        ast::print( os, qualifiers );
         if ( forall ) {
 …
         switch ( kind ) {
           case Basic:
+        case Basic:
                 if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
                 if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
 …
                 if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " ";
                 break;
           case Pointer:
+        case Pointer:
                 os << "pointer ";
                 if ( base ) {
 …
                 } // if
                 break;
           case Reference:
+        case Reference:
                 os << "reference ";
                 if ( base ) {
 …
                 } // if
                 break;
           case Array:
+        case Array:
                 if ( array.isStatic ) {
                         os << "static ";
 …
                 } // if
                 break;
           case Function:
+        case Function:
                 os << "function" << endl;
                 if ( function.params ) {
 …
                 } // if
                 break;
           case Aggregate:
                 os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
+        case Aggregate:
+                os << ast::AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters" << endl;
 …
                 } // if
                 break;
           case AggregateInst:
+        case AggregateInst:
                 if ( aggInst.aggregate ) {
                         os << "instance of " ;
 …
                 } // if
                 break;
           case Enum:
                 os << "enumeration ";
+        case Enum:
+                os << "enumeration " << *enumeration.name << endl;;
                 if ( enumeration.constants ) {
                         os << "with constants" << endl;
 …
                 } // if
                 break;
           case EnumConstant:
+        case EnumConstant:
                 os << "enumeration constant ";
                 break;
           case Symbolic:
+        case Symbolic:
                 if ( symbolic.isTypedef ) {
                         os << "typedef definition ";
 …
                 } // if
                 break;
           case SymbolicInst:
+        case SymbolicInst:
                 os << *symbolic.name;
                 if ( symbolic.actuals ) {
 …
                 } // if
                 break;
           case Tuple:
+        case Tuple:
                 os << "tuple ";
                 if ( tuple ) {
 …
                 } // if
                 break;
           case Basetypeof:
+        case Basetypeof:
                 os << "base-";
                 #if defined(__GNUC__) && __GNUC__ >= 7
 …
                 #endif
                 // FALL THROUGH
           case Typeof:
+        case Typeof:
                 os << "type-of expression ";
                 if ( typeexpr ) {
 …
                 } // 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 );
 …
 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
 …
+template< typename ForallList >
+void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
+        buildList( firstNode, outputList );
+void buildForall(
+                const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::TypeInstType>> &outputList ) {
+        {
+                std::vector<ast::ptr<ast::Type>> tmpList;
+                buildTypeList( firstNode, tmpList );
+                for ( auto tmp : tmpList ) {
+                        outputList.emplace_back(
+                                strict_dynamic_cast<const ast::TypeInstType *>(
+                                        tmp.release() ) );
+                }
+        }
         auto n = firstNode;
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
+                TypeDecl * td = static_cast<TypeDecl *>(*i);
+                if ( n->variable.tyClass == TypeDecl::Otype ) {
+                        // add assertion parameters to `type' tyvars in reverse order
+                        // add dtor:  void ^?{}(T *)
+                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
+                        // add copy ctor:  void ?{}(T *, T)
+                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
+                        // add default ctor:  void ?{}(T *)
+                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
+                        // add assignment operator:  T * ?=?(T *, T)
+                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
+                } // if
+        for ( auto i = outputList.begin() ;
+                        i != outputList.end() ;
+                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                // Only the object type class adds additional assertions.
+                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
+                        continue;
+                }
+                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
+                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
+                auto mutTypeDecl = ast::mutate( td );
+                const CodeLocation & location = mutTypeDecl->location;
+                *i = mutTypeDecl;
+                // add assertion parameters to `type' tyvars in reverse order
+                // add assignment operator:  T * ?=?(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?=?",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add default ctor:  void ?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add copy ctor:  void ?{}(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        i->get(),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add dtor:  void ^?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "^?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( i->get() ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                spliceBegin( mutTypeDecl->assertions, newAssertions );
+        } // for
+}
+void buildForall(
+                const DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::TypeDecl>> &outputForall ) {
+        buildList( firstNode, outputForall );
+        auto n = firstNode;
+        for ( auto i = outputForall.begin() ;
+                        i != outputForall.end() ;
+                        ++i, n = (DeclarationNode*)n->get_next() ) {
+                // Only the object type class adds additional assertions.
+                if ( n->variable.tyClass != ast::TypeDecl::Otype ) {
+                        continue;
+                }
+                ast::TypeDecl const * td = i->strict_as<ast::TypeDecl>();
+                std::vector<ast::ptr<ast::DeclWithType>> newAssertions;
+                auto mutTypeDecl = ast::mutate( td );
+                const CodeLocation & location = mutTypeDecl->location;
+                *i = mutTypeDecl;
+                // add assertion parameters to `type' tyvars in reverse order
+                // add assignment operator:  T * ?=?(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?=?",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType( new ast::TypeInstType( td->name, *i ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add default ctor:  void ?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( td->name, i->get() ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add copy ctor:  void ?{}(T *, T)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( td->name, *i ) ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::TypeInstType( td->name, *i ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                // add dtor:  void ^?{}(T *)
+                newAssertions.push_back( new ast::FunctionDecl(
+                        location,
+                        "^?{}",
+                        {}, // forall
+                        {}, // assertions
+                        {
+                                new ast::ObjectDecl(
+                                        location,
+                                        "",
+                                        new ast::ReferenceType(
+                                                new ast::TypeInstType( i->get() )
+                                        ),
+                                        (ast::Init *)nullptr,
+                                        ast::Storage::Classes(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr
+                                ),
+                        }, // params
+                        {}, // returns
+                        (ast::CompoundStmt *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+                spliceBegin( mutTypeDecl->assertions, newAssertions );
         } // for
 } // buildForall
 Type * typebuild( const TypeData * td ) {
+ast::Type * typebuild( const TypeData * td ) {
         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:
+                return new ast::BasicType(
+                        ast::BasicType::SignedInt,
+                        buildQualifiers( td )
+                );
+        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:
                 return buildFunction( td );
           case TypeData::AggregateInst:
+        case TypeData::Function:
+                return buildFunctionType( td );
+        case TypeData::AggregateInst:
                 return buildAggInst( td );
           case TypeData::EnumConstant:
                 return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
+        case TypeData::EnumConstant:
+                return new ast::EnumInstType( "", buildQualifiers( td ) );
+        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:
                         return new ZeroType( noQualifiers );
                   case DeclarationNode::One:
                         return new OneType( noQualifiers );
                   default:
                         return new VarArgsType( buildQualifiers( td ) );
+                case DeclarationNode::Zero:
+                        return new ast::ZeroType();
+                case DeclarationNode::One:
+                        return new ast::OneType();
+                default:
+                        return new ast::VarArgsType( buildQualifiers( td ) );
                 } // switch
+          case TypeData::GlobalScope:
+                return new GlobalScopeType();
+          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::GlobalScope:
+                return new ast::GlobalScopeType();
+        case TypeData::Qualified:
+                return new ast::QualifiedType(
+                        typebuild( td->qualified.parent ),
+                        typebuild( td->qualified.child ),
+                        buildQualifiers( td )
+                );
+        case TypeData::Symbolic:
+        case TypeData::Enum:
+        case TypeData::Aggregate:
                 assert( false );
         } // switch
 …
         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 );
 …
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
+ast::CV::Qualifiers buildQualifiers( const TypeData * td ) {
         return td->qualifiers;
 } // buildQualifiers
 …
 } // genTSError
 Type * buildBasicType( const TypeData * td ) {
         BasicType::Kind ret;
+ast::Type * buildBasicType( const TypeData * td ) {
+        ast::BasicType::Kind ret;
         switch ( td->basictype ) {
           case DeclarationNode::Void:
+        case DeclarationNode::Void:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 return new VoidType( buildQualifiers( td ) );
                 break;
           case DeclarationNode::Bool:
+                return new ast::VoidType( buildQualifiers( td ) );
+                break;
+        case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                 } // if
                 ret = BasicType::Bool;
                 break;
           case DeclarationNode::Char:
+                ret = ast::BasicType::Bool;
+                break;
+        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
                 // either signed char or unsigned char.
                 static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
+                static ast::BasicType::Kind chartype[] = { ast::BasicType::SignedChar, ast::BasicType::UnsignedChar, ast::BasicType::Char };
                 if ( td->length != DeclarationNode::NoLength ) {
 …
                 break;
           case DeclarationNode::Int:
                 static BasicType::Kind inttype[2][4] = {
                         { BasicType::ShortSignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt },
                         { BasicType::ShortUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt },
+        case DeclarationNode::Int:
+                static ast::BasicType::Kind inttype[2][4] = {
+                        { ast::BasicType::ShortSignedInt, ast::BasicType::LongSignedInt, ast::BasicType::LongLongSignedInt, ast::BasicType::SignedInt },
+                        { ast::BasicType::ShortUnsignedInt, ast::BasicType::LongUnsignedInt, ast::BasicType::LongLongUnsignedInt, ast::BasicType::UnsignedInt },
                 };
           Integral: ;
+        Integral: ;
                 if ( td->signedness == DeclarationNode::NoSignedness ) {
                         const_cast<TypeData *>(td)->signedness = DeclarationNode::Signed;
 …
                 break;
           case DeclarationNode::Int128:
                 ret = td->signedness == DeclarationNode::Unsigned ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+        case DeclarationNode::Int128:
+                ret = td->signedness == DeclarationNode::Unsigned ? ast::BasicType::UnsignedInt128 : ast::BasicType::SignedInt128;
                 if ( td->length != DeclarationNode::NoLength ) {
                         genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
 …
                 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:
                 static BasicType::Kind floattype[2][12] = {
                         { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex, },
                         { BasicType::Float, BasicType::Double, BasicType::LongDouble, BasicType::uuFloat80, BasicType::uuFloat128, BasicType::uFloat16, BasicType::uFloat32, BasicType::uFloat32x, BasicType::uFloat64, BasicType::uFloat64x, BasicType::uFloat128, BasicType::uFloat128x, },
+        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 ast::BasicType::Kind floattype[2][12] = {
+                        { ast::BasicType::FloatComplex, ast::BasicType::DoubleComplex, ast::BasicType::LongDoubleComplex, (ast::BasicType::Kind)-1, (ast::BasicType::Kind)-1, ast::BasicType::uFloat16Complex, ast::BasicType::uFloat32Complex, ast::BasicType::uFloat32xComplex, ast::BasicType::uFloat64Complex, ast::BasicType::uFloat64xComplex, ast::BasicType::uFloat128Complex, ast::BasicType::uFloat128xComplex, },
+                        { ast::BasicType::Float, ast::BasicType::Double, ast::BasicType::LongDouble, ast::BasicType::uuFloat80, ast::BasicType::uuFloat128, ast::BasicType::uFloat16, ast::BasicType::uFloat32, ast::BasicType::uFloat32x, ast::BasicType::uFloat64, ast::BasicType::uFloat64x, ast::BasicType::uFloat128, ast::BasicType::uFloat128x, },
                 };
           FloatingPoint: ;
+        FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
 …
                 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 ) {
 …
                 const_cast<TypeData *>(td)->basictype = DeclarationNode::Int;
                 goto Integral;
           default:
                 assertf( false, "unknown basic type" );
+        default:
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
+        BasicType * bt = new BasicType( buildQualifiers( td ), ret );
+        buildForall( td->forall, bt->get_forall() );
+        ast::BasicType * bt = new ast::BasicType( ret, buildQualifiers( td ) );
         return bt;
 } // buildBasicType
 PointerType * buildPointer( const TypeData * td ) {
         PointerType * pt;
+ast::PointerType * buildPointer( const TypeData * td ) {
+        ast::PointerType * pt;
         if ( td->base ) {
+                pt = new PointerType( buildQualifiers( td ), typebuild( td->base ) );
+                pt = new ast::PointerType(
+                        typebuild( td->base ),
+                        buildQualifiers( td )
+                );
         } else {
+                pt = new PointerType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                pt = new ast::PointerType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, pt->get_forall() );
         return pt;
 } // buildPointer
 ArrayType * buildArray( const TypeData * td ) {
         ArrayType * at;
+ast::ArrayType * buildArray( const TypeData * td ) {
+        ast::ArrayType * at;
         if ( td->base ) {
+                at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ),
+                                                        td->array.isVarLen, td->array.isStatic );
+                at = new ast::ArrayType(
+                        typebuild( td->base ),
+                        maybeBuild( td->array.dimension ),
+                        td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
+                        td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
+                        buildQualifiers( td )
+                );
         } else {
+                at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ),
+                                                        maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic );
+                at = new ast::ArrayType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        maybeBuild( td->array.dimension ),
+                        td->array.isVarLen ? ast::VariableLen : ast::FixedLen,
+                        td->array.isStatic ? ast::StaticDim : ast::DynamicDim,
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, at->get_forall() );
         return at;
 } // buildArray
 ReferenceType * buildReference( const TypeData * td ) {
         ReferenceType * rt;
+ast::ReferenceType * buildReference( const TypeData * td ) {
+        ast::ReferenceType * rt;
         if ( td->base ) {
+                rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) );
+                rt = new ast::ReferenceType(
+                        typebuild( td->base ),
+                        buildQualifiers( td )
+                );
         } else {
+                rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                rt = new ast::ReferenceType(
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        buildQualifiers( td )
+                );
         } // if
-        buildForall( td->forall, rt->get_forall() );
         return rt;
 } // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::AggregateDecl * buildAggregate( const TypeData * td, std::vector<ast::ptr<ast::Attribute>> attributes, ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
         AggregateDecl * at;
+        ast::AggregateDecl * at;
         switch ( td->aggregate.kind ) {
+          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:
+                at = new UnionDecl( *td->aggregate.name, attributes, linkage );
+                buildForall( td->aggregate.params, at->get_parameters() );
+                break;
+          case AggregateDecl::Trait:
+                at = new TraitDecl( *td->aggregate.name, attributes, linkage );
+                buildList( td->aggregate.params, at->get_parameters() );
+                break;
+          default:
+        case ast::AggregateDecl::Struct:
+        case ast::AggregateDecl::Coroutine:
+        case ast::AggregateDecl::Exception:
+        case ast::AggregateDecl::Generator:
+        case ast::AggregateDecl::Monitor:
+        case ast::AggregateDecl::Thread:
+                at = new ast::StructDecl( td->location,
+                        *td->aggregate.name,
+                        td->aggregate.kind,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildForall( td->aggregate.params, at->params );
+                break;
+        case ast::AggregateDecl::Union:
+                at = new ast::UnionDecl( td->location,
+                        *td->aggregate.name,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildForall( td->aggregate.params, at->params );
+                break;
+        case ast::AggregateDecl::Trait:
+                at = new ast::TraitDecl( td->location,
+                        *td->aggregate.name,
+                        std::move( attributes ),
+                        linkage
+                );
+                buildList( td->aggregate.params, at->params );
+                break;
+        default:
                 assert( false );
         } // switch
         buildList( td->aggregate.fields, at->get_members() );
+        buildList( td->aggregate.fields, at->members );
         at->set_body( td->aggregate.body );
 …
+ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::BaseInstType * buildComAggInst(
+                const TypeData * type,
+                std::vector<ast::ptr<ast::Attribute>> && attributes,
+                ast::Linkage::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 ) {
+                        ast::EnumDecl * typedecl =
+                                buildEnum( type, std::move( attributes ), linkage );
+                        return new ast::EnumInstType(
+                                typedecl,
+                                buildQualifiers( type )
+                        );
+                } else {
+                        return new ast::EnumInstType(
+                                *type->enumeration.name,
+                                buildQualifiers( type )
+                        );
+                } // if
+                break;
+        case TypeData::Aggregate:
+                if ( type->aggregate.body ) {
+                        ast::AggregateDecl * typedecl =
+                                buildAggregate( type, std::move( attributes ), linkage );
+                        switch ( type->aggregate.kind ) {
+                        case ast::AggregateDecl::Struct:
+                        case ast::AggregateDecl::Coroutine:
+                        case ast::AggregateDecl::Monitor:
+                        case ast::AggregateDecl::Thread:
+                                return new ast::StructInstType(
+                                        strict_dynamic_cast<ast::StructDecl *>( typedecl ),
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Union:
+                                return new ast::UnionInstType(
+                                        strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Trait:
+                                assert( false );
+                                break;
+                        default:
+                                assert( false );
+                        } // switch
+                } else {
+                        switch ( type->aggregate.kind ) {
+                        case ast::AggregateDecl::Struct:
+                        case ast::AggregateDecl::Coroutine:
+                        case ast::AggregateDecl::Monitor:
+                        case ast::AggregateDecl::Thread:
+                                return new ast::StructInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Union:
+                                return new ast::UnionInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        case ast::AggregateDecl::Trait:
+                                return new ast::TraitInstType(
+                                        *type->aggregate.name,
+                                        buildQualifiers( type )
+                                );
+                        default:
+                                assert( false );
+                        } // switch
+                        break;
+                } // if
+                break;
+        default:
                 assert( false );
         } // switch
+        assert( false );
 } // buildAggInst
 ReferenceToType * buildAggInst( const TypeData * td ) {
+ast::BaseInstType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
+        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
+        ReferenceToType * ret = nullptr;
+        ast::BaseInstType * ret = nullptr;
         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 ast::EnumInstType(
+                        *type->enumeration.name,
+                        buildQualifiers( type )
+                );
+        case TypeData::Aggregate:
+                switch ( type->aggregate.kind ) {
+                case ast::AggregateDecl::Struct:
+                case ast::AggregateDecl::Coroutine:
+                case ast::AggregateDecl::Monitor:
+                case ast::AggregateDecl::Thread:
+                        ret = new ast::StructInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                case ast::AggregateDecl::Union:
+                        ret = new ast::UnionInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                case ast::AggregateDecl::Trait:
+                        ret = new ast::TraitInstType(
+                                *type->aggregate.name,
+                                buildQualifiers( type )
+                        );
+                        break;
+                default:
+                        assert( false );
+                } // switch
+                break;
+        default:
                 assert( false );
         } // switch
+        ret->set_hoistType( td->aggInst.hoistType );
+        buildList( td->aggInst.params, ret->get_parameters() );
+        buildForall( td->forall, ret->get_forall() );
+        ret->hoistType = td->aggInst.hoistType;
+        buildList( td->aggInst.params, ret->params );
         return ret;
 } // buildAggInst
+NamedTypeDecl * buildSymbolic( const TypeData * td, std::list< Attribute * > attributes, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
+ast::NamedTypeDecl * buildSymbolic(
+                const TypeData * td,
+                std::vector<ast::ptr<ast::Attribute>> attributes,
+                const std::string & name,
+                ast::Storage::Classes scs,
+                ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
+        ast::NamedTypeDecl * ret;
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
+                ret = new TypedefDecl( name, td->location, scs, typebuild( td->base ), linkage );
+                ret = new ast::TypedefDecl(
+                        td->location,
+                        name,
+                        scs,
+                        typebuild( td->base ),
+                        linkage
+                );
         } else {
+                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
+                ret = new ast::TypeDecl(
+                        td->location,
+                        name,
+                        scs,
+                        typebuild( td->base ),
+                        ast::TypeDecl::Dtype,
+                        true
+                );
         } // if
         buildList( td->symbolic.assertions, ret->get_assertions() );
         ret->base->attributes.splice( ret->base->attributes.end(), attributes );
+        buildList( td->symbolic.assertions, ret->assertions );
+        splice( ret->base.get_and_mutate()->attributes, attributes );
         return ret;
 } // buildSymbolic
+EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
+ast::EnumDecl * buildEnum(
+                const TypeData * td,
+                std::vector<ast::ptr<ast::Attribute>> && attributes,
+                ast::Linkage::Spec linkage ) {
         assert( td->kind == TypeData::Enum );
+        Type * baseType = td->base ? typebuild(td->base) : nullptr;
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, td->enumeration.typed, linkage, baseType );
+        buildList( td->enumeration.constants, ret->get_members() );
+        list< Declaration * >::iterator members = ret->get_members().begin();
+        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? EnumDecl::EnumHiding::Hide : EnumDecl::EnumHiding::Visible;
+        ast::Type * baseType = td->base ? typebuild(td->base) : nullptr;
+        ast::EnumDecl * ret = new ast::EnumDecl(
+                td->location,
+                *td->enumeration.name,
+                td->enumeration.typed,
+                std::move( attributes ),
+                linkage,
+                baseType
+        );
+        buildList( td->enumeration.constants, ret->members );
+        auto members = ret->members.begin();
+        ret->hide = td->enumeration.hiding == EnumHiding::Hide ? ast::EnumDecl::EnumHiding::Hide : ast::EnumDecl::EnumHiding::Visible;
         for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->enumInLine ) {
 …
                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
                 } else if ( cur->has_enumeratorValue() ) {
+                        ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) );
+                        ast::Decl * member = members->get_and_mutate();
+                        ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
+                        object->init = new ast::SingleInit(
+                                td->location,
+                                maybeMoveBuild( cur->consume_enumeratorValue() ),
+                                ast::NoConstruct
+                        );
                 } else if ( !cur->initializer ) {
                         if ( baseType && (!dynamic_cast<BasicType *>(baseType) || !dynamic_cast<BasicType *>(baseType)->isWholeNumber())) {
+                        if ( baseType && (!dynamic_cast<ast::BasicType *>(baseType) || !dynamic_cast<ast::BasicType *>(baseType)->isInteger())) {
                                 SemanticError( td->location, "Enumerators of an non-integer typed enum must be explicitly initialized." );
+                        }
 …
                 // if
         } // for
         ret->set_body( td->enumeration.body );
+        ret->body = td->enumeration.body;
         return ret;
 } // buildEnum
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
+ast::TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
+        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
+        buildList( td->symbolic.actuals, ret->get_parameters() );
+        buildForall( td->forall, ret->get_forall() );
+        ast::TypeInstType * ret = new ast::TypeInstType(
+                *td->symbolic.name,
+                ast::TypeDecl::Dtype,
+                buildQualifiers( td )
+        );
+        buildList( td->symbolic.actuals, ret->params );
         return ret;
 } // buildSymbolicInst
 TupleType * buildTuple( const TypeData * td ) {
+ast::TupleType * buildTuple( const TypeData * td ) {
         assert( td->kind == TypeData::Tuple );
         std::list< Type * > types;
+        std::vector<ast::ptr<ast::Type>> types;
         buildTypeList( td->tuple, types );
+        TupleType * ret = new TupleType( buildQualifiers( td ), types );
+        buildForall( td->forall, ret->get_forall() );
+        ast::TupleType * ret = new ast::TupleType(
+                std::move( types ),
+                buildQualifiers( td )
+        );
         return ret;
 } // buildTuple
 TypeofType * buildTypeof( const TypeData * td ) {
+ast::TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
         assert( td->typeexpr );
+        // assert( td->typeexpr->expr );
+        return new TypeofType{ buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
+        return new ast::TypeofType(
+                td->typeexpr->build(),
+                td->kind == TypeData::Typeof
+                        ? ast::TypeofType::Typeof : ast::TypeofType::Basetypeof,
+                buildQualifiers( td )
+        );
 } // buildTypeof
 VTableType * buildVtable( const TypeData * td ) {
+ast::VTableType * buildVtable( const TypeData * td ) {
         assert( td->base );
+        return new VTableType{ buildQualifiers( td ), typebuild( td->base ) };
+        return new ast::VTableType(
+                typebuild( td->base ),
+                buildQualifiers( td )
+        );
 } // buildVtable
+Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+ast::FunctionDecl * buildFunctionDecl(
+                const TypeData * td,
+                const string &name,
+                ast::Storage::Classes scs,
+                ast::Function::Specs funcSpec,
+                ast::Linkage::Spec linkage,
+                ast::Expr * asmName,
+                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
+        assert( td->kind == TypeData::Function );
+        // For some reason FunctionDecl takes a bool instead of an ArgumentFlag.
+        bool isVarArgs = !td->function.params || td->function.params->hasEllipsis;
+        ast::CV::Qualifiers cvq = buildQualifiers( td );
+        std::vector<ast::ptr<ast::TypeDecl>> forall;
+        std::vector<ast::ptr<ast::DeclWithType>> assertions;
+        std::vector<ast::ptr<ast::DeclWithType>> params;
+        std::vector<ast::ptr<ast::DeclWithType>> returns;
+        buildList( td->function.params, params );
+        buildForall( td->forall, forall );
+        // Functions do not store their assertions there anymore.
+        for ( ast::ptr<ast::TypeDecl> & type_param : forall ) {
+                auto mut = type_param.get_and_mutate();
+                splice( assertions, mut->assertions );
+        }
+        if ( td->base ) {
+                switch ( td->base->kind ) {
+                case TypeData::Tuple:
+                        buildList( td->base->tuple, returns );
+                        break;
+                default:
+                        returns.push_back( dynamic_cast<ast::DeclWithType *>(
+                                buildDecl(
+                                        td->base,
+                                        "",
+                                        ast::Storage::Classes(),
+                                        (ast::Expr *)nullptr, // bitfieldWidth
+                                        ast::Function::Specs(),
+                                        ast::Linkage::Cforall,
+                                        (ast::Expr *)nullptr // asmName
+                                )
+                        ) );
+                } // switch
+        } else {
+                returns.push_back( new ast::ObjectDecl(
+                        td->location,
+                        "",
+                        new ast::BasicType( ast::BasicType::SignedInt ),
+                        (ast::Init *)nullptr,
+                        ast::Storage::Classes(),
+                        ast::Linkage::Cforall
+                ) );
+        } // if
+        ast::Stmt * stmt = maybeBuild( td->function.body );
+        ast::CompoundStmt * body = dynamic_cast<ast::CompoundStmt *>( stmt );
+        ast::FunctionDecl * decl = new ast::FunctionDecl( td->location,
+                name,
+                std::move( forall ),
+                std::move( assertions ),
+                std::move( params ),
+                std::move( returns ),
+                body,
+                scs,
+                linkage,
+                std::move( attributes ),
+                funcSpec,
+                (isVarArgs) ? ast::VariableArgs : ast::FixedArgs
+        );
+        buildList( td->function.withExprs, decl->withExprs );
+        decl->asmName = asmName;
+        // This may be redundant on a declaration.
+        decl->type.get_and_mutate()->qualifiers = cvq;
+        return decl;
+} // buildFunctionDecl
+ast::Decl * buildDecl(
+                const TypeData * td,
+                const string &name,
+                ast::Storage::Classes scs,
+                ast::Expr * bitfieldWidth,
+                ast::Function::Specs funcSpec,
+                ast::Linkage::Spec linkage,
+                ast::Expr * asmName,
+                ast::Init * init,
+                std::vector<ast::ptr<ast::Attribute>> && attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
 …
                 } // if
+                FunctionDecl * decl;
+                Statement * stmt = maybeBuild<Statement>( td->function.body );
+                CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
+                decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
+                buildList( td->function.withExprs, decl->withExprs );
+                return decl->set_asmName( asmName );
+                return buildFunctionDecl(
+                        td, name, scs, funcSpec, linkage,
+                        asmName, std::move( attributes ) );
         } else if ( td->kind == TypeData::Aggregate ) {
                 return buildAggregate( td, attributes, linkage );
+                return buildAggregate( td, std::move( attributes ), linkage );
         } else if ( td->kind == TypeData::Enum ) {
                 return buildEnum( td, attributes, linkage );
+                return buildEnum( td, std::move( attributes ), linkage );
         } else if ( td->kind == TypeData::Symbolic ) {
                 return buildSymbolic( td, attributes, name, scs, linkage );
+                return buildSymbolic( td, std::move( attributes ), name, scs, linkage );
         } else {
+                return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
+                auto ret = new ast::ObjectDecl( td->location,
+                        name,
+                        typebuild( td ),
+                        init,
+                        scs,
+                        linkage,
+                        bitfieldWidth,
+                        std::move( attributes )
+                );
+                ret->asmName = asmName;
+                return ret;
         } // if
         return nullptr;
 …
 FunctionType * buildFunction( const TypeData * td ) {
+ast::FunctionType * buildFunctionType( const TypeData * td ) {
         assert( td->kind == TypeData::Function );
+        FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
+        buildList( td->function.params, ft->parameters );
+        ast::FunctionType * ft = new ast::FunctionType(
+                ( !td->function.params || td->function.params->hasEllipsis )
+                        ? ast::VariableArgs : ast::FixedArgs,
+                buildQualifiers( td )
+        );
+        buildTypeList( td->function.params, ft->params );
         buildForall( td->forall, ft->forall );
         if ( td->base ) {
                 switch ( td->base->kind ) {
                   case TypeData::Tuple:
                         buildList( td->base->tuple, ft->returnVals );
+                case TypeData::Tuple:
+                        buildTypeList( td->base->tuple, ft->returns );
                         break;
+                  default:
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
+                default:
+                        ft->returns.push_back( typebuild( td->base ) );
+                        break;
                 } // switch
         } else {
+                ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                ft->returns.push_back(
+                        new ast::BasicType( ast::BasicType::SignedInt ) );
         } // if
         return ft;
 } // buildFunction
+} // buildFunctionType
 …
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type
+                                param->attributes.splice( param->attributes.end(), decl->attributes ); // copy and reset attributes from declaration to parameter
+                                // Copy and reset attributes from declaration to parameter:
+                                splice( param->attributes, decl->attributes );
                         } // if
                 } // for

src/Parser/TypeData.h

-              r34b4268
+              r24d6572
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 10 22:18:49 2022
 // Update Count     : 203
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Mar  1 10:44:00 2023
+// Update Count     : 206
 //
 #pragma once
 #include <iosfwd>                                                                               // for ostream
 #include <list>                                                                                 // for list
 #include <string>                                                                               // for string
+#include <iosfwd>                                   // for ostream
+#include <list>                                     // for list
+#include <string>                                   // for string
+#include "ParseNode.h"                                                                  // for DeclarationNode, DeclarationNode::Ag...
+#include "SynTree/LinkageSpec.h"                                                // for Spec
+#include "SynTree/Type.h"                                                               // for Type, ReferenceToType (ptr only)
+#include "SynTree/SynTree.h"                                                    // for Visitor Nodes
+#include "AST/Type.hpp"                             // for Type
+#include "DeclarationNode.h"                        // for DeclarationNode
 struct TypeData {
 …
         struct Aggregate_t {
                 AggregateDecl::Aggregate kind;
+                ast::AggregateDecl::Aggregate kind;
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;
 …
                 bool body;
                 bool anon;
                 bool tagged;
                 const std::string * parent = nullptr;
 …
         DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
         Type::Qualifiers qualifiers;
+        ast::CV::Qualifiers qualifiers;
         DeclarationNode * forall = nullptr;
 …
 };
 Type * typebuild( const TypeData * );
+ast::Type * typebuild( const TypeData * );
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel = true );
+Type::Qualifiers buildQualifiers( const TypeData * td );
+Type * buildBasicType( const TypeData * );
+PointerType * buildPointer( const TypeData * );
+ArrayType * buildArray( const TypeData * );
+ReferenceType * buildReference( const TypeData * );
+AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
+ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );
+ReferenceToType * buildAggInst( const TypeData * );
+TypeDecl * buildVariable( const TypeData * );
+EnumDecl * buildEnum( const TypeData *, std::list< Attribute * >, LinkageSpec::Spec );
+TypeInstType * buildSymbolicInst( const TypeData * );
+TupleType * buildTuple( const TypeData * );
+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 * >() );
+FunctionType * buildFunction( const TypeData * );
+Declaration * addEnumBase( Declaration *, const TypeData * );
+ast::CV::Qualifiers buildQualifiers( const TypeData * td );
+ast::Type * buildBasicType( const TypeData * );
+ast::PointerType * buildPointer( const TypeData * );
+ast::ArrayType * buildArray( const TypeData * );
+ast::ReferenceType * buildReference( const TypeData * );
+ast::AggregateDecl * buildAggregate( const TypeData *, std::vector<ast::ptr<ast::Attribute>> );
+ast::BaseInstType * buildComAggInst( const TypeData *, std::vector<ast::ptr<ast::Attribute>> && attributes, ast::Linkage::Spec linkage );
+ast::BaseInstType * buildAggInst( const TypeData * );
+ast::TypeDecl * buildVariable( const TypeData * );
+ast::EnumDecl * buildEnum( const TypeData *, std::vector<ast::ptr<ast::Attribute>> &&, ast::Linkage::Spec );
+ast::TypeInstType * buildSymbolicInst( const TypeData * );
+ast::TupleType * buildTuple( const TypeData * );
+ast::TypeofType * buildTypeof( const TypeData * );
+ast::VTableType * buildVtable( const TypeData * );
+ast::Decl * buildDecl(
+        const TypeData *, const std::string &, ast::Storage::Classes, ast::Expr *,
+        ast::Function::Specs funcSpec, ast::Linkage::Spec, ast::Expr * asmName,
+        ast::Init * init = nullptr, std::vector<ast::ptr<ast::Attribute>> && attributes = std::vector<ast::ptr<ast::Attribute>>() );
+ast::FunctionType * buildFunctionType( const TypeData * );
+ast::Decl * addEnumBase( Declaration *, const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );

src/Parser/TypedefTable.cc

-              r34b4268
+              r24d6572
 #include "TypedefTable.h"
+#include <cassert>                                                                              // for assert
+#include <iostream>
+#include <cassert>                                // for assert
+#include <string>                                 // for string
+#include <iostream>                               // for iostream
+#include "ExpressionNode.h"                       // for LabelNode
+#include "ParserTypes.h"                          // for Token
+#include "StatementNode.h"                        // for CondCtl, ForCtrl
+// This (generated) header must come late as it is missing includes.
+#include "parser.hh"              // for IDENTIFIER, TYPEDEFname, TYPEGENname
 using namespace std;
 #if 0
 #define debugPrint( code ) code
+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:
+                cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
+                abort();
+        } // switch
+} // kindName
 #else
 #define debugPrint( code )
 #endif
-using namespace std;                                                                    // string, iostream
-debugPrint(
-        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:
-                        cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl;
-                        abort();
-                } // switch
-        } // kindName
-);
 TypedefTable::~TypedefTable() {
 …
                 typedefTable.addToEnclosingScope( name, kind, "MTD" );
         } // if
+} // TypedefTable::makeTypedef
+void TypedefTable::makeTypedef( const string & name ) {
+        return makeTypedef( name, TYPEDEFname );
 } // TypedefTable::makeTypedef

src/Parser/TypedefTable.h

-              r34b4268
+              r24d6572
 #include "Common/ScopedMap.h"                                                   // for ScopedMap
-#include "ParserTypes.h"
-#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname
 class TypedefTable {
         struct Note { size_t level; bool forall; };
         typedef ScopedMap< std::string, int, Note > KindTable;
         KindTable kindTable;
+        KindTable kindTable;
         unsigned int level = 0;
   public:
 …
         bool existsCurr( const std::string & identifier ) const;
         int isKind( const std::string & identifier ) const;
+        void makeTypedef( const std::string & name, int kind = TYPEDEFname );
+        void makeTypedef( const std::string & name, int kind );
+        void makeTypedef( const std::string & name );
         void addToScope( const std::string & identifier, int kind, const char * );
         void addToEnclosingScope( const std::string & identifier, int kind, const char * );

src/Parser/lex.ll

-              r34b4268
+              r24d6572
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Thu Oct 13 20:46:04 2022
  * Update Count     : 764
+ * Last Modified On : Tue May  2 08:45:21 2023
+ * Update Count     : 769
  */
 …
 // line-number directives) and C/C++ style comments, which are ignored.
 //**************************** Includes and Defines ****************************
+// *************************** Includes and Defines ****************************
 #ifdef __clang__
 …
 #include "config.h"                                                                             // configure info
+#include "DeclarationNode.h"                            // for DeclarationNode
+#include "ExpressionNode.h"                             // for LabelNode
+#include "InitializerNode.h"                            // for InitializerNode
 #include "ParseNode.h"
+#include "ParserTypes.h"                                // for Token
+#include "StatementNode.h"                              // for CondCtl, ForCtrl
 #include "TypedefTable.h"
+// This (generated) header must come late as it is missing includes.
+#include "parser.hh"                                    // generated info
 string * build_postfix_name( string * name );
 …
 __alignof               { KEYWORD_RETURN(ALIGNOF); }                    // GCC
 __alignof__             { KEYWORD_RETURN(ALIGNOF); }                    // GCC
+and                             { QKEYWORD_RETURN(WAND); }                              // CFA
 asm                             { KEYWORD_RETURN(ASM); }
 __asm                   { KEYWORD_RETURN(ASM); }                                // GCC
 …
 enable                  { KEYWORD_RETURN(ENABLE); }                             // CFA
 enum                    { KEYWORD_RETURN(ENUM); }
+exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
 __extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
-exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
 extern                  { KEYWORD_RETURN(EXTERN); }
 fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
 …
 vtable                  { KEYWORD_RETURN(VTABLE); }                             // CFA
 waitfor                 { KEYWORD_RETURN(WAITFOR); }                    // CFA
+waituntil               { KEYWORD_RETURN(WAITUNTIL); }                  // CFA
 when                    { KEYWORD_RETURN(WHEN); }                               // CFA
 while                   { KEYWORD_RETURN(WHILE); }
 …
         SemanticErrorThrow = true;
         cerr << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
                  << ": " << ErrorHelpers::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
+                 << ": " << ErrorHelpers::error_str() << errmsg << " before token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
+}

src/Parser/module.mk

-              r34b4268
+              r24d6572
 SRC += \
        Parser/DeclarationNode.cc \
+       Parser/DeclarationNode.h \
        Parser/ExpressionNode.cc \
+       Parser/ExpressionNode.h \
        Parser/InitializerNode.cc \
+       Parser/InitializerNode.h \
        Parser/lex.ll \
        Parser/ParseNode.cc \
 …
        Parser/parserutility.cc \
        Parser/parserutility.h \
+       Parser/RunParser.cpp \
+       Parser/RunParser.hpp \
        Parser/StatementNode.cc \
+       Parser/StatementNode.h \
        Parser/TypeData.cc \
        Parser/TypeData.h \

src/Parser/parser.yy

-              r34b4268
+              r24d6572
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Nov 21 22:34:30 2022
 // Update Count     : 5848
+// Last Modified On : Wed Apr 26 16:45:37 2023
+// Update Count     : 6330
 //
 …
 #include <cstdio>
+#include <sstream>
 #include <stack>
 using namespace std;
+#include "SynTree/Declaration.h"
+#include "ParseNode.h"
+#include "SynTree/Type.h"                               // for Type
+#include "DeclarationNode.h"                            // for DeclarationNode, ...
+#include "ExpressionNode.h"                             // for ExpressionNode, ...
+#include "InitializerNode.h"                            // for InitializerNode, ...
+#include "ParserTypes.h"
+#include "StatementNode.h"                              // for build_...
 #include "TypedefTable.h"
 #include "TypeData.h"
-#include "SynTree/LinkageSpec.h"
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
 #include "SynTree/Attribute.h"     // for Attribute
+#include "SynTree/Attribute.h"                                                  // for Attribute
 // lex uses __null in a boolean context, it's fine.
 …
 extern DeclarationNode * parseTree;
 extern LinkageSpec::Spec linkage;
+extern ast::Linkage::Spec linkage;
 extern TypedefTable typedefTable;
 stack<LinkageSpec::Spec> linkageStack;
+stack<ast::Linkage::Spec> linkageStack;
 bool appendStr( string & to, string & from ) {
 …
 } // fieldDecl
 #define NEW_ZERO new ExpressionNode( build_constantInteger( *new string( "0" ) ) )
 #define NEW_ONE  new ExpressionNode( build_constantInteger( *new string( "1" ) ) )
+#define NEW_ZERO new ExpressionNode( build_constantInteger( yylloc, *new string( "0" ) ) )
+#define NEW_ONE  new ExpressionNode( build_constantInteger( yylloc, *new string( "1" ) ) )
 #define UPDOWN( compop, left, right ) (compop == OperKinds::LThan || compop == OperKinds::LEThan ? left : right)
 #define MISSING_ANON_FIELD "Missing loop fields with an anonymous loop index is meaningless as loop index is unavailable in loop body."
 …
 #define MISSING_HIGH "Missing high value for down-to range so index is uninitialized."
+ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+static ForCtrl * makeForCtrl(
+                const CodeLocation & location,
+                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( location,
+                compop,
+                new ExpressionNode( build_varref( location, new string( *init->name ) ) ),
+                comp ) );
+        if ( inc ) inc = new ExpressionNode( build_binary_val( location,
+                // choose += or -= for upto/downto
+                compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn,
+                new ExpressionNode( build_varref( location, 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( const CodeLocation & location, DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( index->initializer ) {
                 SemanticError( yylloc, "Direct initialization disallowed. Use instead: type var; initialization ~ comparison ~ increment." );
 …
                 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( location, initDecl, compop, comp, inc );
 } // forCtrl
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         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 ) ) );
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        ast::ConstantExpr * constant = dynamic_cast<ast::ConstantExpr *>(type->expr.get());
+        if ( constant && (constant->rep == "0" || constant->rep == "1") ) {
+                type = new ExpressionNode( new ast::CastExpr( location, maybeMoveBuild(type), new ast::BasicType( ast::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( location, initDecl, compop, comp, inc );
 } // forCtrl
 ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->expr.get()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
         } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->expr.get()) ) {
                 if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
                         return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+ForCtrl * forCtrl( const CodeLocation & location, ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( auto identifier = dynamic_cast<ast::NameExpr *>(index->expr.get()) ) {
+                return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( auto commaExpr = dynamic_cast<ast::CommaExpr *>( index->expr.get() ) ) {
+                if ( auto identifier = commaExpr->arg1.as<ast::NameExpr>() ) {
+                        return forCtrl( location, type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
 …
 %union {
         Token tok;
+        ParseNode * pn;
+        ExpressionNode * en;
+        ExpressionNode * expr;
         DeclarationNode * decl;
+        AggregateDecl::Aggregate aggKey;
+        TypeDecl::Kind tclass;
+        StatementNode * sn;
+        WaitForStmt * wfs;
+        Expression * constant;
+        ast::AggregateDecl::Aggregate aggKey;
+        ast::TypeDecl::Kind tclass;
+        StatementNode * stmt;
+        ClauseNode * clause;
+        ast::WaitForStmt * wfs;
+    ast::WaitUntilStmt::ClauseNode * wucn;
         CondCtl * ifctl;
+        ForCtrl * fctl;
+        OperKinds compop;
+        LabelNode * label;
+        InitializerNode * in;
+        OperKinds op;
+        ForCtrl * forctl;
+        LabelNode * labels;
+        InitializerNode * init;
+        OperKinds oper;
         std::string * str;
         bool flag;
         EnumHiding hide;
         CatchStmt::Kind catch_kind;
         GenericExpr * genexpr;
+        bool is_volatile;
+        EnumHiding enum_hiding;
+        ast::ExceptionKind except_kind;
+        ast::GenericExpr * genexpr;
+}
 //************************* TERMINAL TOKENS ********************************
+// ************************ TERMINAL TOKENS ********************************
 // keywords
 …
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 %token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR    // CFA
+%token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR WAITUNTIL // CFA
 %token DISABLE ENABLE TRY THROW THROWRESUME AT                  // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 …
 // names and constants: lexer differentiates between identifier and typedef names
 %token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDIMname             TYPEDEFname             TYPEGENname
 %token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
+%token<tok> IDENTIFIER          TYPEDIMname             TYPEDEFname             TYPEGENname
+%token<tok> TIMEOUT                     WAND    WOR                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
 %token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
 %token<tok> DIRECTIVE
 …
 %type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
+%type<expr> string_literal
 %type<str> string_literal_list
 %type<hide> hide_opt                                    visible_hide_opt
+%type<enum_hiding> hide_opt                                     visible_hide_opt
 // expressions
 %type<en> constant
 %type<en> tuple                                                 tuple_expression_list
 %type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
 %type<en> shift_expression                              relational_expression           equality_expression
 %type<en> AND_expression                                exclusive_OR_expression         inclusive_OR_expression
 %type<en> logical_AND_expression                logical_OR_expression
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
+%type<expr> constant
+%type<expr> tuple                                                       tuple_expression_list
+%type<oper> ptrref_operator                             unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
+%type<expr> primary_expression                  postfix_expression                      unary_expression
+%type<expr> cast_expression_list                        cast_expression                         exponential_expression          multiplicative_expression       additive_expression
+%type<expr> shift_expression                            relational_expression           equality_expression
+%type<expr> AND_expression                              exclusive_OR_expression         inclusive_OR_expression
+%type<expr> logical_AND_expression              logical_OR_expression
+%type<expr> conditional_expression              constant_expression                     assignment_expression           assignment_expression_opt
+%type<expr> comma_expression                            comma_expression_opt
+%type<expr> argument_expression_list_opt        argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> conditional_declaration
 %type<fctl> for_control_expression              for_control_expression_list
 %type<compop> upupeq updown updowneq downupdowneq
 %type<en> subrange
+%type<forctl> for_control_expression            for_control_expression_list
+%type<oper> upupeq updown updowneq downupdowneq
+%type<expr> subrange
 %type<decl> asm_name_opt
 %type<en> asm_operands_opt                              asm_operands_list                       asm_operand
 %type<label> label_list
 %type<en> asm_clobbers_list_opt
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
+%type<expr> asm_operands_opt                            asm_operands_list                       asm_operand
+%type<labels> label_list
+%type<expr> asm_clobbers_list_opt
+%type<is_volatile> asm_volatile_opt
+%type<expr> handler_predicate_opt
 %type<genexpr> generic_association              generic_assoc_list
 // statements
+%type<sn> statement                                             labeled_statement                       compound_statement
+%type<sn> statement_decl                                statement_decl_list                     statement_list_nodecl
+%type<sn> selection_statement                   if_statement
+%type<sn> switch_clause_list_opt                switch_clause_list
+%type<en> case_value
+%type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
+%type<sn> iteration_statement                   jump_statement
+%type<sn> expression_statement                  asm_statement
+%type<sn> with_statement
+%type<en> with_clause_opt
+%type<sn> exception_statement                   handler_clause                          finally_clause
+%type<catch_kind> handler_key
+%type<sn> mutex_statement
+%type<en> when_clause                                   when_clause_opt                         waitfor                                         timeout
+%type<sn> waitfor_statement
+%type<wfs> waitfor_clause
+%type<stmt> statement                                           labeled_statement                       compound_statement
+%type<stmt> statement_decl                              statement_decl_list                     statement_list_nodecl
+%type<stmt> selection_statement                 if_statement
+%type<clause> switch_clause_list_opt            switch_clause_list
+%type<expr> case_value
+%type<clause> case_clause                               case_value_list                         case_label                                      case_label_list
+%type<stmt> iteration_statement                 jump_statement
+%type<stmt> expression_statement                        asm_statement
+%type<stmt> with_statement
+%type<expr> with_clause_opt
+%type<stmt> exception_statement
+%type<clause> handler_clause                    finally_clause
+%type<except_kind> handler_key
+%type<stmt> mutex_statement
+%type<expr> when_clause                                 when_clause_opt                         waitfor         waituntil               timeout
+%type<stmt> waitfor_statement                           waituntil_statement
+%type<wfs> wor_waitfor_clause
+%type<wucn> waituntil_clause                    wand_waituntil_clause       wor_waituntil_clause
 // declarations
 …
 %type<decl> assertion assertion_list assertion_list_opt
 %type<en> bit_subrange_size_opt bit_subrange_size
+%type<expr> bit_subrange_size_opt bit_subrange_size
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
 …
 %type<decl> enumerator_list enum_type enum_type_nobody
 %type<in> enumerator_value_opt
+%type<init> enumerator_value_opt
 %type<decl> external_definition external_definition_list external_definition_list_opt
 …
 %type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list_opt field_abstract
 %type<en> field field_name_list field_name fraction_constants_opt
+%type<expr> field field_name_list field_name fraction_constants_opt
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
 …
 %type<decl> typedef_name typedef_declaration typedef_expression
+%type<decl> variable_type_redeclarator type_ptr type_array type_function
+%type<decl> variable_type_redeclarator variable_type_ptr variable_type_array variable_type_function
+%type<decl> general_function_declarator function_type_redeclarator function_type_array function_type_no_ptr function_type_ptr
 %type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
 …
 %type<decl> type_parameter type_parameter_list type_initializer_opt
 %type<en> type_parameters_opt type_list array_type_list
+%type<expr> type_parameters_opt type_list array_type_list
 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
 …
 // initializers
 %type<in>  initializer initializer_list_opt initializer_opt
+%type<init>  initializer initializer_list_opt initializer_opt
 // designators
 %type<en>  designator designator_list designation
+%type<expr>  designator designator_list designation
 …
 // Similar issues exit with the waitfor statement.
 // Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
 // associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
+// Order of these lines matters (low-to-high precedence). THEN is left associative over WAND/WOR/TIMEOUT/ELSE, WAND/WOR
+// is left associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
 %precedence THEN                // rule precedence for IF/WAITFOR statement
+%precedence ANDAND              // token precedence for start of WAND in WAITFOR statement
+%precedence WAND                // token precedence for start of WAND in WAITFOR statement
+%precedence OROR                // token precedence for start of WOR in WAITFOR statement
 %precedence WOR                 // token precedence for start of WOR in WAITFOR statement
 %precedence TIMEOUT             // token precedence for start of TIMEOUT in WAITFOR statement
 …
 constant:
                 // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant".
         INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
         | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( *$1 ) ); }
         | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( *$1 ) ); }
+        INTEGERconstant                                                         { $$ = new ExpressionNode( build_constantInteger( yylloc, *$1 ) ); }
+        | FLOATING_DECIMALconstant                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | FLOATING_FRACTIONconstant                                     { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | FLOATINGconstant                                                      { $$ = new ExpressionNode( build_constantFloat( yylloc, *$1 ) ); }
+        | CHARACTERconstant                                                     { $$ = new ExpressionNode( build_constantChar( yylloc, *$1 ) ); }
+        ;
 quasi_keyword:                                                                                  // CFA
         TIMEOUT
+        | WAND
         | WOR
         | CATCH
 …
 string_literal:
         string_literal_list                                                     { $$ = build_constantStr( *$1 ); }
+        string_literal_list                                                     { $$ = new ExpressionNode( build_constantStr( yylloc, *$1 ) ); }
+        ;
 …
 primary_expression:
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
         | quasi_keyword
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
         | TYPEDIMname                                                                           // CFA, generic length argument
                 // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
                 // { $$ = new ExpressionNode( build_varref( $1 ) ); }
                 { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
+                { $$ = new ExpressionNode( build_dimensionref( yylloc, $1 ) ); }
         | tuple
         | '(' comma_expression ')'
                 { $$ = $2; }
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast<CompoundStmt *>(maybeMoveBuild<Statement>($2) ) ) ); }
+                { $$ = new ExpressionNode( new ast::StmtExpr( yylloc, dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( $2 ) ) ) ); }
         | type_name '.' identifier                                                      // CFA, nested type
                 { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_qualified_expr( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
 …
+                {
                         // add the missing control expression to the GenericExpr and return it
                         $5->control = maybeMoveBuild<Expression>( $3 );
+                        $5->control = maybeMoveBuild( $3 );
                         $$ = new ExpressionNode( $5 );
+                }
 …
+                {
                         // steal the association node from the singleton and delete the wrapper
+                        $1->associations.splice($1->associations.end(), $3->associations);
+                        assert( 1 == $3->associations.size() );
+                        $1->associations.push_back( $3->associations.front() );
                         delete $3;
                         $$ = $1;
 …
+                {
                         // create a GenericExpr wrapper with one association pair
                         $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>( $3 ) } } );
+                        $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuildType( $1 ), maybeMoveBuild( $3 ) } } );
+                }
         | DEFAULT ':' assignment_expression
                 { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>( $3 ) } } ); }
+                { $$ = new ast::GenericExpr( yylloc, nullptr, { { maybeMoveBuild( $3 ) } } ); }
+        ;
 …
                 // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
                 // Current: Commas in subscripts make tuples.
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
         | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
 …
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | constant '[' assignment_expression ']'                        // 3[a], 'a'[a], 3.5[a]
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | string_literal '[' assignment_expression ']'          // "abc"[3], 3["abc"]
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Index, $1, $3 ) ); }
         | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
+                {
                         Token fn;
                         fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
                         $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                        $$ = new ExpressionNode( new ast::ConstructorExpr( yylloc, build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | postfix_expression '(' argument_expression_list_opt ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, $1, $3 ) ); }
         | VA_ARG '(' primary_expression ',' declaration_specifier_nobody abstract_parameter_declarator_opt ')'
                 // { SemanticError( yylloc, "va_arg is currently unimplemented." ); $$ = nullptr; }
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__builtin_va_arg") ) ),
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, new string( "__builtin_va_arg") ) ),
                                                                                            (ExpressionNode *)($3->set_last( (ExpressionNode *)($6 ? $6->addType( $5 ) : $5) )) ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | constant '`' identifier                                                       // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), $1 ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | string_literal '`' identifier                                         // CFA, postfix call
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( build_postfix_name( $3 ) ) ), new ExpressionNode( $1 ) ) ); }
+                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
         | postfix_expression '.' identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 ) ) ); }
         | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | postfix_expression '.' aggregate_control
                 { $$ = new ExpressionNode( build_keyword_cast( $3, $1 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $3, $1 ) ); }
         | postfix_expression ARROW identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
         | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, new InitializerNode( $5, true ) ) ); }
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
+                { $$ = new ExpressionNode( build_compoundLiteral( yylloc, $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
+                {
                         Token fn;
                         fn.str = new string( "^?{}" );                          // location undefined
                         $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                        $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) );
+                }
+        ;
 …
         '@'                                                                                                     // CFA, default parameter
                 { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
                 // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
+                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
         | assignment_expression
+        ;
 …
         field_name
         | FLOATING_DECIMALconstant field
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), maybeMoveBuild( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( yylloc, *$1 ) ), build_tuple( yylloc, $3 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
         | field_name '.' '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
         | field_name ARROW field
                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, maybeMoveBuild( $3 ) ) ); }
         | field_name ARROW '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( yylloc, $1, build_tuple( yylloc, $4 ) ) ); }
+        ;
 field_name:
         INTEGERconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_constantInteger( yylloc, *$1 ), $2 ) ); }
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
+                { $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_field_name_FLOATINGconstant( yylloc, *$1 ), $2 ) ); }
         | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+                {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
+                        $$ = new ExpressionNode( build_field_name_fraction_constants( yylloc, build_varref( yylloc, $1 ), $2 ) );
+                }
+        ;
 …
         | fraction_constants_opt FLOATING_FRACTIONconstant
+                {
                         Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
                         $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
+                        ast::Expr * constant = build_field_name_FLOATING_FRACTIONconstant( yylloc, *$2 );
+                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( yylloc, $1, constant ) ) : new ExpressionNode( constant );
+                }
+        ;
 …
         | constant
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
+                { $$ = $1; }
         | EXTENSION cast_expression                                                     // GCC
                 { $$ = $2->set_extension( true ); }
 …
+                {
                         switch ( $1 ) {
                           case OperKinds::AddressOf:
                                 $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) );
+                        case OperKinds::AddressOf:
+                                $$ = new ExpressionNode( new ast::AddressExpr( maybeMoveBuild( $2 ) ) );
                                 break;
                           case OperKinds::PointTo:
                                 $$ = new ExpressionNode( build_unary_val( $1, $2 ) );
+                        case OperKinds::PointTo:
+                                $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) );
                                 break;
                           case OperKinds::And:
                                 $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild<Expression>( $2 ) ) ) );
+                        case OperKinds::And:
+                                $$ = new ExpressionNode( new ast::AddressExpr( new ast::AddressExpr( maybeMoveBuild( $2 ) ) ) );
                                 break;
                           default:
+                        default:
                                 assert( false );
+                        }
+                }
         | unary_operator cast_expression
                 { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, $1, $2 ) ); }
         | ICR unary_expression
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Incr, $2 ) ); }
         | DECR unary_expression
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
+                { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | OFFSETOF '(' type_no_function ',' identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_offsetOf( yylloc, $3, build_varref( yylloc, $5 ) ) ); }
         | TYPEID '(' type_no_function ')'
+                {
 …
         unary_expression
         | '(' type_no_function ')' cast_expression
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
         | '(' aggregate_control '*' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+                { $$ = new ExpressionNode( build_keyword_cast( yylloc, $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $4 ), maybeMoveBuildType( nullptr ) ) ); }
+                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); }
         | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { $$ = new ExpressionNode( build_cast( $3, $5, CastExpr::Return ) ); }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
 …
                 { SemanticError( yylloc, "Qualifier cast is currently unimplemented." ); $$ = nullptr; }
 //      | '(' type_no_function ')' tuple
 //              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
+//              { $$ = new ast::ExpressionNode( build_cast( yylloc, $2, $4 ) ); }
+        ;
 …
         cast_expression
         | exponential_expression '\\' cast_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Exp, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Exp, $1, $3 ) ); }
+        ;
 …
         exponential_expression
         | multiplicative_expression '*' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mul, $1, $3 ) ); }
         | multiplicative_expression '/' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Div, $1, $3 ) ); }
         | multiplicative_expression '%' exponential_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Mod, $1, $3 ) ); }
+        ;
 …
         multiplicative_expression
         | additive_expression '+' multiplicative_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Plus, $1, $3 ) ); }
         | additive_expression '-' multiplicative_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Minus, $1, $3 ) ); }
+        ;
 …
         additive_expression
         | shift_expression LS additive_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LShift, $1, $3 ) ); }
         | shift_expression RS additive_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::RShift, $1, $3 ) ); }
+        ;
 …
         shift_expression
         | relational_expression '<' shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LThan, $1, $3 ) ); }
         | relational_expression '>' shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GThan, $1, $3 ) ); }
         | relational_expression LE shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::LEThan, $1, $3 ) ); }
         | relational_expression GE shift_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::GEThan, $1, $3 ) ); }
+        ;
 …
         relational_expression
         | equality_expression EQ relational_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Eq, $1, $3 ) ); }
         | equality_expression NE relational_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Neq, $1, $3 ) ); }
+        ;
 …
         equality_expression
         | AND_expression '&' equality_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitAnd, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitAnd, $1, $3 ) ); }
+        ;
 …
         AND_expression
         | exclusive_OR_expression '^' AND_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Xor, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::Xor, $1, $3 ) ); }
+        ;
 …
         exclusive_OR_expression
         | inclusive_OR_expression '|' exclusive_OR_expression
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::BitOr, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( yylloc, OperKinds::BitOr, $1, $3 ) ); }
+        ;
 …
         inclusive_OR_expression
         | logical_AND_expression ANDAND inclusive_OR_expression
                 { $$ = new ExpressionNode( build_and_or( $1, $3, true ) ); }
+                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::AndExpr ) ); }
+        ;
 …
         logical_AND_expression
         | logical_OR_expression OROR logical_AND_expression
                 { $$ = new ExpressionNode( build_and_or( $1, $3, false ) ); }
+                { $$ = new ExpressionNode( build_and_or( yylloc, $1, $3, ast::OrExpr ) ); }
+        ;
 …
         logical_OR_expression
         | logical_OR_expression '?' comma_expression ':' conditional_expression
                 { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
                 { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+        ;
 …
 //                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
 //                      } else {
                                 $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
+                                $$ = new ExpressionNode( build_binary_val( yylloc, $2, $1, $3 ) );
 //                      } // if
+                }
 …
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
         '[' ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
         | '[' push assignment_expression pop ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $6 ) ) )); }
+                { $$ = new ExpressionNode( build_tuple( yylloc, (ExpressionNode *)($3->set_last( $6 ) ) )); }
+        ;
 …
         assignment_expression
         | comma_expression ',' assignment_expression
                 { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::CommaExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+        ;
 …
         | mutex_statement
         | waitfor_statement
+        | waituntil_statement
         | exception_statement
         | enable_disable_statement
 …
         | asm_statement
         | DIRECTIVE
                 { $$ = new StatementNode( build_directive( $1 ) ); }
+                { $$ = new StatementNode( build_directive( yylloc, $1 ) ); }
+        ;
 …
                 // labels cannot be identifiers 0 or 1
         identifier_or_type_name ':' attribute_list_opt statement
                 { $$ = $4->add_label( $1, $3 ); }
+                { $$ = $4->add_label( yylloc, $1, $3 ); }
         | identifier_or_type_name ':' attribute_list_opt error // syntax error
+                {
 …
 compound_statement:
         '{' '}'
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
+                { $$ = new StatementNode( build_compound( yylloc, (StatementNode *)0 ) ); }
         | '{' push
           local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
                 { $$ = new StatementNode( build_compound( $4 ) ); }
+                { $$ = new StatementNode( build_compound( yylloc, $4 ) ); }
+        ;
 …
 expression_statement:
         comma_expression_opt ';'
+                { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
+                { $$ = new StatementNode( build_expr( yylloc, $1 ) ); }
+        ;
 …
                 { $$ = $2; }
         | SWITCH '(' comma_expression ')' case_clause
                 { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( yylloc, true, $3, $5 ) ); }
         | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+                {
                         StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
+                        StatementNode *sw = new StatementNode( build_switch( yylloc, true, $3, $8 ) );
                         // The semantics of the declaration list is changed to include associated initialization, which is performed
                         // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
 …
                         // therefore, are removed from the grammar even though C allows it. The change also applies to choose
                         // statement.
                         $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
         | SWITCH '(' comma_expression ')' '{' error '}'         // CFA, syntax error
                 { SemanticError( yylloc, "Only declarations can appear before the list of case clauses." ); $$ = nullptr; }
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
                 { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
+                { $$ = new StatementNode( build_switch( yylloc, false, $3, $5 ) ); }
         | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+                {
                         StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
                         $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                        StatementNode *sw = new StatementNode( build_switch( yylloc, false, $3, $8 ) );
+                        $$ = $7 ? new StatementNode( build_compound( yylloc, (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
+                }
         | CHOOSE '(' comma_expression ')' '{' error '}'         // CFA, syntax error
 …
         IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
+                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), nullptr ) ); }
         | IF '(' conditional_declaration ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
+                { $$ = new StatementNode( build_if( yylloc, $3, maybe_build_compound( yylloc, $5 ), maybe_build_compound( yylloc, $7 ) ) ); }
+        ;
 …
         | declaration comma_expression                                          // semi-colon separated
                 { $$ = new CondCtl( $1, $2 ); }
+        ;
+        ;
 // CASE and DEFAULT clauses are only allowed in the SWITCH statement, precluding Duff's device. In addition, a case
 …
         constant_expression                                                     { $$ = $1; }
         | constant_expression ELLIPSIS constant_expression      // GCC, subrange
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | subrange                                                                                      // CFA, subrange
+        ;
 case_value_list:                                                                                // CFA
         case_value                                                                      { $$ = new StatementNode( build_case( $1 ) ); }
+        case_value                                                                      { $$ = new ClauseNode( build_case( yylloc, $1 ) ); }
                 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
         | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_last( new StatementNode( build_case( $3 ) ) ) ); }
+        | case_value_list ',' case_value                        { $$ = $1->set_last( new ClauseNode( build_case( yylloc, $3 ) ) ); }
+        ;
 …
         | CASE case_value_list error                                            // syntax error
                 { SemanticError( yylloc, "Missing colon after case list." ); $$ = nullptr; }
         | DEFAULT ':'                                                           { $$ = new StatementNode( build_default() ); }
+        | DEFAULT ':'                                                           { $$ = new ClauseNode( build_default( yylloc ) ); }
                 // A semantic check is required to ensure only one default clause per switch/choose statement.
         | DEFAULT error                                                                         //  syntax error
 …
 case_label_list:                                                                                // CFA
         case_label
         | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_last( $2 )); }
+        | case_label_list case_label                            { $$ = $1->set_last( $2 ); }
+        ;
 case_clause:                                                                                    // CFA
         case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( yylloc, $2 ) ); }
+        ;
 …
 switch_clause_list:                                                                             // CFA
         case_label_list statement_list_nodecl
                 { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
+                { $$ = $1->append_last_case( new StatementNode( build_compound( yylloc, $2 ) ) ); }
         | switch_clause_list case_label_list statement_list_nodecl
                 { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
+                { $$ = $1->set_last( $2->append_last_case( new StatementNode( build_compound( yylloc, $3 ) ) ) ); }
+        ;
 iteration_statement:
         WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) ); }
+                { $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) ); }
         | WHILE '(' ')' statement ELSE statement                        // CFA
+                {
                         $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_while( yylloc, new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( yylloc, $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_while( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) ); }
         | DO statement WHILE '(' ')' ELSE statement                     // CFA
+                {
                         $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_do_while( yylloc, NEW_ONE, maybe_build_compound( yylloc, $2 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
+                { $$ = new StatementNode( build_do_while( yylloc, $5, maybe_build_compound( yylloc, $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( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) ); }
         | FOR '(' ')' statement ELSE statement                          // CFA
+                {
                         $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
                         SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        $$ = new StatementNode( build_for( yylloc, new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( yylloc, $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
+                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
+                { $$ = new StatementNode( build_for( yylloc, $3, maybe_build_compound( yylloc, $5 ), $7 ) ); }
+        ;
 …
                         if ( $1->condition ) {
                                 if ( $3->condition ) {
                                         $1->condition->expr.reset( new LogicalExpr( $1->condition->expr.release(), $3->condition->expr.release(), true ) );
+                                        $1->condition->expr.reset( new ast::LogicalExpr( yylloc, $1->condition->expr.release(), $3->condition->expr.release(), ast::AndExpr ) );
                                 } // if
                         } else $1->condition = $3->condition;
                         if ( $1->change ) {
                                 if ( $3->change ) {
                                         $1->change->expr.reset( new CommaExpr( $1->change->expr.release(), $3->change->expr.release() ) );
+                                        $1->change->expr.reset( new ast::CommaExpr( yylloc, $1->change->expr.release(), $3->change->expr.release() ) );
                                 } // if
                         } else $1->change = $3->change;
 …
 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 ast::ExprStmt( yylloc, 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
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), NEW_ZERO, OperKinds::LThan, $1->clone(), NEW_ONE ); }
         | downupdowneq comma_expression                                         // CFA, anonymous loop-index
                 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $2, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $1, NEW_ZERO, $2->clone() ), $1, UPDOWN( $1, $2->clone(), NEW_ZERO ), NEW_ONE ); }
         | comma_expression updowneq comma_expression            // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), NEW_ONE ); }
         | '@' updowneq comma_expression                                         // CFA, anonymous loop-index
+                {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, NEW_ONE );
+                }
         | comma_expression updowneq '@'                                         // CFA, anonymous loop-index
 …
+                }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
+                { $$ = forCtrl( yylloc, $1, new string( DeclarationNode::anonymous.newName() ), UPDOWN( $2, $1->clone(), $3 ), $2, UPDOWN( $2, $3->clone(), $1->clone() ), $5 ); }
         | '@' updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
+                {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                        else $$ = forCtrl( yylloc, $3, new string( DeclarationNode::anonymous.newName() ), $3->clone(), $2, nullptr, $5 );
+                }
         | comma_expression updowneq '@' '~' comma_expression // CFA, anonymous loop-index
 …
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $3, $1, NEW_ZERO, OperKinds::LThan, $3->clone(), NEW_ONE ); }
         | comma_expression ';' downupdowneq comma_expression // CFA
                 { $$ = forCtrl( $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $4, $1, UPDOWN( $3, NEW_ZERO, $4->clone() ), $3, UPDOWN( $3, $4->clone(), NEW_ZERO ), NEW_ONE ); }
         | comma_expression ';' comma_expression updowneq comma_expression // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), NEW_ONE ); }
         | comma_expression ';' '@' updowneq comma_expression // CFA
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, NEW_ONE );
+                }
         | comma_expression ';' comma_expression updowneq '@' // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, NEW_ONE );
+                }
         | comma_expression ';' '@' updowneq '@'                         // CFA, error
 …
         | comma_expression ';' comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), $7 ); }
         | comma_expression ';' '@' updowneq comma_expression '~' comma_expression // CFA, error
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, $7 );
+                }
         | comma_expression ';' comma_expression updowneq '@' '~' comma_expression // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, $7 );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, $7 );
+                }
         | comma_expression ';' comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
+                { $$ = forCtrl( yylloc, $3, $1, UPDOWN( $4, $3->clone(), $5 ), $4, UPDOWN( $4, $5->clone(), $3->clone() ), nullptr ); }
         | comma_expression ';' '@' updowneq comma_expression '~' '@' // CFA, error
+                {
                         if ( $4 == OperKinds::LThan || $4 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $5, $1, $5->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $5, $1, $5->clone(), $4, nullptr, nullptr );
+                }
         | comma_expression ';' comma_expression updowneq '@' '~' '@' // CFA
 …
                         if ( $4 == OperKinds::GThan || $4 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $4 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $3, $1, $3->clone(), $4, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $3, $1, $3->clone(), $4, nullptr, nullptr );
+                }
         | comma_expression ';' '@' updowneq '@' '~' '@' // CFA
 …
         | declaration comma_expression                                          // CFA
                 { $$ = forCtrl( $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, NEW_ZERO, OperKinds::LThan, $2, NEW_ONE ); }
         | declaration downupdowneq comma_expression                     // CFA
                 { $$ = forCtrl( $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $2, NEW_ZERO, $3 ), $2, UPDOWN( $2, $3->clone(), NEW_ZERO ), NEW_ONE ); }
         | declaration comma_expression updowneq comma_expression // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2->clone(), $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), NEW_ONE ); }
         | declaration '@' updowneq comma_expression                     // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, NEW_ONE );
+                }
         | declaration comma_expression updowneq '@'                     // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, NEW_ONE );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, NEW_ONE );
+                }
         | declaration comma_expression updowneq comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), $6 ); }
         | declaration '@' updowneq comma_expression '~' comma_expression // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, $6 );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, $6 );
+                }
         | declaration comma_expression updowneq '@' '~' comma_expression // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, $6 );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, $6 );
+                }
         | declaration comma_expression updowneq comma_expression '~' '@' // CFA
                 { $$ = forCtrl( $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
+                { $$ = forCtrl( yylloc, $1, UPDOWN( $3, $2, $4 ), $3, UPDOWN( $3, $4->clone(), $2->clone() ), nullptr ); }
         | declaration '@' updowneq comma_expression '~' '@' // CFA
+                {
                         if ( $3 == OperKinds::LThan || $3 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_LOW ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $4, $3, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $1, $4, $3, nullptr, nullptr );
+                }
         | declaration comma_expression updowneq '@' '~' '@'     // CFA
 …
                         if ( $3 == OperKinds::GThan || $3 == OperKinds::GEThan ) { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                         else if ( $3 == OperKinds::LEThan ) { SemanticError( yylloc, "Equality with missing high value is meaningless. Use \"~\"." ); $$ = nullptr; }
                         else $$ = forCtrl( $1, $2, $3, nullptr, nullptr );
+                        else $$ = forCtrl( yylloc, $1, $2, $3, nullptr, nullptr );
+                }
         | declaration '@' updowneq '@' '~' '@'                          // CFA, error
 …
                         SemanticError( yylloc, "Type iterator is currently unimplemented." ); $$ = nullptr;
+                }
+        ;
+        ;
 downupdowneq:
 …
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
+        ;
+        ;
 updown:
 …
         | ErangeDown
                 { $$ = OperKinds::GThan; }
+        ;
+        ;
 updowneq:
 …
         | ErangeDownEq
                 { $$ = OperKinds::GEThan; }
+        ;
+        ;
 jump_statement:
         GOTO identifier_or_type_name ';'
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Goto ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Goto ) ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
                 // The syntax for the GCC computed goto violates normal expression precedence, e.g., goto *i+3; => goto *(i+3);
 …
                 // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
         | fall_through_name ';'                                                         // CFA
                 { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThrough ) ); }
         | fall_through_name identifier_or_type_name ';'         // CFA
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::FallThrough ) ); }
         | fall_through_name DEFAULT ';'                                         // CFA
                 { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::FallThroughDefault ) ); }
         | CONTINUE ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( build_branch( BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Continue ) ); }
         | CONTINUE identifier_or_type_name ';'                          // CFA, multi-level continue
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Continue ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Continue ) ); }
         | BREAK ';'
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, ast::BranchStmt::Break ) ); }
         | BREAK identifier_or_type_name ';'                                     // CFA, multi-level exit
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
                 { $$ = new StatementNode( build_branch( $2, BranchStmt::Break ) ); }
+                { $$ = new StatementNode( build_branch( yylloc, $2, ast::BranchStmt::Break ) ); }
         | RETURN comma_expression_opt ';'
                 { $$ = new StatementNode( build_return( $2 ) ); }
+                { $$ = new StatementNode( build_return( yylloc, $2 ) ); }
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
         | SUSPEND ';'
                 { $$ = new StatementNode( build_suspend( nullptr ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::None ) ); }
         | SUSPEND compound_statement
                 { $$ = new StatementNode( build_suspend( $2 ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $2, ast::SuspendStmt::None ) ); }
         | SUSPEND COROUTINE ';'
                 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Coroutine ) ); }
         | SUSPEND COROUTINE compound_statement
                 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Coroutine ) ); }
         | SUSPEND GENERATOR ';'
                 { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, nullptr, ast::SuspendStmt::Generator ) ); }
         | SUSPEND GENERATOR compound_statement
                 { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
+                { $$ = new StatementNode( build_suspend( yylloc, $3, ast::SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
+                { $$ = new StatementNode( build_throw( yylloc, $2 ) ); }
         | THROWRESUME assignment_expression_opt ';'                     // handles reresume
                 { $$ = new StatementNode( build_resume( $2 ) ); }
+                { $$ = new StatementNode( build_resume( yylloc, $2 ) ); }
         | THROWRESUME assignment_expression_opt AT assignment_expression ';' // handles reresume
                 { $$ = new StatementNode( build_resume_at( $2, $4 ) ); }
 …
 with_statement:
         WITH '(' tuple_expression_list ')' statement
                 { $$ = new StatementNode( build_with( $3, $5 ) ); }
+        ;
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
+                { $$ = new StatementNode( build_with( yylloc, $3, $5 ) ); }
+        ;
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so possibly change syntax to "with mutex".
 mutex_statement:
+        MUTEX '(' argument_expression_list ')' statement
+                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        MUTEX '(' argument_expression_list_opt ')' statement
+                {
+                        if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; }
+                        $$ = new StatementNode( build_mutex( yylloc, $3, $5 ) );
+                }
+        ;
 …
                 { $$ = nullptr; }
         | when_clause
+        ;
-waitfor:
-        WAITFOR '(' cast_expression ')'
-                { $$ = $3; }
-//      | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
-//              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
-        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
-                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
 …
 timeout:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+waitfor_clause:
+        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
+        ;
+wor:
+        OROR
+        | WOR
+waitfor:
+        WAITFOR '(' cast_expression ')'
+                { $$ = $3; }
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
+                { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
+wor_waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
+        | when_clause_opt timeout statement                                     %prec THEN
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
+        | when_clause_opt ELSE statement
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
+                // Called first: create header for WaitForStmt.
+                { $$ = build_waitfor( yylloc, new ast::WaitForStmt( yylloc ), $1, $2, maybe_build_compound( yylloc, $3 ) ); }
+        | wor_waitfor_clause wor when_clause_opt waitfor statement
+                { $$ = build_waitfor( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
+        | wor_waitfor_clause wor when_clause_opt ELSE statement
+                { $$ = build_waitfor_else( yylloc, $1, $3, maybe_build_compound( yylloc, $5 ) ); }
+        | wor_waitfor_clause wor when_clause_opt timeout statement      %prec THEN
+                { $$ = build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | when_clause_opt timeout statement WOR ELSE statement // syntax error
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
                 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | when_clause_opt timeout statement WOR when_clause ELSE statement
                 { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
+        | wor_waitfor_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
+                { $$ = build_waitfor_else( yylloc, build_waitfor_timeout( yylloc, $1, $3, $4, maybe_build_compound( yylloc, $5 ) ), $7, maybe_build_compound( yylloc, $9 ) ); }
+        ;
 waitfor_statement:
+        when_clause_opt waitfor statement                                       %prec THEN
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
+        wor_waitfor_clause                                                                      %prec THEN
+                { $$ = new StatementNode( $1 ); }
+        ;
+wand:
+        ANDAND
+        | WAND
+        ;
+waituntil:
+        WAITUNTIL '(' comma_expression ')'
+                { $$ = $3; }
+        ;
+waituntil_clause:
+        when_clause_opt waituntil statement
+                { $$ = build_waituntil_clause( yylloc, $1, $2, maybe_build_compound( yylloc, $3 ) ); }
+        | '(' wor_waituntil_clause ')'
+                { $$ = $2; }
+        ;
+wand_waituntil_clause:
+        waituntil_clause                                                                        %prec THEN
+                { $$ = $1; }
+        | waituntil_clause wand wand_waituntil_clause
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::AND, $1, $3 ); }
+        ;
+wor_waituntil_clause:
+        wand_waituntil_clause
+                { $$ = $1; }
+        | wor_waituntil_clause wor wand_waituntil_clause
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, $1, $3 ); }
+        | wor_waituntil_clause wor when_clause_opt ELSE statement
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+        | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
+        // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
+                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
+        | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
+                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR,
+                    build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ),
+                    build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
+        ;
+waituntil_statement:
+        wor_waituntil_clause                                                            %prec THEN
+                // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
+                {
+            $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
+            // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
+        }
+        ;
 exception_statement:
         TRY compound_statement handler_clause                                   %prec THEN
                 { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
+        TRY compound_statement handler_clause                                   %prec THEN
+                { $$ = new StatementNode( build_try( yylloc, $2, $3, nullptr ) ); }
         | TRY compound_statement finally_clause
                 { $$ = new StatementNode( build_try( $2, 0, $3 ) ); }
+                { $$ = new StatementNode( build_try( yylloc, $2, nullptr, $3 ) ); }
         | TRY compound_statement handler_clause finally_clause
                 { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
+                { $$ = new StatementNode( build_try( yylloc, $2, $3, $4 ) ); }
+        ;
 handler_clause:
         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
                 { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
+                { $$ = new ClauseNode( build_catch( yylloc, $1, $4, $6, $8 ) ); }
         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
                 { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
+                { $$ = $1->set_last( new ClauseNode( build_catch( yylloc, $2, $5, $7, $9 ) ) ); }
+        ;
 …
 handler_key:
         CATCH                                                                           { $$ = CatchStmt::Terminate; }
         | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
         | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
         | FIXUP                                                                         { $$ = CatchStmt::Resume; }
+        CATCH                                                                           { $$ = ast::Terminate; }
+        | RECOVER                                                                       { $$ = ast::Terminate; }
+        | CATCHRESUME                                                           { $$ = ast::Resume; }
+        | FIXUP                                                                         { $$ = ast::Resume; }
+        ;
 finally_clause:
         FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( $2 ) ); }
+        FINALLY compound_statement                                      { $$ = new ClauseNode( build_finally( yylloc, $2 ) ); }
+        ;
 …
 asm_statement:
         ASM asm_volatile_opt '(' string_literal ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, 0 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, nullptr ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
                 { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $4, $6, $8, $10 ) ); }
         | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
                 { $$ = new StatementNode( build_asm( $2, $5, 0, $8, $10, $12 ) ); }
+                { $$ = new StatementNode( build_asm( yylloc, $2, $5, nullptr, $8, $10, $12 ) ); }
+        ;
 …
 asm_operand:                                                                                    // GCC
         string_literal '(' constant_expression ')'
                 { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AsmExpr( yylloc, "", maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
         | '[' IDENTIFIER ']' string_literal '(' constant_expression ')'
+                { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild<Expression>( $6 ) ) ); }
+                {
+                        $$ = new ExpressionNode( new ast::AsmExpr( yylloc, *$2.str, maybeMoveBuild( $4 ), maybeMoveBuild( $6 ) ) );
+                        delete $2.str;
+                }
+        ;
 …
                 { $$ = nullptr; }                                                               // use default argument
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
+                { $$ = $1; }
         | asm_clobbers_list_opt ',' string_literal
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( $3 ) )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 ) ); }
+        ;
 …
         identifier
+                {
                         $$ = new LabelNode(); $$->labels.push_back( *$1 );
+                        $$ = new LabelNode(); $$->labels.emplace_back( yylloc, *$1 );
                         delete $1;                                                                      // allocated by lexer
+                }
         | label_list ',' identifier
+                {
                         $$ = $1; $1->labels.push_back( *$3 );
+                        $$ = $1; $1->labels.emplace_back( yylloc, *$3 );
                         delete $3;                                                                      // allocated by lexer
+                }
 …
+                {
                         // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
                 { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, maybeMoveBuild( $5 ) ); }
         | STATICASSERT '(' constant_expression ')' ';'          // CFA
                 { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
+                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( yylloc, *new string( "\"\"" ) ) ); }
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
 …
 //      '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
 //              {
 //                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
+//                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, nullptr, true );
 //              }
 //      '[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
 //                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, nullptr, true );
 //              }
 //      | '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
 //                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+//                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, nullptr, true );
 //              }
 //      | '[' ']' typegen_name
 …
         cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, nullptr )->addQualifiers( $8 ); }
         | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' attribute_list_opt
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 )->addQualifiers( $8 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, nullptr )->addQualifiers( $8 ); }
+        ;
 …
+                {
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
+                        $$ = $3->addType( $2 )->addTypedef();
+                        if ( $2->type->forall || ($2->type->kind == TypeData::Aggregate && $2->type->aggregate.params) ) {
+                                SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." ); $$ = nullptr;
+                        } else $$ = $3->addType( $2 )->addTypedef(); // watchout frees $2 and $3
+                }
         | typedef_declaration pop ',' push declarator
 …
+                }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
+                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
         | type_specifier TYPEDEF declarator
+                {
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
+                        $$ = $3->addType( $1 )->addTypedef();
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
         | type_specifier TYPEDEF type_qualifier_list declarator
+                {
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
+                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
+                }
+                { SemanticError( yylloc, "Type qualifiers/specifiers before TYPEDEF is deprecated, move after TYPEDEF." ); $$ = nullptr; }
+        ;
 …
         TYPEDEF identifier '=' assignment_expression
+                {
                         SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
         | typedef_expression pop ',' push identifier '=' assignment_expression
+                {
                         SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                        SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
+        ;
 …
         | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
+                {
+                        assert( $1->type );
+                        if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
+                                SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr;
+                        }
+                        // enums are never empty declarations because there must have at least one enumeration.
+                        if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
+                                SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
+                        }
+                }
+        ;
 …
                 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
                 // storage-class
         declarator asm_name_opt initializer_opt
+        variable_declarator asm_name_opt initializer_opt
                 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
+        | variable_type_redeclarator asm_name_opt initializer_opt
+                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
+        | general_function_declarator asm_name_opt
+                { $$ = $1->addAsmName( $2 )->addInitializer( nullptr ); }
+        | general_function_declarator asm_name_opt '=' VOID
+                { $$ = $1->addAsmName( $2 )->addInitializer( new InitializerNode( true ) ); }
         | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
                 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
+        ;
+general_function_declarator:
+        function_type_redeclarator
+        | function_declarator
+        ;
 declaration_specifier:                                                                  // type specifier + storage class
         basic_declaration_specifier
+        | type_declaration_specifier
         | sue_declaration_specifier
+        | type_declaration_specifier
+        | sue_declaration_specifier invalid_types
+                {
+                        SemanticError( yylloc, ::toString( "Missing ';' after end of ",
+                                $1->type->enumeration.name ? "enum" : ast::AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                " declaration" ) );
+                        $$ = nullptr;
+                }
+        ;
+invalid_types:
+        aggregate_key
+        | basic_type_name
+        | indirect_type
+        ;
 …
         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
+        ;
 …
                 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
         | forall
+                { $$ = DeclarationNode::newForall( $1 ); }
+        ;
 forall:
         FORALL '(' type_parameter_list ')'                                      // CFA
                 { $$ = DeclarationNode::newForall( $3 ); }
+                { $$ = $3; }
+        ;
 …
                 { $$ = DeclarationNode::newTypeof( $3 ); }
         | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
                 { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ), true ); }
         | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3, true ); }
 …
+                {
                         // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
+                {
                         // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
+                {
                         // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
           '{' 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
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
+                {
-                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
 …
                         // 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;
+                        }
+                }
+        ;
 …
 aggregate_data:
         STRUCT vtable_opt
                 { $$ = AggregateDecl::Struct; }
+                { $$ = ast::AggregateDecl::Struct; }
         | UNION
                 { $$ = AggregateDecl::Union; }
+                { $$ = ast::AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
                 { $$ = AggregateDecl::Exception; }
           //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                { $$ = ast::AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = ast::AggregateDecl::NoAggregate; }
+        ;
 aggregate_control:                                                                              // CFA
         MONITOR
                 { $$ = AggregateDecl::Monitor; }
+                { $$ = ast::AggregateDecl::Monitor; }
         | MUTEX STRUCT
                 { $$ = AggregateDecl::Monitor; }
+                { $$ = ast::AggregateDecl::Monitor; }
         | GENERATOR
                 { $$ = AggregateDecl::Generator; }
+                { $$ = ast::AggregateDecl::Generator; }
         | MUTEX GENERATOR
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor generator is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
         | COROUTINE
                 { $$ = AggregateDecl::Coroutine; }
+                { $$ = ast::AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor coroutine is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
         | THREAD
                 { $$ = AggregateDecl::Thread; }
+                { $$ = ast::AggregateDecl::Thread; }
         | MUTEX THREAD
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                {
+                        SemanticError( yylloc, "monitor thread is currently unimplemented." );
+                        $$ = ast::AggregateDecl::NoAggregate;
+                }
+        ;
 …
                         $$ = fieldDecl( $1, $2 );
                         // printf( "type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
                         //   printf( "\tattr %s\n", attr->name.c_str() );
                         // } // for
 …
         | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
+        | STATIC type_specifier field_declaring_list_opt ';' // CFA
+                { SemanticError( yylloc, "STATIC aggregate field qualifier currently unimplemented." ); $$ = nullptr; }
         | INLINE type_specifier field_abstract_list_opt ';'     // CFA
+                {
 …
+                }
         | INLINE aggregate_control ';'                                          // CFA
                 { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
+                { SemanticError( yylloc, "INLINE aggregate control currently unimplemented." ); $$ = nullptr; }
         | typedef_declaration ';'                                                       // CFA
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
 …
                 { $$ = $1->addBitfield( $2 ); }
         | variable_type_redeclarator bit_subrange_size_opt
+                // A semantic check is required to ensure bit_subrange only appears on integral types.
+                { $$ = $1->addBitfield( $2 ); }
+        | function_type_redeclarator bit_subrange_size_opt
                 // A semantic check is required to ensure bit_subrange only appears on integral types.
                 { $$ = $1->addBitfield( $2 ); }
 …
                 { $$ = DeclarationNode::newEnum( $3->name, $6, true, false, nullptr, $4 )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() )
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 …
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
+                {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6 );
+                }
 …
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, nullptr, false, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt type_name
                 { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, nullptr, false, false )->addQualifiers( $2 ); }
+        ;
 …
 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 ); }
 …
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier_at ':'                                                                     // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $1 ) ); }
+        ;
 …
 designator:
         '.' identifier_at                                                                       // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
+                { $$ = new ExpressionNode( build_varref( yylloc, $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
                 // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
 …
                 { $$ = $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 ast::RangeExpr( yylloc, maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); }
         | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
 …
+                {
                         typedefTable.addToScope( *$2, TYPEDEFname, "9" );
                         if ( $1 == TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
                         if ( $1 == TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
                         if ( $1 == TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                        if ( $1 == ast::TypeDecl::Otype ) { SemanticError( yylloc, "otype keyword is deprecated, use T " ); }
+                        if ( $1 == ast::TypeDecl::Dtype ) { SemanticError( yylloc, "dtype keyword is deprecated, use T &" ); }
+                        if ( $1 == ast::TypeDecl::Ttype ) { SemanticError( yylloc, "ttype keyword is deprecated, use T ..." ); }
+                }
           type_initializer_opt assertion_list_opt
 …
+                {
                         typedefTable.addToScope( *$2, TYPEDIMname, "9" );
                         $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
+                        $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dimension, $2 );
+                }
         // | type_specifier identifier_parameter_declarator
         | assertion_list
                 { $$ = DeclarationNode::newTypeParam( TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+                { $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+        ;
 new_type_class:                                                                                 // CFA
         // empty
                 { $$ = TypeDecl::Otype; }
+                { $$ = ast::TypeDecl::Otype; }
         | '&'
                 { $$ = TypeDecl::Dtype; }
+                { $$ = ast::TypeDecl::Dtype; }
         | '*'
                 { $$ = TypeDecl::DStype; }                                              // dtype + sized
+                { $$ = ast::TypeDecl::DStype; }                                         // dtype + sized
         // | '(' '*' ')'
         //      { $$ = TypeDecl::Ftype; }
+        //      { $$ = ast::TypeDecl::Ftype; }
         | ELLIPSIS
                 { $$ = TypeDecl::Ttype; }
+                { $$ = ast::TypeDecl::Ttype; }
+        ;
 type_class:                                                                                             // CFA
         OTYPE
                 { $$ = TypeDecl::Otype; }
+                { $$ = ast::TypeDecl::Otype; }
         | DTYPE
                 { $$ = TypeDecl::Dtype; }
+                { $$ = ast::TypeDecl::Dtype; }
         | FTYPE
                 { $$ = TypeDecl::Ftype; }
+                { $$ = ast::TypeDecl::Ftype; }
         | TTYPE
                 { $$ = TypeDecl::Ttype; }
+                { $$ = ast::TypeDecl::Ttype; }
+        ;
 …
 type_list:                                                                                              // CFA
         type
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression
         | type_list ',' type
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
         | type_list ',' assignment_expression
                 { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
 …
+                {
                         typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
                         $$ = DeclarationNode::newTypeDecl( $1, 0 );
+                        $$ = DeclarationNode::newTypeDecl( $1, nullptr );
+                }
         | identifier_or_type_name '(' type_parameter_list ')'
 …
 trait_specifier:                                                                                // CFA
         TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
+                { $$ = DeclarationNode::newTrait( $2, $4, 0 ); }
+                {
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
+                        $$ = DeclarationNode::newTrait( $2, $4, nullptr );
+                }
+        | forall TRAIT identifier_or_type_name '{' '}'          // alternate
+                { $$ = DeclarationNode::newTrait( $3, $1, nullptr ); }
         | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
+                { $$ = DeclarationNode::newTrait( $2, $4, $8 ); }
+                {
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
+                        $$ = DeclarationNode::newTrait( $2, $4, $8 );
+                }
+        | forall TRAIT identifier_or_type_name '{' push trait_declaration_list pop '}' // alternate
+                { $$ = DeclarationNode::newTrait( $3, $1, $6 ); }
+        ;
 …
 external_definition:
         DIRECTIVE
                 { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( yylloc, $1 ) ) ); }
         | declaration
+                {
+                        // Variable declarations of anonymous types requires creating a unique type-name across multiple translation
+                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
+                        // disallowed at the moment.
+                        if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
+                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
+                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
+                                } else if ( $1->type->aggInst.aggregate->aggregate.anon ) { // handles struct or union
+                                        SemanticError( yylloc, "extern anonymous struct/union is currently unimplemented." ); $$ = nullptr;
+                                }
+                        }
+                }
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
 …
+                }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
                 { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) ); }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( yylloc, false, $3, nullptr ) ) ); }
         | EXTERN STRINGliteral
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                }
           up external_definition down
 …
+                {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
                         linkage = LinkageSpec::update( yylloc, linkage, $2 );
+                        linkage = ast::Linkage::update( yylloc, linkage, $2 );
+                }
           '{' up external_definition_list_opt down '}'
 …
         | type_qualifier_list
+                {
                         if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type->forall ) forall = true;          // remember generic type
+                }
 …
+                {
                         distQual( $5, $1 );
                         forall = false;
+                        forall = false;
                         $$ = $5;
+                }
         | declaration_qualifier_list
+                {
                         if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
+                }
 …
+                {
                         distQual( $5, $1 );
                         forall = false;
+                        forall = false;
                         $$ = $5;
+                }
         | declaration_qualifier_list type_qualifier_list
+                {
                         if ( ($1->type && $1->type->qualifiers.val) || ($2->type && $2->type->qualifiers.val) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
+                }
 …
+                {
                         distQual( $6, $1->addQualifiers( $2 ) );
                         forall = false;
+                        forall = false;
                         $$ = $6;
+                }
 …
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
+                }
         | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
+        | declaration_specifier function_type_redeclarator with_clause_opt compound_statement
+                {
                         rebindForall( $1, $2 );
 …
         | variable_type_redeclarator
         | function_declarator
+        | function_type_redeclarator
+        ;
 subrange:
         constant_expression '~' constant_expression                     // CFA, integer subrange
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild<Expression>( $1 ), maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::RangeExpr( yylloc, maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); }
+        ;
 …
+                {
                         DeclarationNode * name = new DeclarationNode();
                         name->asmName = $3;
+                        name->asmName = maybeMoveBuild( $3 );
                         $$ = name->addQualifiers( $5 );
+                }
 …
 variable_ptr:
         ptrref_operator variable_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
         | '(' attribute_list variable_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
 …
 function_ptr:
         ptrref_operator function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
 KR_function_ptr:
         ptrref_operator KR_function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list KR_function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
+        ;
 // This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
+// This pattern parses a declaration for a variable that redefines a type name, e.g.:
 //
 //              typedef int foo;
 …
 //                 int foo; // redefine typedef name in new scope
 //              }
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
 paren_type:
 …
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | type_ptr
         | type_array attribute_list_opt
+        | variable_type_ptr
+        | variable_type_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | type_function attribute_list_opt
+        | variable_type_function attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        ;
 type_ptr:
+variable_type_ptr:
         ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
+        | '(' variable_type_ptr ')' attribute_list_opt          // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
         | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
+        | '(' attribute_list variable_type_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
 type_array:
+variable_type_array:
         paren_type array_dimension
                 { $$ = $1->addArray( $2 ); }
         | '(' type_ptr ')' array_dimension
+        | '(' variable_type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list type_ptr ')' array_dimension
+        | '(' attribute_list variable_type_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
+        | '(' variable_type_array ')' multi_array_dimension     // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
         | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
+        | '(' attribute_list variable_type_array ')' multi_array_dimension // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')'                                                            // redundant parenthesis
+        | '(' variable_type_array ')'                                           // redundant parenthesis
                 { $$ = $2; }
         | '(' attribute_list type_array ')'                                     // redundant parenthesis
+        | '(' attribute_list variable_type_array ')'            // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
+type_function:
+variable_type_function:
+        '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
+        | '(' variable_type_function ')'                                        // redundant parenthesis
+                { $$ = $2; }
+        | '(' attribute_list variable_type_function ')'         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
+// This pattern parses a declaration for a function prototype that redefines a type name.  It precludes declaring an
+// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
+// arrays and functions.
+function_type_redeclarator:
+        function_type_no_ptr attribute_list_opt
+                { $$ = $1->addQualifiers( $2 ); }
+        | function_type_ptr
+        | function_type_array attribute_list_opt
+                { $$ = $1->addQualifiers( $2 ); }
+        ;
+function_type_no_ptr:
         paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
         | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+        | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
         | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+        | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' type_function ')'                                                         // redundant parenthesis
+        | '(' function_type_no_ptr ')'                                          // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
+        | '(' attribute_list function_type_no_ptr ')'           // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
+function_type_ptr:
+        ptrref_operator function_type_redeclarator
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
+        | ptrref_operator type_qualifier_list function_type_redeclarator
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
+        | '(' function_type_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list function_type_ptr ')' attribute_list_opt
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
+function_type_array:
+        '(' function_type_ptr ')' array_dimension
+                { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_type_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' function_type_array ')' multi_array_dimension     // redundant parenthesis
+                { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_type_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' function_type_array ')'                                           // redundant parenthesis
+                { $$ = $2; }
+        | '(' attribute_list function_type_array ')'            // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
 identifier_parameter_ptr:
         ptrref_operator identifier_parameter_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
 type_parameter_ptr:
         ptrref_operator type_parameter_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
 abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
+                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
                 // Only the first dimension can be empty.
         '[' ']'
                 { $$ = DeclarationNode::newArray( 0, 0, false ); }
+                { $$ = DeclarationNode::newArray( nullptr, nullptr, false ); }
         | '[' ']' multi_array_dimension
                 { $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $3 ); }
+                { $$ = DeclarationNode::newArray( nullptr, nullptr, false )->addArray( $3 ); }
                 // Cannot use constant_expression because of tuples => semantic check
         | '[' push assignment_expression pop ',' comma_expression ']' // CFA
                 { $$ = DeclarationNode::newArray( $3, 0, false )->addArray( DeclarationNode::newArray( $6, 0, false ) ); }
+                { $$ = DeclarationNode::newArray( $3, nullptr, false )->addArray( DeclarationNode::newArray( $6, nullptr, false ) ); }
                 // { SemanticError( yylloc, "New array dimension is currently unimplemented." ); $$ = nullptr; }
         | '[' push array_type_list pop ']'                                      // CFA
 …
 array_type_list:
         basic_type_name
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | type_name
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
+                { $$ = new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression upupeq assignment_expression
         | array_type_list ',' basic_type_name
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' type_name
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
+        | array_type_list ',' type_name
+                { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new ast::TypeExpr( yylloc, maybeMoveBuildType( $3 ) ) ) )); }
         | array_type_list ',' assignment_expression upupeq assignment_expression
+        ;
 …
         | ErangeUpEq
                 { $$ = OperKinds::LEThan; }
+        ;
+        ;
 multi_array_dimension:
         '[' push assignment_expression pop ']'
                 { $$ = DeclarationNode::newArray( $3, 0, false ); }
+                { $$ = DeclarationNode::newArray( $3, nullptr, false ); }
         | '[' push '*' pop ']'                                                          // C99
                 { $$ = DeclarationNode::newVarArray( 0 ); }
         | multi_array_dimension '[' push assignment_expression pop ']'
                 { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
+                { $$ = $1->addArray( DeclarationNode::newArray( $4, nullptr, false ) ); }
         | multi_array_dimension '[' push '*' pop ']'            // C99
                 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
 …
 array_parameter_1st_dimension:
         '[' ']'
                 { $$ = DeclarationNode::newArray( 0, 0, false ); }
+                { $$ = DeclarationNode::newArray( nullptr, nullptr, false ); }
                 // multi_array_dimension handles the '[' '*' ']' case
         | '[' push type_qualifier_list '*' pop ']'                      // remaining C99
                 { $$ = DeclarationNode::newVarArray( $3 ); }
         | '[' push type_qualifier_list pop ']'
                 { $$ = DeclarationNode::newArray( 0, $3, false ); }
+                { $$ = DeclarationNode::newArray( nullptr, $3, false ); }
                 // multi_array_dimension handles the '[' assignment_expression ']' case
         | '[' push type_qualifier_list assignment_expression pop ']'
 …
 variable_abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
+                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator variable_abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
 …
                 // No SUE declaration in parameter list.
         ptrref_operator type_specifier_nobody
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier_nobody
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
 …
                 // shift/reduce conflict with new-style empty (void) function return type.
         '[' ']' type_specifier_nobody
                 { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension type_specifier_nobody
                 { $$ = $2->addNewArray( $1 ); }
         | '[' ']' multi_array_dimension type_specifier_nobody
                 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension multi_array_dimension type_specifier_nobody
                 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
 …
         | '[' ']' cfa_identifier_parameter_ptr
                 { $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension cfa_identifier_parameter_ptr
                 { $$ = $2->addNewArray( $1 ); }
         | '[' ']' multi_array_dimension cfa_identifier_parameter_ptr
                 { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+                { $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
         | cfa_array_parameter_1st_dimension multi_array_dimension cfa_identifier_parameter_ptr
                 { $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
 …
 cfa_abstract_ptr:                                                                               // CFA
         ptrref_operator type_specifier
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }

src/Parser/parserutility.cc

-              r34b4268
+              r24d6572
 // Created On       : Sat May 16 15:30:39 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Jul 18 10:12:00 2017
 // Update Count     : 8
+// Last Modified On : Wed Mar  1 10:42:00 2023
+// Update Count     : 9
 //
 …
 #include <string>                // for string
+#include "SynTree/Constant.h"    // for Constant
+#include "SynTree/Expression.h"  // for UntypedExpr, CastExpr, ConstantExpr
+#include "SynTree/Type.h"        // for BasicType, ZeroType, BasicType::Kind...
+#include "AST/Expr.hpp"          // for UntypedExpr, CastExpr, ConstantExpr
+#include "AST/Type.hpp"          // for BasicType, ZeroType, BasicType::Kind...
 // rewrite
 …
 //    if ( (int)(x != 0) ) ...
+Expression *notZeroExpr( Expression *orig ) {
+        if( !orig ) return nullptr;
+        UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
+        comparison->get_args().push_back( orig );
+        comparison->get_args().push_back( new ConstantExpr( Constant( new ZeroType( noQualifiers ), "0", (unsigned long long int)0 ) ) );
+        return new CastExpr( comparison, new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+ast::Expr * notZeroExpr( ast::Expr * orig ) {
+        return ( !orig ) ? nullptr : new ast::CastExpr( orig->location,
+                ast::UntypedExpr::createCall( orig->location,
+                        "?!=?",
+                        {
+                                orig,
+                                new ast::ConstantExpr( orig->location,
+                                        new ast::ZeroType(),
+                                        "0",
+                                        std::optional<unsigned long long>( 0 )
+                                ),
+                        }
+                ),
+                new ast::BasicType( ast::BasicType::SignedInt )
+        );
+}

src/Parser/parserutility.h

-              r34b4268
+              r24d6572
 // file "LICENCE" distributed with Cforall.
 //
 // parserutility.h --
+// parserutility.h -- Collected utilities for the parser.
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 15:31:46 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:32:58 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Apr  4 14:03:00 2023
+// Update Count     : 7
 //
 #pragma once
+class Expression;
+#include "AST/Copy.hpp"            // for shallowCopy
+namespace ast {
+        class Expr;
+}
+Expression *notZeroExpr( Expression *orig );
+ast::Expr * notZeroExpr( ast::Expr *orig );
+template< typename T >
+static inline auto maybeBuild( T * orig ) -> decltype(orig->build()) {
+        return (orig) ? orig->build() : nullptr;
+}
+template< typename T >
+static inline auto maybeMoveBuild( T * orig ) -> decltype(orig->build()) {
+        auto ret = maybeBuild<T>(orig);
+        delete orig;
+        return ret;
+}
+template<typename node_t>
+node_t * maybeCopy( node_t const * node ) {
+        return node ? ast::shallowCopy( node ) : nullptr;
+}
 // Local Variables: //

Context Navigation

Legend:

src/Parser/DeclarationNode.cc

src/Parser/ExpressionNode.cc

src/Parser/InitializerNode.cc

src/Parser/ParseNode.h

src/Parser/ParserTypes.h

src/Parser/StatementNode.cc

src/Parser/TypeData.cc

src/Parser/TypeData.h

src/Parser/TypedefTable.cc

src/Parser/TypedefTable.h

src/Parser/lex.ll

src/Parser/module.mk

src/Parser/parser.yy

src/Parser/parserutility.cc

src/Parser/parserutility.h

Download in other formats: