Changeset dd020c0

Timestamp:

Mar 3, 2017, 10:12:02 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

8191203

Parents:

f37147b

Message:

first attempt to create function specifiers

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (5 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• CodeGen/FixNames.cc (modified) (4 diffs)
• GenPoly/Box.cc (modified) (3 diffs)
• GenPoly/Specialize.cc (modified) (2 diffs)
• InitTweak/FixGlobalInit.cc (modified) (2 diffs)
• InitTweak/FixInit.cc (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (21 diffs)
• Parser/ParseNode.h (modified) (5 diffs)
• Parser/TypeData.cc (modified) (16 diffs)
• Parser/TypeData.h (modified) (3 diffs)
• Parser/parser.cc (modified) (355 diffs)
• Parser/parser.yy (modified) (3 diffs)
• SymTab/Autogen.cc (modified) (3 diffs)
• SymTab/Validate.cc (modified) (3 diffs)
• SynTree/Declaration.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (8 diffs)
• SynTree/DeclarationWithType.cc (modified) (2 diffs)
• SynTree/FunctionDecl.cc (modified) (4 diffs)
• SynTree/NamedTypeDecl.cc (modified) (3 diffs)
• SynTree/ObjectDecl.cc (modified) (4 diffs)
• SynTree/Type.h (modified) (3 diffs)

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:56:29 2017
-// Update Count     : 418
+// Last Modified On : Fri Mar  3 21:18:47 2017
+// Update Count     : 465
 //
 
@@ -134 +134 @@
 
                 handleStorageClass( functionDecl );
-                if ( functionDecl->get_isInline() ) {
-                        output << "inline ";
-                } // if
-                if ( functionDecl->get_isNoreturn() ) {
-                        output << "_Noreturn ";
-                } // if
+                DeclarationNode::print_FuncSpec( output, functionDecl->get_funcSpec() );
+
                 output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty );
 
@@ -835 +831 @@
         }
 
-
         void CodeGenerator::visit( ReturnStmt * returnStmt ) {
                 output << "return ";
@@ -899 +894 @@
         }
 
-        void CodeGenerator::handleStorageClass( Declaration * decl ) {
+        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
                 switch ( decl->get_storageClass() ) {
+                        //output << DeclarationNode::storageClassNames[decl->get_storageClass()] << ' ';
                   case DeclarationNode::Extern:
                         output << "extern ";
@@ -913 +909 @@
                         output << "register ";
                         break;
-                  case DeclarationNode::Inline:
-                        output << "inline ";
-                        break;
-                  case DeclarationNode::Fortran:
-                        output << "fortran ";
-                        break;
-                  case DeclarationNode::Noreturn:
-                        output << "_Noreturn ";
-                        break;
                   case DeclarationNode::Threadlocal:
-                        output << "_Thread_local ";
-                        break;
+                        output << "_Thread_local ";
+                        break;
                   case DeclarationNode::NoStorageClass:
                         break;
+                  default:
+                        assert( false );
                 } // switch
-        }
+        } // CodeGenerator::handleStorageClass
 
         std::string genName( DeclarationWithType * decl ) {

src/CodeGen/CodeGenerator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  9 15:06:21 2017
-// Update Count     : 49
+// Last Modified On : Wed Mar  1 16:20:04 2017
+// Update Count     : 50
 //
 
@@ -123 +123 @@
 
                 void printDesignators( std::list< Expression * > & );
-                void handleStorageClass( Declaration *decl );
+                void handleStorageClass( DeclarationWithType *decl );
                 void handleAggregate( AggregateDecl *aggDecl );
                 void handleTypedef( NamedTypeDecl *namedType );

src/CodeGen/FixNames.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Mon Apr 11 15:38:10 2016
-// Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar  3 21:52:17 2017
+// Update Count     : 6
 //
 
@@ -44 +44 @@
                         LinkageSpec::Cforall, 
                         main_type = new FunctionType( Type::Qualifiers(), true ), 
-                        nullptr, false, false
+                        nullptr
                 ) };
                 main_type->get_returnVals().push_back( 
@@ -50 +50 @@
                 );
 
-                auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
+                auto && name = SymTab::Mangler::mangle( mainDecl.get() );
                 // std::cerr << name << std::endl;
                 return name;
@@ -61 +61 @@
                         LinkageSpec::Cforall, 
                         main_type = new FunctionType( Type::Qualifiers(), false ), 
-                        nullptr, false, false
+                        nullptr
                 ) };
                 main_type->get_returnVals().push_back( 

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:57:16 2017
-// Update Count     : 297
+// Last Modified On : Fri Mar  3 21:57:15 2017
+// Update Count     : 310
 //
 
@@ -299 +299 @@
                 // because each unit generates copies of the default routines for each aggregate.
                 FunctionDecl *layoutDecl = new FunctionDecl(
-                        layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
+                        layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
+                        std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
@@ -910 +911 @@
                         adapterBody->get_kids().push_back( bodyStmt );
                         std::string adapterName = makeAdapterName( mangleName );
-                        return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false, false );
+                        return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody );
                 }
 

src/GenPoly/Specialize.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Thu Apr 28 15:17:45 2016
-// Update Count     : 24
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar  3 21:54:45 2017
+// Update Count     : 28
 //
 
@@ -155 +155 @@
                 } // if
                 // create new thunk with same signature as formal type (C linkage, empty body)
-                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ), false, false );
+                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
                 thunkFunc->fixUniqueId();
 

src/InitTweak/FixGlobalInit.cc

@@ -10 +10 @@
 // Created On       : Mon May 04 15:14:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 29 22:33:15 2016
-// Update Count     : 4
+// Last Modified On : Fri Mar  3 21:55:33 2017
+// Update Count     : 9
 //
 
@@ -87 +87 @@
                         dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
                 }
-                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
+                initFunction = new FunctionDecl( "_init_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                 initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
+                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                 destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
         }

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:58:43 2017
-// Update Count     : 35
+// Last Modified On : Fri Mar  3 21:56:11 2017
+// Update Count     : 39
 //
 
@@ -731 +731 @@
 
                                                         // void __objName_dtor_atexitN(...) {...}
-                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
+                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                                                         dtorCaller->fixUniqueId();
                                                         dtorCaller->get_statements()->push_back( dtorStmt );

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 22:21:06 2017
-// Update Count     : 775
+// Last Modified On : Fri Mar  3 21:38:34 2017
+// Update Count     : 862
 //
 
@@ -32 +32 @@
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
-const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
-const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
-const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
-const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
-const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
-const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
-const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
-const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
+const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "inline", "fortran", "_Noreturn", "NoStorageClassNames" };
+const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
+const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoTypeQualifierNames" };
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
+const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
+const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
+const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
+const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" };
+const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
+const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
@@ -50 +51 @@
                 storageClass( NoStorageClass ),
                 bitfieldWidth( nullptr ),
-                isInline( false ),
-                isNoreturn( false ),
                 hasEllipsis( false ),
                 linkage( ::linkage ),
@@ -92 +91 @@
         newnode->storageClass = storageClass;
         newnode->bitfieldWidth = maybeClone( bitfieldWidth );
-        newnode->isInline = isInline;
-        newnode->isNoreturn = isNoreturn;
+        newnode->funcSpec = funcSpec;
         newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
         newnode->hasEllipsis = hasEllipsis;
@@ -118 +116 @@
 }
 
+void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpec funcSpec ) {
+        if ( funcSpec.any() ) {                                                         // function specifiers?
+                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
+                        if ( funcSpec[i] ) {
+                                output << DeclarationNode::funcSpecifierNames[i] << ' ';
+                        } // if
+                } // for
+        } // if
+} // print_FuncSpec
+
 void DeclarationNode::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' );
@@ -130 +138 @@
         } // if
 
-        if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' ';
-        if ( isInline ) os << DeclarationNode::storageName[Inline] << ' ';
-        if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' ';
+        if ( storageClass != NoStorageClass ) os << DeclarationNode::storageClassNames[storageClass] << ' ';
+        print_FuncSpec( os, funcSpec );
+
         if ( type ) {
                 type->print( os, indent );
@@ -183 +191 @@
 } // DeclarationNode::newFunction
 
-DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
+
+DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->storageClass = sc;
+        return newnode;
+} // DeclarationNode::newStorageClass
+
+DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->funcSpec[ fs ] = true;
+        return newnode;
+} // DeclarationNode::newFuncSpecifier
+
+DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
-        newnode->type->qualifiers[ q ] = 1;
+        newnode->type->typeQualifiers[ tq ] = true;
         return newnode;
 } // DeclarationNode::newQualifier
+
+DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->basictype = bt;
+        return newnode;
+} // DeclarationNode::newBasicType
+
+DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->complextype = ct;
+        return newnode;
+} // DeclarationNode::newComplexType
+
+DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->signedness = sn;
+        return newnode;
+} // DeclarationNode::newSignedNess
+
+DeclarationNode * DeclarationNode::newLength( Length lnth ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->length = lnth;
+        return newnode;
+} // DeclarationNode::newLength
 
 DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
@@ -196 +245 @@
         return newnode;
 } // DeclarationNode::newForall
-
-DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->storageClass = sc;
-        return newnode;
-} // DeclarationNode::newStorageClass
-
-DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basictype = bt;
-        return newnode;
-} // DeclarationNode::newBasicType
-
-DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->complextype = ct;
-        return newnode;
-} // DeclarationNode::newComplexType
-
-DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->signedness = sn;
-        return newnode;
-} // DeclarationNode::newSignedNess
-
-DeclarationNode * DeclarationNode::newLength( Length lnth ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->length = lnth;
-        return newnode;
-} // DeclarationNode::newLength
 
 DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
@@ -428 +443 @@
 
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
-        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
-
-        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
-                for ( int i = 0; i < NoQualifier; i += 1 ) {    // find common qualifiers
+        const TypeData::TypeQualifiers &qsrc = src->typeQualifiers, &qdst = dst->typeQualifiers; // optimization
+
+        if ( (qsrc & qdst).any() ) {                                             // common qualifier ?
+                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
                         if ( qsrc[i] && qdst[i] ) {
-                                appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
+                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
                         } // if
                 } // for
@@ -440 +455 @@
 
 void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
+        const FuncSpec &src = funcSpec, &dst = q->funcSpec; // optimization
+        if ( (src & dst).any() ) {                                                      // common specifier ?
+                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
+                        if ( src[i] && dst[i] ) {
+                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
+                        } // if
+                } // for
+        } // if
+
         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
-                        appendError( error, string( "duplicate " ) + storageName[ storageClass ] );
+                        appendError( error, string( "duplicate " ) + storageClassNames[ storageClass ] );
                 } else {                                                                                // only one storage class
-                        appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
+                        appendError( error, string( "conflicting " ) + storageClassNames[ storageClass ] + " & " + storageClassNames[ q->storageClass ] );
                         q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
                 } // if
         } // if
+
         appendError( error, q->error );
 } // DeclarationNode::checkStorageClasses
 
 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
-        isInline = isInline || q->isInline;
-        isNoreturn = isNoreturn || q->isNoreturn;
+        funcSpec = funcSpec | q->funcSpec;
+
         // do not overwrite an existing value with NoStorageClass
         if ( q->storageClass != NoStorageClass ) {
@@ -481 +506 @@
                 src = nullptr;
         } else {
-                dst->qualifiers |= src->qualifiers;
+                dst->typeQualifiers |= src->typeQualifiers;
         } // if
 } // addQualifiersToType
@@ -539 +564 @@
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
-                        src->qualifiers |= dst->qualifiers;
+                        src->typeQualifiers |= dst->typeQualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
-                        dst->qualifiers |= src->qualifiers;
+                        dst->typeQualifiers |= src->typeQualifiers;
                         if ( src->kind != TypeData::Unknown ) {
                                 assert( src->kind == TypeData::Basic );
@@ -551 +576 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -568 +593 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
                         } // if
                         break;
@@ -580 +605 @@
                                         dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
                                 } // if
-                                dst->base->qualifiers |= src->qualifiers;
+                                dst->base->typeQualifiers |= src->typeQualifiers;
                                 src = nullptr;
                                 break;
@@ -612 +637 @@
                                                 type->aggInst.hoistType = o->type->enumeration.body;
                                         } // if
-                                        type->qualifiers |= o->type->qualifiers;
+                                        type->typeQualifiers |= o->type->typeQualifiers;
                                 } else {
                                         type = o->type;
@@ -768 +793 @@
                                         p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                p->type->base->qualifiers |= type->qualifiers;
+                                p->type->base->typeQualifiers |= type->typeQualifiers;
                                 break;
 
@@ -805 +830 @@
                                         lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                lastArray->base->qualifiers |= type->qualifiers;
+                                lastArray->base->typeQualifiers |= type->typeQualifiers;
                                 break;
                           default:
@@ -1005 +1030 @@
         } // if
 
-//      if ( variable.name ) {
         if ( variable.tyClass != NoTypeClass ) {
                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
                 assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "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( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
                 TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
                 buildList( variable.assertions, ret->get_assertions() );
@@ -1017 +1040 @@
 
         if ( type ) {
-                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
-        } // if
-
-        if ( ! isInline && ! isNoreturn ) {
-                assertf( name, "ObjectDecl are assumed to have names\n" );
-                return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
-        } // if
-
-        throw SemanticError( "invalid function specifier ", this );
+                // Function specifiers can only appear on a function definition/declaration.
+                //
+                //    inline _Noreturn int f();                 // allowed
+                //    inline _Noreturn int g( int i );  // allowed
+                //    inline _Noreturn int i;                   // disallowed
+                if ( type->kind != TypeData::Function && funcSpec.any() ) {
+                        throw SemanticError( "invalid function specifier for ", this );
+                } // if
+                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), funcSpec, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+        } // if
+
+        // SUE's cannot have function specifiers, either
+        //
+        //    inlne _Noreturn struct S { ... };         // disallowed
+        //    inlne _Noreturn enum   E { ... };         // disallowed
+        if ( funcSpec.any() ) {
+                throw SemanticError( "invalid function specifier for ", this );
+        } // if
+        assertf( name, "ObjectDecl must a have name\n" );
+        return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
 }
 
@@ -1032 +1066 @@
 
         if ( attr.expr ) {
-//              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
                 return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
         } else if ( attr.type ) {
-//              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
                 return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
         } // if

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 15:22:10 2017
-// Update Count     : 662
+// Last Modified On : Fri Mar  3 21:34:27 2017
+// Update Count     : 704
 //
 
@@ -19 +19 @@
 #include <string>
 #include <list>
+#include <bitset>
 #include <iterator>
 #include <memory>
@@ -203 +204 @@
         // These must remain in the same order as the corresponding DeclarationNode names.
 
-        // enum StorageClass { Extern, Static, Auto, Register, NoStorageClass };
-        // enum FunctionSpec { Inline, Fortran, Noreturn, NoFunctionSpec };
-        // enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Threadlocal, Mutex, NoQualifier };
-
-        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
-        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
+        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass };
+        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
+                                        InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
+        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoTypeQualifier };
         enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
         enum ComplexType { Complex, Imaginary, NoComplexType };
@@ -217 +216 @@
         enum BuiltinType { Valist, Zero, One, NoBuiltinType };
 
-        static const char * storageName[];
-        static const char * qualifierName[];
-        static const char * basicTypeName[];
-        static const char * complexTypeName[];
-        static const char * signednessName[];
-        static const char * lengthName[];
-        static const char * aggregateName[];
-        static const char * typeClassName[];
-        static const char * builtinTypeName[];
-
-        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
-        static DeclarationNode * newQualifier( Qualifier );
-        static DeclarationNode * newForall( DeclarationNode * );
+        static const char * storageClassNames[];
+        static const char * funcSpecifierNames[];
+        static const char * typeQualifierNames[];
+        static const char * basicTypeNames[];
+        static const char * complexTypeNames[];
+        static const char * signednessNames[];
+        static const char * lengthNames[];
+        static const char * aggregateNames[];
+        static const char * typeClassNames[];
+        static const char * builtinTypeNames[];
+
         static DeclarationNode * newStorageClass( StorageClass );
+        static DeclarationNode * newFuncSpecifier( FuncSpecifier );
+        static DeclarationNode * newTypeQualifier( TypeQualifier );
         static DeclarationNode * newBasicType( BasicType );
         static DeclarationNode * newComplexType( ComplexType );
-        static DeclarationNode * newSignedNess( Signedness sn );
-        static DeclarationNode * newLength( Length lnth );
+        static DeclarationNode * newSignedNess( Signedness );
+        static DeclarationNode * newLength( Length );
         static DeclarationNode * newBuiltinType( BuiltinType );
+        static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newFromTypedef( std::string * );
+        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
@@ -324 +325 @@
         TypeData * type;
         StorageClass storageClass;
+
+        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpec;
+        FuncSpec funcSpec;
+        static void print_FuncSpec( std::ostream & output, FuncSpec funcSpec );
+
         ExpressionNode * bitfieldWidth;
-        bool isInline, isNoreturn;
         std::unique_ptr<ExpressionNode> enumeratorValue;
         bool hasEllipsis;

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 21:48:55 2017
-// Update Count     : 485
+// Last Modified On : Fri Mar  3 21:59:10 2017
+// Update Count     : 516
 //
 
@@ -157 +157 @@
 TypeData * TypeData::clone() const {
         TypeData * newtype = new TypeData( kind );
-        newtype->qualifiers = qualifiers;
+        newtype->typeQualifiers = typeQualifiers;
         newtype->base = maybeClone( base );
         newtype->forall = maybeClone( forall );
@@ -226 +226 @@
 
 void TypeData::print( ostream &os, int indent ) const {
-        for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
-                if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
+        for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) {
+                if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
         } // for
 
@@ -250 +250 @@
                 break;
           case Basic:
-                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " ";
-                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " ";
+                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
+                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
                 assert( basictype != DeclarationNode::NoBasicType );
-                os << DeclarationNode::basicTypeName[ basictype ] << " ";
-                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " ";
+                os << DeclarationNode::basicTypeNames[ basictype ] << " ";
+                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " ";
                 break;
           case Array:
@@ -301 +301 @@
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
+                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters " << endl;
@@ -399 +399 @@
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
                         dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr ) );
 
                         // add copy ctor:  void ?{}(T *, T)
@@ -405 +405 @@
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr ) );
 
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
                         ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr ) );
 
                         // add assignment operator:  T * ?=?(T *, T)
@@ -417 +417 @@
                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr ) );
                 } // if
         } // for
@@ -494 +494 @@
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
         Type::Qualifiers q;
-        q.isConst = td->qualifiers[ DeclarationNode::Const ];
-        q.isVolatile = td->qualifiers[ DeclarationNode::Volatile ];
-        q.isRestrict = td->qualifiers[ DeclarationNode::Restrict ];
-        q.isLvalue = td->qualifiers[ DeclarationNode::Lvalue ];
-        q.isAtomic = td->qualifiers[ DeclarationNode::Atomic ];;
+        q.isConst = td->typeQualifiers[ DeclarationNode::Const ];
+        q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ];
+        q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ];
+        q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ];
+        q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];;
         return q;
 } // buildQualifiers
@@ -516 +516 @@
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
 
@@ -532 +532 @@
 
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
 
@@ -562 +562 @@
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
@@ -784 +784 @@
 } // buildTypeof
 
-Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
@@ -793 +793 @@
                 Statement * stmt = maybeBuild<Statement>( td->function.body );
                 CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
-                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn, attributes );
+                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, attributes, funcSpec );
                 return decl->set_asmName( asmName );
         } else if ( td->kind == TypeData::Aggregate ) {
@@ -802 +802 @@
                 return buildSymbolic( td, name, sc );
         } else {
-                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes, isInline, isNoreturn ))->set_asmName( asmName );
+                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
         } // if
         return nullptr;
@@ -820 +820 @@
                         break;
                   default:
-                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) );
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base, "", DeclarationNode::NoStorageClass, nullptr, DeclarationNode::FuncSpecifier(), LinkageSpec::Cforall, nullptr ) ) );
                 } // switch
         } else {

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 17:14:46 2017
-// Update Count     : 158
+// Last Modified On : Fri Mar  3 20:56:53 2017
+// Update Count     : 167
 //
 
@@ -76 +76 @@
         DeclarationNode::Length length = DeclarationNode::NoLength;
         DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
-        typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers;
-        Qualifiers qualifiers;
+        typedef std::bitset< DeclarationNode::NoTypeQualifier > TypeQualifiers;
+        TypeQualifiers typeQualifiers;
         DeclarationNode * forall;
 
@@ -113 +113 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, DeclarationNode::FuncSpec funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );

src/Parser/parser.cc

@@ -892 +892 @@
      240,   299,   115,    -1,   242,    -1,   237,   242,    -1,   241,
      237,   242,    -1,   243,    -1,   242,   243,    -1,     5,    -1,
-       7,    -1,     4,    -1,     6,    -1,     8,    -1,     9,    -1,
-      72,    -1,    74,    -1,    16,    -1,    21,    -1,    20,    -1,
+       7,    -1,     4,    -1,     6,    -1,    74,    -1,     8,    -1,
+       9,    -1,    72,    -1,    16,    -1,    21,    -1,    20,    -1,
       18,    -1,    19,    -1,    17,    -1,    22,    -1,    23,    -1,
       15,    -1,    27,    -1,    28,    -1,    29,    -1,    26,    -1,
@@ -1092 +1092 @@
     1391,  1396,  1397,  1401,  1403,  1405,  1407,  1409,  1412,  1411,
     1423,  1424,  1426,  1436,  1437,  1442,  1444,  1446,  1448,  1450,
-    1453,  1455,  1458,  1463,  1465,  1467,  1469,  1471,  1473,  1475,
-    1477,  1479,  1481,  1483,  1485,  1487,  1489,  1491,  1497,  1498,
-    1500,  1502,  1504,  1509,  1510,  1516,  1517,  1519,  1521,  1526,
-    1528,  1530,  1532,  1537,  1538,  1540,  1542,  1547,  1548,  1550,
-    1555,  1556,  1558,  1560,  1565,  1566,  1568,  1573,  1574,  1576,
-    1578,  1583,  1585,  1587,  1592,  1593,  1597,  1598,  1602,  1605,
-    1604,  1608,  1610,  1614,  1619,  1624,  1626,  1632,  1633,  1638,
-    1639,  1644,  1647,  1655,  1656,  1658,  1660,  1665,  1666,  1672,
-    1673,  1675,  1678,  1681,  1686,  1687,  1692,  1697,  1700,  1699,
-    1703,  1707,  1715,  1717,  1723,  1724,  1732,  1733,  1737,  1738,
-    1739,  1741,  1743,  1750,  1751,  1753,  1755,  1760,  1761,  1767,
-    1768,  1772,  1773,  1778,  1779,  1780,  1782,  1790,  1791,  1793,
-    1796,  1798,  1802,  1803,  1804,  1806,  1808,  1813,  1818,  1826,
-    1828,  1837,  1839,  1844,  1845,  1846,  1850,  1851,  1852,  1856,
-    1857,  1858,  1862,  1863,  1864,  1869,  1870,  1875,  1876,  1878,
-    1883,  1884,  1889,  1890,  1891,  1892,  1893,  1908,  1909,  1914,
-    1915,  1921,  1923,  1926,  1928,  1930,  1953,  1954,  1956,  1958,
-    1963,  1964,  1966,  1971,  1976,  1977,  1983,  1982,  1986,  1990,
-    1992,  1994,  1996,  2002,  2003,  2008,  2013,  2015,  2020,  2022,
-    2023,  2025,  2030,  2032,  2034,  2039,  2041,  2046,  2051,  2059,
-    2065,  2064,  2078,  2079,  2084,  2085,  2089,  2094,  2099,  2107,
-    2112,  2123,  2124,  2129,  2130,  2136,  2137,  2141,  2142,  2143,
-    2148,  2147,  2158,  2166,  2172,  2178,  2187,  2193,  2199,  2205,
-    2211,  2219,  2225,  2233,  2239,  2248,  2249,  2250,  2254,  2260,
-    2261,  2271,  2272,  2276,  2277,  2282,  2287,  2288,  2294,  2295,
-    2297,  2302,  2303,  2304,  2305,  2340,  2342,  2343,  2345,  2350,
-    2355,  2360,  2362,  2364,  2369,  2371,  2373,  2375,  2380,  2382,
-    2391,  2393,  2394,  2399,  2401,  2403,  2408,  2410,  2412,  2417,
-    2419,  2421,  2433,  2434,  2435,  2439,  2441,  2443,  2448,  2450,
-    2452,  2457,  2459,  2461,  2476,  2478,  2479,  2481,  2486,  2487,
-    2492,  2494,  2496,  2501,  2503,  2505,  2507,  2512,  2514,  2516,
-    2526,  2528,  2529,  2531,  2536,  2538,  2540,  2545,  2547,  2549,
-    2551,  2556,  2558,  2560,  2573,  2575,  2576,  2578,  2583,  2588,
-    2596,  2598,  2600,  2605,  2607,  2612,  2614,  2631,  2632,  2634,
-    2639,  2641,  2643,  2645,  2647,  2652,  2653,  2655,  2657,  2662,
-    2664,  2666,  2672,  2674,  2676,  2680,  2682,  2684,  2686,  2720,
-    2721,  2723,  2728,  2730,  2732,  2734,  2736,  2741,  2742,  2744,
-    2746,  2751,  2753,  2755,  2761,  2762,  2764,  2773,  2776,  2778,
-    2781,  2783,  2785,  2799,  2800,  2802,  2807,  2809,  2811,  2813,
-    2815,  2820,  2821,  2823,  2825,  2830,  2832,  2840,  2841,  2842,
-    2847,  2848,  2853,  2855,  2857,  2859,  2861,  2863,  2870,  2872,
-    2874,  2876,  2878,  2881,  2883,  2885,  2887,  2889,  2894,  2896,
-    2898,  2903,  2929,  2930,  2932,  2936,  2937,  2941,  2943,  2945,
-    2947,  2949,  2951,  2958,  2960,  2962,  2964,  2966,  2968,  2973,
-    2980,  2982,  3000,  3002,  3007,  3008
+    1453,  1455,  1457,  1462,  1464,  1466,  1468,  1470,  1472,  1474,
+    1476,  1478,  1480,  1482,  1484,  1486,  1488,  1490,  1496,  1497,
+    1499,  1501,  1503,  1508,  1509,  1515,  1516,  1518,  1520,  1525,
+    1527,  1529,  1531,  1536,  1537,  1539,  1541,  1546,  1547,  1549,
+    1554,  1555,  1557,  1559,  1564,  1565,  1567,  1572,  1573,  1575,
+    1577,  1582,  1584,  1586,  1591,  1592,  1596,  1597,  1601,  1604,
+    1603,  1607,  1609,  1613,  1618,  1623,  1625,  1631,  1632,  1637,
+    1638,  1643,  1646,  1654,  1655,  1657,  1659,  1664,  1665,  1671,
+    1672,  1674,  1677,  1680,  1685,  1686,  1691,  1696,  1699,  1698,
+    1702,  1706,  1714,  1716,  1722,  1723,  1731,  1732,  1736,  1737,
+    1738,  1740,  1742,  1749,  1750,  1752,  1754,  1759,  1760,  1766,
+    1767,  1771,  1772,  1777,  1778,  1779,  1781,  1789,  1790,  1792,
+    1795,  1797,  1801,  1802,  1803,  1805,  1807,  1812,  1817,  1825,
+    1827,  1836,  1838,  1843,  1844,  1845,  1849,  1850,  1851,  1855,
+    1856,  1857,  1861,  1862,  1863,  1868,  1869,  1874,  1875,  1877,
+    1882,  1883,  1888,  1889,  1890,  1891,  1892,  1907,  1908,  1913,
+    1914,  1920,  1922,  1925,  1927,  1929,  1952,  1953,  1955,  1957,
+    1962,  1963,  1965,  1970,  1975,  1976,  1982,  1981,  1985,  1989,
+    1991,  1993,  1995,  2001,  2002,  2007,  2012,  2014,  2019,  2021,
+    2022,  2024,  2029,  2031,  2033,  2038,  2040,  2045,  2050,  2058,
+    2064,  2063,  2077,  2078,  2083,  2084,  2088,  2093,  2098,  2106,
+    2111,  2122,  2123,  2128,  2129,  2135,  2136,  2140,  2141,  2142,
+    2147,  2146,  2157,  2165,  2171,  2177,  2186,  2192,  2198,  2204,
+    2210,  2218,  2224,  2232,  2238,  2247,  2248,  2249,  2253,  2259,
+    2260,  2270,  2271,  2275,  2276,  2281,  2286,  2287,  2293,  2294,
+    2296,  2301,  2302,  2303,  2304,  2339,  2341,  2342,  2344,  2349,
+    2354,  2359,  2361,  2363,  2368,  2370,  2372,  2374,  2379,  2381,
+    2390,  2392,  2393,  2398,  2400,  2402,  2407,  2409,  2411,  2416,
+    2418,  2420,  2432,  2433,  2434,  2438,  2440,  2442,  2447,  2449,
+    2451,  2456,  2458,  2460,  2475,  2477,  2478,  2480,  2485,  2486,
+    2491,  2493,  2495,  2500,  2502,  2504,  2506,  2511,  2513,  2515,
+    2525,  2527,  2528,  2530,  2535,  2537,  2539,  2544,  2546,  2548,
+    2550,  2555,  2557,  2559,  2572,  2574,  2575,  2577,  2582,  2587,
+    2595,  2597,  2599,  2604,  2606,  2611,  2613,  2630,  2631,  2633,
+    2638,  2640,  2642,  2644,  2646,  2651,  2652,  2654,  2656,  2661,
+    2663,  2665,  2671,  2673,  2675,  2679,  2681,  2683,  2685,  2719,
+    2720,  2722,  2727,  2729,  2731,  2733,  2735,  2740,  2741,  2743,
+    2745,  2750,  2752,  2754,  2760,  2761,  2763,  2772,  2775,  2777,
+    2780,  2782,  2784,  2798,  2799,  2801,  2806,  2808,  2810,  2812,
+    2814,  2819,  2820,  2822,  2824,  2829,  2831,  2839,  2840,  2841,
+    2846,  2847,  2852,  2854,  2856,  2858,  2860,  2862,  2869,  2871,
+    2873,  2875,  2877,  2880,  2882,  2884,  2886,  2888,  2893,  2895,
+    2897,  2902,  2928,  2929,  2931,  2935,  2936,  2940,  2942,  2944,
+    2946,  2948,  2950,  2957,  2959,  2961,  2963,  2965,  2967,  2972,
+    2979,  2981,  2999,  3001,  3006,  3007
 };
 #endif
@@ -1451 +1451 @@
 static const yytype_uint16 yydefact[] =
 {
-     307,   307,   327,   325,   328,   326,   329,   330,   313,   315,
+     307,   307,   327,   325,   328,   326,   330,   331,   313,   315,
      314,     0,   316,   341,   333,   338,   336,   337,   335,   334,
      339,   340,   346,   347,   345,   342,   343,   344,   571,   395,
-     396,     0,     0,     0,   307,     0,   317,   331,   332,     9,
+     396,     0,     0,     0,   307,     0,   317,   332,   329,     9,
      381,     0,    10,    16,    17,     0,     2,    72,    73,   589,
       11,   307,   547,   253,     3,   477,     3,   266,     0,     3,
@@ -6909 +6909 @@
 /* Line 1806 of yacc.c  */
 #line 1402 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
     break;
 
@@ -6916 +6916 @@
 /* Line 1806 of yacc.c  */
 #line 1404 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
     break;
 
@@ -6923 +6923 @@
 /* Line 1806 of yacc.c  */
 #line 1406 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
     break;
 
@@ -6930 +6930 @@
 /* Line 1806 of yacc.c  */
 #line 1408 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
     break;
 
@@ -6937 +6937 @@
 /* Line 1806 of yacc.c  */
 #line 1410 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
     break;
 
@@ -7011 +7011 @@
 
 /* Line 1806 of yacc.c  */
-#line 1452 "parser.yy"
-    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
+#line 1451 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     break;
 
@@ -7019 +7019 @@
 /* Line 1806 of yacc.c  */
 #line 1454 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
+    { (yyval.decl) = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); }
     break;
 
@@ -7025 +7025 @@
 
 /* Line 1806 of yacc.c  */
-#line 1457 "parser.yy"
-    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
+#line 1456 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFuncSpecifier( DeclarationNode::Fortran ); }
     break;
 
@@ -7032 +7032 @@
 
 /* Line 1806 of yacc.c  */
-#line 1459 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
+#line 1458 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFuncSpecifier( DeclarationNode::Noreturn ); }
     break;
 
@@ -7039 +7039 @@
 
 /* Line 1806 of yacc.c  */
-#line 1464 "parser.yy"
+#line 1463 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     break;
@@ -7046 +7046 @@
 
 /* Line 1806 of yacc.c  */
-#line 1466 "parser.yy"
+#line 1465 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     break;
@@ -7053 +7053 @@
 
 /* Line 1806 of yacc.c  */
-#line 1468 "parser.yy"
+#line 1467 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     break;
@@ -7060 +7060 @@
 
 /* Line 1806 of yacc.c  */
-#line 1470 "parser.yy"
+#line 1469 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     break;
@@ -7067 +7067 @@
 
 /* Line 1806 of yacc.c  */
-#line 1472 "parser.yy"
+#line 1471 "parser.yy"
     { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
     break;
@@ -7074 +7074 @@
 
 /* Line 1806 of yacc.c  */
-#line 1474 "parser.yy"
+#line 1473 "parser.yy"
     { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
     break;
@@ -7081 +7081 @@
 
 /* Line 1806 of yacc.c  */
-#line 1476 "parser.yy"
+#line 1475 "parser.yy"
     { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
     break;
@@ -7088 +7088 @@
 
 /* Line 1806 of yacc.c  */
-#line 1478 "parser.yy"
+#line 1477 "parser.yy"
     { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
     break;
@@ -7095 +7095 @@
 
 /* Line 1806 of yacc.c  */
-#line 1480 "parser.yy"
+#line 1479 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     break;
@@ -7102 +7102 @@
 
 /* Line 1806 of yacc.c  */
-#line 1482 "parser.yy"
+#line 1481 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     break;
@@ -7109 +7109 @@
 
 /* Line 1806 of yacc.c  */
-#line 1484 "parser.yy"
+#line 1483 "parser.yy"
     { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
     break;
@@ -7116 +7116 @@
 
 /* Line 1806 of yacc.c  */
-#line 1486 "parser.yy"
+#line 1485 "parser.yy"
     { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
     break;
@@ -7123 +7123 @@
 
 /* Line 1806 of yacc.c  */
-#line 1488 "parser.yy"
+#line 1487 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
     break;
@@ -7130 +7130 @@
 
 /* Line 1806 of yacc.c  */
-#line 1490 "parser.yy"
+#line 1489 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
     break;
@@ -7137 +7137 @@
 
 /* Line 1806 of yacc.c  */
-#line 1492 "parser.yy"
+#line 1491 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
     break;
@@ -7144 +7144 @@
 
 /* Line 1806 of yacc.c  */
-#line 1499 "parser.yy"
+#line 1498 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7151 +7151 @@
 
 /* Line 1806 of yacc.c  */
-#line 1501 "parser.yy"
+#line 1500 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7158 +7158 @@
 
 /* Line 1806 of yacc.c  */
-#line 1503 "parser.yy"
+#line 1502 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7165 +7165 @@
 
 /* Line 1806 of yacc.c  */
-#line 1505 "parser.yy"
+#line 1504 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -7172 +7172 @@
 
 /* Line 1806 of yacc.c  */
-#line 1511 "parser.yy"
+#line 1510 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7179 +7179 @@
 
 /* Line 1806 of yacc.c  */
-#line 1518 "parser.yy"
+#line 1517 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7186 +7186 @@
 
 /* Line 1806 of yacc.c  */
-#line 1520 "parser.yy"
+#line 1519 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7193 +7193 @@
 
 /* Line 1806 of yacc.c  */
-#line 1522 "parser.yy"
+#line 1521 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7200 +7200 @@
 
 /* Line 1806 of yacc.c  */
-#line 1527 "parser.yy"
+#line 1526 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     break;
@@ -7207 +7207 @@
 
 /* Line 1806 of yacc.c  */
-#line 1529 "parser.yy"
+#line 1528 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     break;
@@ -7214 +7214 @@
 
 /* Line 1806 of yacc.c  */
-#line 1531 "parser.yy"
+#line 1530 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
     break;
@@ -7221 +7221 @@
 
 /* Line 1806 of yacc.c  */
-#line 1533 "parser.yy"
+#line 1532 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     break;
@@ -7228 +7228 @@
 
 /* Line 1806 of yacc.c  */
-#line 1539 "parser.yy"
+#line 1538 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7235 +7235 @@
 
 /* Line 1806 of yacc.c  */
-#line 1541 "parser.yy"
+#line 1540 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7242 +7242 @@
 
 /* Line 1806 of yacc.c  */
-#line 1543 "parser.yy"
+#line 1542 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7249 +7249 @@
 
 /* Line 1806 of yacc.c  */
-#line 1549 "parser.yy"
+#line 1548 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7256 +7256 @@
 
 /* Line 1806 of yacc.c  */
-#line 1551 "parser.yy"
+#line 1550 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7263 +7263 @@
 
 /* Line 1806 of yacc.c  */
-#line 1557 "parser.yy"
+#line 1556 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7270 +7270 @@
 
 /* Line 1806 of yacc.c  */
-#line 1559 "parser.yy"
+#line 1558 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7277 +7277 @@
 
 /* Line 1806 of yacc.c  */
-#line 1561 "parser.yy"
+#line 1560 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7284 +7284 @@
 
 /* Line 1806 of yacc.c  */
-#line 1567 "parser.yy"
+#line 1566 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7291 +7291 @@
 
 /* Line 1806 of yacc.c  */
-#line 1569 "parser.yy"
+#line 1568 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7298 +7298 @@
 
 /* Line 1806 of yacc.c  */
-#line 1575 "parser.yy"
+#line 1574 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7305 +7305 @@
 
 /* Line 1806 of yacc.c  */
-#line 1577 "parser.yy"
+#line 1576 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7312 +7312 @@
 
 /* Line 1806 of yacc.c  */
-#line 1579 "parser.yy"
+#line 1578 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7319 +7319 @@
 
 /* Line 1806 of yacc.c  */
-#line 1584 "parser.yy"
+#line 1583 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -7326 +7326 @@
 
 /* Line 1806 of yacc.c  */
-#line 1586 "parser.yy"
+#line 1585 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7333 +7333 @@
 
 /* Line 1806 of yacc.c  */
-#line 1588 "parser.yy"
+#line 1587 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7340 +7340 @@
 
 /* Line 1806 of yacc.c  */
-#line 1603 "parser.yy"
+#line 1602 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (5)].aggKey), nullptr, nullptr, (yyvsp[(4) - (5)].decl), true )->addQualifiers( (yyvsp[(2) - (5)].decl) ); }
     break;
@@ -7347 +7347 @@
 
 /* Line 1806 of yacc.c  */
-#line 1605 "parser.yy"
+#line 1604 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); }
     break;
@@ -7354 +7354 @@
 
 /* Line 1806 of yacc.c  */
-#line 1607 "parser.yy"
+#line 1606 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), (yyvsp[(3) - (7)].tok), nullptr, (yyvsp[(6) - (7)].decl), true )->addQualifiers( (yyvsp[(2) - (7)].decl) ); }
     break;
@@ -7361 +7361 @@
 
 /* Line 1806 of yacc.c  */
-#line 1609 "parser.yy"
+#line 1608 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (8)].aggKey), nullptr, (yyvsp[(4) - (8)].en), (yyvsp[(7) - (8)].decl), false )->addQualifiers( (yyvsp[(2) - (8)].decl) ); }
     break;
@@ -7368 +7368 @@
 
 /* Line 1806 of yacc.c  */
-#line 1615 "parser.yy"
+#line 1614 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) );
@@ -7378 +7378 @@
 
 /* Line 1806 of yacc.c  */
-#line 1620 "parser.yy"
+#line 1619 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) ); }
     break;
@@ -7385 +7385 @@
 
 /* Line 1806 of yacc.c  */
-#line 1625 "parser.yy"
+#line 1624 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Struct; }
     break;
@@ -7392 +7392 @@
 
 /* Line 1806 of yacc.c  */
-#line 1627 "parser.yy"
+#line 1626 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Union; }
     break;
@@ -7399 +7399 @@
 
 /* Line 1806 of yacc.c  */
-#line 1632 "parser.yy"
+#line 1631 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7406 +7406 @@
 
 /* Line 1806 of yacc.c  */
-#line 1634 "parser.yy"
+#line 1633 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl) ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     break;
@@ -7413 +7413 @@
 
 /* Line 1806 of yacc.c  */
-#line 1640 "parser.yy"
+#line 1639 "parser.yy"
     {
                         distExt( (yyvsp[(2) - (3)].decl) );                                                             // mark all fields in list
@@ -7423 +7423 @@
 
 /* Line 1806 of yacc.c  */
-#line 1645 "parser.yy"
+#line 1644 "parser.yy"
     {
                         (yyval.decl) = distAttr( (yyvsp[(1) - (3)].decl), (yyvsp[(2) - (3)].decl) ); }
@@ -7431 +7431 @@
 
 /* Line 1806 of yacc.c  */
-#line 1648 "parser.yy"
+#line 1647 "parser.yy"
     {
                         distExt( (yyvsp[(3) - (4)].decl) );                                                             // mark all fields in list
@@ -7441 +7441 @@
 
 /* Line 1806 of yacc.c  */
-#line 1657 "parser.yy"
+#line 1656 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     break;
@@ -7448 +7448 @@
 
 /* Line 1806 of yacc.c  */
-#line 1659 "parser.yy"
+#line 1658 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
     break;
@@ -7455 +7455 @@
 
 /* Line 1806 of yacc.c  */
-#line 1661 "parser.yy"
+#line 1660 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
     break;
@@ -7462 +7462 @@
 
 /* Line 1806 of yacc.c  */
-#line 1667 "parser.yy"
+#line 1666 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(4) - (4)].decl)->addQualifiers( (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -7469 +7469 @@
 
 /* Line 1806 of yacc.c  */
-#line 1672 "parser.yy"
+#line 1671 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     break;
@@ -7476 +7476 @@
 
 /* Line 1806 of yacc.c  */
-#line 1674 "parser.yy"
+#line 1673 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     break;
@@ -7483 +7483 @@
 
 /* Line 1806 of yacc.c  */
-#line 1677 "parser.yy"
+#line 1676 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7490 +7490 @@
 
 /* Line 1806 of yacc.c  */
-#line 1680 "parser.yy"
+#line 1679 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7497 +7497 @@
 
 /* Line 1806 of yacc.c  */
-#line 1686 "parser.yy"
+#line 1685 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -7504 +7504 @@
 
 /* Line 1806 of yacc.c  */
-#line 1688 "parser.yy"
+#line 1687 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -7511 +7511 @@
 
 /* Line 1806 of yacc.c  */
-#line 1693 "parser.yy"
+#line 1692 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7518 +7518 @@
 
 /* Line 1806 of yacc.c  */
-#line 1698 "parser.yy"
+#line 1697 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(4) - (6)].decl), true )->addQualifiers( (yyvsp[(2) - (6)].decl) ); }
     break;
@@ -7525 +7525 @@
 
 /* Line 1806 of yacc.c  */
-#line 1700 "parser.yy"
+#line 1699 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); }
     break;
@@ -7532 +7532 @@
 
 /* Line 1806 of yacc.c  */
-#line 1702 "parser.yy"
+#line 1701 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(3) - (8)].tok), (yyvsp[(6) - (8)].decl), true )->addQualifiers( (yyvsp[(2) - (8)].decl) ); }
     break;
@@ -7539 +7539 @@
 
 /* Line 1806 of yacc.c  */
-#line 1708 "parser.yy"
+#line 1707 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) );
@@ -7549 +7549 @@
 
 /* Line 1806 of yacc.c  */
-#line 1716 "parser.yy"
+#line 1715 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7556 +7556 @@
 
 /* Line 1806 of yacc.c  */
-#line 1718 "parser.yy"
+#line 1717 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -7563 +7563 @@
 
 /* Line 1806 of yacc.c  */
-#line 1723 "parser.yy"
+#line 1722 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -7570 +7570 @@
 
 /* Line 1806 of yacc.c  */
-#line 1725 "parser.yy"
+#line 1724 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7577 +7577 @@
 
 /* Line 1806 of yacc.c  */
-#line 1732 "parser.yy"
+#line 1731 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7584 +7584 @@
 
 /* Line 1806 of yacc.c  */
-#line 1740 "parser.yy"
+#line 1739 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7591 +7591 @@
 
 /* Line 1806 of yacc.c  */
-#line 1742 "parser.yy"
+#line 1741 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7598 +7598 @@
 
 /* Line 1806 of yacc.c  */
-#line 1744 "parser.yy"
+#line 1743 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7605 +7605 @@
 
 /* Line 1806 of yacc.c  */
-#line 1752 "parser.yy"
+#line 1751 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7612 +7612 @@
 
 /* Line 1806 of yacc.c  */
-#line 1754 "parser.yy"
+#line 1753 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7619 +7619 @@
 
 /* Line 1806 of yacc.c  */
-#line 1756 "parser.yy"
+#line 1755 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     break;
@@ -7626 +7626 @@
 
 /* Line 1806 of yacc.c  */
-#line 1762 "parser.yy"
+#line 1761 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7633 +7633 @@
 
 /* Line 1806 of yacc.c  */
-#line 1767 "parser.yy"
+#line 1766 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7640 +7640 @@
 
 /* Line 1806 of yacc.c  */
-#line 1774 "parser.yy"
+#line 1773 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7647 +7647 @@
 
 /* Line 1806 of yacc.c  */
-#line 1781 "parser.yy"
+#line 1780 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7654 +7654 @@
 
 /* Line 1806 of yacc.c  */
-#line 1783 "parser.yy"
+#line 1782 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7661 +7661 @@
 
 /* Line 1806 of yacc.c  */
-#line 1792 "parser.yy"
+#line 1791 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
@@ -7668 +7668 @@
 
 /* Line 1806 of yacc.c  */
-#line 1795 "parser.yy"
+#line 1794 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
@@ -7675 +7675 @@
 
 /* Line 1806 of yacc.c  */
-#line 1797 "parser.yy"
+#line 1796 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
     break;
@@ -7682 +7682 @@
 
 /* Line 1806 of yacc.c  */
-#line 1807 "parser.yy"
+#line 1806 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7689 +7689 @@
 
 /* Line 1806 of yacc.c  */
-#line 1814 "parser.yy"
+#line 1813 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7699 +7699 @@
 
 /* Line 1806 of yacc.c  */
-#line 1819 "parser.yy"
+#line 1818 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7709 +7709 @@
 
 /* Line 1806 of yacc.c  */
-#line 1827 "parser.yy"
+#line 1826 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addInitializer( (yyvsp[(2) - (2)].en) ? new InitializerNode( (yyvsp[(2) - (2)].en) ) : nullptr ); }
     break;
@@ -7716 +7716 @@
 
 /* Line 1806 of yacc.c  */
-#line 1829 "parser.yy"
+#line 1828 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addType( (yyvsp[(1) - (3)].decl) )->addInitializer( (yyvsp[(3) - (3)].en) ? new InitializerNode( (yyvsp[(3) - (3)].en) ) : nullptr ); }
     break;
@@ -7723 +7723 @@
 
 /* Line 1806 of yacc.c  */
-#line 1838 "parser.yy"
+#line 1837 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -7730 +7730 @@
 
 /* Line 1806 of yacc.c  */
-#line 1840 "parser.yy"
+#line 1839 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
     break;
@@ -7737 +7737 @@
 
 /* Line 1806 of yacc.c  */
-#line 1865 "parser.yy"
+#line 1864 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7744 +7744 @@
 
 /* Line 1806 of yacc.c  */
-#line 1875 "parser.yy"
+#line 1874 "parser.yy"
     { (yyval.in) = nullptr; }
     break;
@@ -7751 +7751 @@
 
 /* Line 1806 of yacc.c  */
-#line 1877 "parser.yy"
+#line 1876 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in); }
     break;
@@ -7758 +7758 @@
 
 /* Line 1806 of yacc.c  */
-#line 1879 "parser.yy"
+#line 1878 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     break;
@@ -7765 +7765 @@
 
 /* Line 1806 of yacc.c  */
+#line 1882 "parser.yy"
+    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
+    break;
+
+  case 481:
+
+/* Line 1806 of yacc.c  */
 #line 1883 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
-    break;
-
-  case 481:
-
-/* Line 1806 of yacc.c  */
-#line 1884 "parser.yy"
     { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
     break;
@@ -7779 +7779 @@
 
 /* Line 1806 of yacc.c  */
-#line 1889 "parser.yy"
+#line 1888 "parser.yy"
     { (yyval.in) = nullptr; }
     break;
@@ -7786 +7786 @@
 
 /* Line 1806 of yacc.c  */
+#line 1890 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
+    break;
+
+  case 485:
+
+/* Line 1806 of yacc.c  */
 #line 1891 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
-    break;
-
-  case 485:
-
-/* Line 1806 of yacc.c  */
-#line 1892 "parser.yy"
     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
     break;
@@ -7800 +7800 @@
 
 /* Line 1806 of yacc.c  */
-#line 1894 "parser.yy"
+#line 1893 "parser.yy"
     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
     break;
@@ -7807 +7807 @@
 
 /* Line 1806 of yacc.c  */
-#line 1910 "parser.yy"
+#line 1909 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
     break;
@@ -7814 +7814 @@
 
 /* Line 1806 of yacc.c  */
-#line 1916 "parser.yy"
+#line 1915 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -7821 +7821 @@
 
 /* Line 1806 of yacc.c  */
-#line 1922 "parser.yy"
+#line 1921 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
     break;
@@ -7828 +7828 @@
 
 /* Line 1806 of yacc.c  */
-#line 1925 "parser.yy"
+#line 1924 "parser.yy"
     { (yyval.en) = (yyvsp[(3) - (5)].en); }
     break;
@@ -7835 +7835 @@
 
 /* Line 1806 of yacc.c  */
-#line 1927 "parser.yy"
+#line 1926 "parser.yy"
     { (yyval.en) = (yyvsp[(3) - (5)].en); }
     break;
@@ -7842 +7842 @@
 
 /* Line 1806 of yacc.c  */
-#line 1929 "parser.yy"
+#line 1928 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
     break;
@@ -7849 +7849 @@
 
 /* Line 1806 of yacc.c  */
-#line 1931 "parser.yy"
+#line 1930 "parser.yy"
     { (yyval.en) = (yyvsp[(4) - (6)].en); }
     break;
@@ -7856 +7856 @@
 
 /* Line 1806 of yacc.c  */
-#line 1955 "parser.yy"
+#line 1954 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7863 +7863 @@
 
 /* Line 1806 of yacc.c  */
-#line 1957 "parser.yy"
+#line 1956 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7870 +7870 @@
 
 /* Line 1806 of yacc.c  */
-#line 1959 "parser.yy"
+#line 1958 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7877 +7877 @@
 
 /* Line 1806 of yacc.c  */
-#line 1965 "parser.yy"
+#line 1964 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7884 +7884 @@
 
 /* Line 1806 of yacc.c  */
-#line 1967 "parser.yy"
+#line 1966 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7891 +7891 @@
 
 /* Line 1806 of yacc.c  */
-#line 1972 "parser.yy"
+#line 1971 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     break;
@@ -7898 +7898 @@
 
 /* Line 1806 of yacc.c  */
-#line 1978 "parser.yy"
+#line 1977 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
     break;
@@ -7905 +7905 @@
 
 /* Line 1806 of yacc.c  */
-#line 1983 "parser.yy"
+#line 1982 "parser.yy"
     { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
     break;
@@ -7912 +7912 @@
 
 /* Line 1806 of yacc.c  */
-#line 1985 "parser.yy"
+#line 1984 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -7919 +7919 @@
 
 /* Line 1806 of yacc.c  */
-#line 1991 "parser.yy"
+#line 1990 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Otype; }
     break;
@@ -7926 +7926 @@
 
 /* Line 1806 of yacc.c  */
-#line 1993 "parser.yy"
+#line 1992 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Dtype; }
     break;
@@ -7933 +7933 @@
 
 /* Line 1806 of yacc.c  */
-#line 1995 "parser.yy"
+#line 1994 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Ftype; }
     break;
@@ -7940 +7940 @@
 
 /* Line 1806 of yacc.c  */
-#line 1997 "parser.yy"
+#line 1996 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Ttype; }
     break;
@@ -7947 +7947 @@
 
 /* Line 1806 of yacc.c  */
-#line 2002 "parser.yy"
+#line 2001 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7954 +7954 @@
 
 /* Line 1806 of yacc.c  */
-#line 2004 "parser.yy"
+#line 2003 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl) ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     break;
@@ -7961 +7961 @@
 
 /* Line 1806 of yacc.c  */
-#line 2009 "parser.yy"
+#line 2008 "parser.yy"
     {
                         typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
@@ -7971 +7971 @@
 
 /* Line 1806 of yacc.c  */
-#line 2014 "parser.yy"
+#line 2013 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
     break;
@@ -7978 +7978 @@
 
 /* Line 1806 of yacc.c  */
-#line 2016 "parser.yy"
+#line 2015 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7985 +7985 @@
 
 /* Line 1806 of yacc.c  */
-#line 2021 "parser.yy"
+#line 2020 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
     break;
@@ -7992 +7992 @@
 
 /* Line 1806 of yacc.c  */
-#line 2024 "parser.yy"
+#line 2023 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
     break;
@@ -7999 +7999 @@
 
 /* Line 1806 of yacc.c  */
-#line 2026 "parser.yy"
+#line 2025 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
@@ -8006 +8006 @@
 
 /* Line 1806 of yacc.c  */
-#line 2031 "parser.yy"
+#line 2030 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
@@ -8013 +8013 @@
 
 /* Line 1806 of yacc.c  */
-#line 2033 "parser.yy"
+#line 2032 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -8020 +8020 @@
 
 /* Line 1806 of yacc.c  */
-#line 2035 "parser.yy"
+#line 2034 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -8027 +8027 @@
 
 /* Line 1806 of yacc.c  */
-#line 2040 "parser.yy"
+#line 2039 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8034 +8034 @@
 
 /* Line 1806 of yacc.c  */
-#line 2042 "parser.yy"
+#line 2041 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8041 +8041 @@
 
 /* Line 1806 of yacc.c  */
-#line 2047 "parser.yy"
+#line 2046 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
@@ -8051 +8051 @@
 
 /* Line 1806 of yacc.c  */
-#line 2052 "parser.yy"
+#line 2051 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
@@ -8061 +8061 @@
 
 /* Line 1806 of yacc.c  */
-#line 2060 "parser.yy"
+#line 2059 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
@@ -8071 +8071 @@
 
 /* Line 1806 of yacc.c  */
-#line 2065 "parser.yy"
+#line 2064 "parser.yy"
     {
                         typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
@@ -8081 +8081 @@
 
 /* Line 1806 of yacc.c  */
-#line 2070 "parser.yy"
+#line 2069 "parser.yy"
     {
                         typedefTable.leaveTrait();
@@ -8092 +8092 @@
 
 /* Line 1806 of yacc.c  */
-#line 2080 "parser.yy"
+#line 2079 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -8099 +8099 @@
 
 /* Line 1806 of yacc.c  */
-#line 2090 "parser.yy"
+#line 2089 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8109 +8109 @@
 
 /* Line 1806 of yacc.c  */
-#line 2095 "parser.yy"
+#line 2094 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8119 +8119 @@
 
 /* Line 1806 of yacc.c  */
-#line 2100 "parser.yy"
+#line 2099 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -8129 +8129 @@
 
 /* Line 1806 of yacc.c  */
-#line 2108 "parser.yy"
+#line 2107 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8139 +8139 @@
 
 /* Line 1806 of yacc.c  */
-#line 2113 "parser.yy"
+#line 2112 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8149 +8149 @@
 
 /* Line 1806 of yacc.c  */
-#line 2123 "parser.yy"
+#line 2122 "parser.yy"
     {}
     break;
@@ -8156 +8156 @@
 
 /* Line 1806 of yacc.c  */
-#line 2125 "parser.yy"
+#line 2124 "parser.yy"
     { parseTree = parseTree ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);       }
     break;
@@ -8163 +8163 @@
 
 /* Line 1806 of yacc.c  */
-#line 2131 "parser.yy"
+#line 2130 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
     break;
@@ -8170 +8170 @@
 
 /* Line 1806 of yacc.c  */
-#line 2136 "parser.yy"
+#line 2135 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8177 +8177 @@
 
 /* Line 1806 of yacc.c  */
-#line 2144 "parser.yy"
+#line 2143 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newAsmStmt( new StatementNode( build_asmstmt( false, (yyvsp[(3) - (5)].constant), 0 ) ) );
@@ -8186 +8186 @@
 
 /* Line 1806 of yacc.c  */
-#line 2148 "parser.yy"
+#line 2147 "parser.yy"
     {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
@@ -8196 +8196 @@
 
 /* Line 1806 of yacc.c  */
-#line 2153 "parser.yy"
+#line 2152 "parser.yy"
     {
                         linkage = linkageStack.top();
@@ -8207 +8207 @@
 
 /* Line 1806 of yacc.c  */
-#line 2159 "parser.yy"
+#line 2158 "parser.yy"
     {
                         distExt( (yyvsp[(2) - (2)].decl) );                                                             // mark all fields in list
@@ -8217 +8217 @@
 
 /* Line 1806 of yacc.c  */
-#line 2173 "parser.yy"
+#line 2172 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8228 +8228 @@
 
 /* Line 1806 of yacc.c  */
-#line 2179 "parser.yy"
+#line 2178 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8239 +8239 @@
 
 /* Line 1806 of yacc.c  */
-#line 2188 "parser.yy"
+#line 2187 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8250 +8250 @@
 
 /* Line 1806 of yacc.c  */
-#line 2194 "parser.yy"
+#line 2193 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8261 +8261 @@
 
 /* Line 1806 of yacc.c  */
-#line 2200 "parser.yy"
+#line 2199 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8272 +8272 @@
 
 /* Line 1806 of yacc.c  */
-#line 2206 "parser.yy"
+#line 2205 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8283 +8283 @@
 
 /* Line 1806 of yacc.c  */
-#line 2212 "parser.yy"
+#line 2211 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8294 +8294 @@
 
 /* Line 1806 of yacc.c  */
-#line 2220 "parser.yy"
+#line 2219 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8305 +8305 @@
 
 /* Line 1806 of yacc.c  */
-#line 2226 "parser.yy"
+#line 2225 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8316 +8316 @@
 
 /* Line 1806 of yacc.c  */
-#line 2234 "parser.yy"
+#line 2233 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8327 +8327 @@
 
 /* Line 1806 of yacc.c  */
-#line 2240 "parser.yy"
+#line 2239 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8338 +8338 @@
 
 /* Line 1806 of yacc.c  */
-#line 2255 "parser.yy"
+#line 2254 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -8345 +8345 @@
 
 /* Line 1806 of yacc.c  */
-#line 2260 "parser.yy"
+#line 2259 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8352 +8352 @@
 
 /* Line 1806 of yacc.c  */
-#line 2262 "parser.yy"
+#line 2261 "parser.yy"
     {
                         DeclarationNode * name = new DeclarationNode();
@@ -8363 +8363 @@
 
 /* Line 1806 of yacc.c  */
-#line 2271 "parser.yy"
+#line 2270 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8370 +8370 @@
 
 /* Line 1806 of yacc.c  */
-#line 2278 "parser.yy"
+#line 2277 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -8377 +8377 @@
 
 /* Line 1806 of yacc.c  */
-#line 2283 "parser.yy"
+#line 2282 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (6)].decl); }
     break;
@@ -8384 +8384 @@
 
 /* Line 1806 of yacc.c  */
-#line 2289 "parser.yy"
+#line 2288 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -8391 +8391 @@
 
 /* Line 1806 of yacc.c  */
-#line 2294 "parser.yy"
+#line 2293 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8398 +8398 @@
 
 /* Line 1806 of yacc.c  */
-#line 2296 "parser.yy"
+#line 2295 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttribute( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -8405 +8405 @@
 
 /* Line 1806 of yacc.c  */
-#line 2298 "parser.yy"
+#line 2297 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttribute( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     break;
@@ -8412 +8412 @@
 
 /* Line 1806 of yacc.c  */
-#line 2306 "parser.yy"
+#line 2305 "parser.yy"
     { (yyval.tok) = Token{ new string( "__const__" ) }; }
     break;
@@ -8419 +8419 @@
 
 /* Line 1806 of yacc.c  */
-#line 2341 "parser.yy"
+#line 2340 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8426 +8426 @@
 
 /* Line 1806 of yacc.c  */
-#line 2344 "parser.yy"
+#line 2343 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8433 +8433 @@
 
 /* Line 1806 of yacc.c  */
-#line 2346 "parser.yy"
+#line 2345 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8440 +8440 @@
 
 /* Line 1806 of yacc.c  */
-#line 2351 "parser.yy"
+#line 2350 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8450 +8450 @@
 
 /* Line 1806 of yacc.c  */
-#line 2356 "parser.yy"
+#line 2355 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8457 +8457 @@
 
 /* Line 1806 of yacc.c  */
-#line 2361 "parser.yy"
+#line 2360 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8464 +8464 @@
 
 /* Line 1806 of yacc.c  */
-#line 2363 "parser.yy"
+#line 2362 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8471 +8471 @@
 
 /* Line 1806 of yacc.c  */
-#line 2365 "parser.yy"
+#line 2364 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8478 +8478 @@
 
 /* Line 1806 of yacc.c  */
-#line 2370 "parser.yy"
+#line 2369 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8485 +8485 @@
 
 /* Line 1806 of yacc.c  */
-#line 2372 "parser.yy"
+#line 2371 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8492 +8492 @@
 
 /* Line 1806 of yacc.c  */
-#line 2374 "parser.yy"
+#line 2373 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8499 +8499 @@
 
 /* Line 1806 of yacc.c  */
-#line 2376 "parser.yy"
+#line 2375 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8506 +8506 @@
 
 /* Line 1806 of yacc.c  */
-#line 2381 "parser.yy"
+#line 2380 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8513 +8513 @@
 
 /* Line 1806 of yacc.c  */
-#line 2383 "parser.yy"
+#line 2382 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8520 +8520 @@
 
 /* Line 1806 of yacc.c  */
-#line 2392 "parser.yy"
+#line 2391 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8527 +8527 @@
 
 /* Line 1806 of yacc.c  */
-#line 2395 "parser.yy"
+#line 2394 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8534 +8534 @@
 
 /* Line 1806 of yacc.c  */
-#line 2400 "parser.yy"
+#line 2399 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
@@ -8541 +8541 @@
 
 /* Line 1806 of yacc.c  */
-#line 2402 "parser.yy"
+#line 2401 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8548 +8548 @@
 
 /* Line 1806 of yacc.c  */
-#line 2404 "parser.yy"
+#line 2403 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8555 +8555 @@
 
 /* Line 1806 of yacc.c  */
-#line 2409 "parser.yy"
+#line 2408 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8562 +8562 @@
 
 /* Line 1806 of yacc.c  */
-#line 2411 "parser.yy"
+#line 2410 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8569 +8569 @@
 
 /* Line 1806 of yacc.c  */
-#line 2413 "parser.yy"
+#line 2412 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8576 +8576 @@
 
 /* Line 1806 of yacc.c  */
-#line 2418 "parser.yy"
+#line 2417 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8583 +8583 @@
 
 /* Line 1806 of yacc.c  */
-#line 2420 "parser.yy"
+#line 2419 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8590 +8590 @@
 
 /* Line 1806 of yacc.c  */
-#line 2422 "parser.yy"
+#line 2421 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8597 +8597 @@
 
 /* Line 1806 of yacc.c  */
-#line 2440 "parser.yy"
+#line 2439 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     break;
@@ -8604 +8604 @@
 
 /* Line 1806 of yacc.c  */
-#line 2442 "parser.yy"
+#line 2441 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8611 +8611 @@
 
 /* Line 1806 of yacc.c  */
-#line 2444 "parser.yy"
+#line 2443 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8618 +8618 @@
 
 /* Line 1806 of yacc.c  */
-#line 2449 "parser.yy"
+#line 2448 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8625 +8625 @@
 
 /* Line 1806 of yacc.c  */
-#line 2451 "parser.yy"
+#line 2450 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8632 +8632 @@
 
 /* Line 1806 of yacc.c  */
-#line 2453 "parser.yy"
+#line 2452 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8639 +8639 @@
 
 /* Line 1806 of yacc.c  */
-#line 2458 "parser.yy"
+#line 2457 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8646 +8646 @@
 
 /* Line 1806 of yacc.c  */
-#line 2460 "parser.yy"
+#line 2459 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8653 +8653 @@
 
 /* Line 1806 of yacc.c  */
-#line 2462 "parser.yy"
+#line 2461 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8660 +8660 @@
 
 /* Line 1806 of yacc.c  */
-#line 2477 "parser.yy"
+#line 2476 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8667 +8667 @@
 
 /* Line 1806 of yacc.c  */
-#line 2480 "parser.yy"
+#line 2479 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8674 +8674 @@
 
 /* Line 1806 of yacc.c  */
-#line 2482 "parser.yy"
+#line 2481 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8681 +8681 @@
 
 /* Line 1806 of yacc.c  */
-#line 2488 "parser.yy"
+#line 2487 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8688 +8688 @@
 
 /* Line 1806 of yacc.c  */
-#line 2493 "parser.yy"
+#line 2492 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8695 +8695 @@
 
 /* Line 1806 of yacc.c  */
-#line 2495 "parser.yy"
+#line 2494 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8702 +8702 @@
 
 /* Line 1806 of yacc.c  */
-#line 2497 "parser.yy"
+#line 2496 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8709 +8709 @@
 
 /* Line 1806 of yacc.c  */
-#line 2502 "parser.yy"
+#line 2501 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8716 +8716 @@
 
 /* Line 1806 of yacc.c  */
-#line 2504 "parser.yy"
+#line 2503 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8723 +8723 @@
 
 /* Line 1806 of yacc.c  */
-#line 2506 "parser.yy"
+#line 2505 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8730 +8730 @@
 
 /* Line 1806 of yacc.c  */
-#line 2508 "parser.yy"
+#line 2507 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8737 +8737 @@
 
 /* Line 1806 of yacc.c  */
-#line 2513 "parser.yy"
+#line 2512 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
@@ -8744 +8744 @@
 
 /* Line 1806 of yacc.c  */
-#line 2515 "parser.yy"
+#line 2514 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8751 +8751 @@
 
 /* Line 1806 of yacc.c  */
-#line 2517 "parser.yy"
+#line 2516 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8758 +8758 @@
 
 /* Line 1806 of yacc.c  */
-#line 2527 "parser.yy"
+#line 2526 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8765 +8765 @@
 
 /* Line 1806 of yacc.c  */
-#line 2530 "parser.yy"
+#line 2529 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8772 +8772 @@
 
 /* Line 1806 of yacc.c  */
-#line 2532 "parser.yy"
+#line 2531 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8779 +8779 @@
 
 /* Line 1806 of yacc.c  */
-#line 2537 "parser.yy"
+#line 2536 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8786 +8786 @@
 
 /* Line 1806 of yacc.c  */
-#line 2539 "parser.yy"
+#line 2538 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8793 +8793 @@
 
 /* Line 1806 of yacc.c  */
-#line 2541 "parser.yy"
+#line 2540 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8800 +8800 @@
 
 /* Line 1806 of yacc.c  */
-#line 2546 "parser.yy"
+#line 2545 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8807 +8807 @@
 
 /* Line 1806 of yacc.c  */
-#line 2548 "parser.yy"
+#line 2547 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8814 +8814 @@
 
 /* Line 1806 of yacc.c  */
-#line 2550 "parser.yy"
+#line 2549 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8821 +8821 @@
 
 /* Line 1806 of yacc.c  */
-#line 2552 "parser.yy"
+#line 2551 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8828 +8828 @@
 
 /* Line 1806 of yacc.c  */
-#line 2557 "parser.yy"
+#line 2556 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
@@ -8835 +8835 @@
 
 /* Line 1806 of yacc.c  */
-#line 2559 "parser.yy"
+#line 2558 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8842 +8842 @@
 
 /* Line 1806 of yacc.c  */
-#line 2561 "parser.yy"
+#line 2560 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8849 +8849 @@
 
 /* Line 1806 of yacc.c  */
-#line 2574 "parser.yy"
+#line 2573 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8856 +8856 @@
 
 /* Line 1806 of yacc.c  */
-#line 2577 "parser.yy"
+#line 2576 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8863 +8863 @@
 
 /* Line 1806 of yacc.c  */
-#line 2579 "parser.yy"
+#line 2578 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8870 +8870 @@
 
 /* Line 1806 of yacc.c  */
-#line 2584 "parser.yy"
+#line 2583 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8880 +8880 @@
 
 /* Line 1806 of yacc.c  */
-#line 2589 "parser.yy"
+#line 2588 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8890 +8890 @@
 
 /* Line 1806 of yacc.c  */
-#line 2597 "parser.yy"
+#line 2596 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8897 +8897 @@
 
 /* Line 1806 of yacc.c  */
-#line 2599 "parser.yy"
+#line 2598 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8904 +8904 @@
 
 /* Line 1806 of yacc.c  */
-#line 2601 "parser.yy"
+#line 2600 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8911 +8911 @@
 
 /* Line 1806 of yacc.c  */
-#line 2606 "parser.yy"
+#line 2605 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8918 +8918 @@
 
 /* Line 1806 of yacc.c  */
-#line 2608 "parser.yy"
+#line 2607 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8925 +8925 @@
 
 /* Line 1806 of yacc.c  */
-#line 2613 "parser.yy"
+#line 2612 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
@@ -8932 +8932 @@
 
 /* Line 1806 of yacc.c  */
-#line 2615 "parser.yy"
+#line 2614 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8939 +8939 @@
 
 /* Line 1806 of yacc.c  */
-#line 2633 "parser.yy"
+#line 2632 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8946 +8946 @@
 
 /* Line 1806 of yacc.c  */
-#line 2635 "parser.yy"
+#line 2634 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8953 +8953 @@
 
 /* Line 1806 of yacc.c  */
-#line 2640 "parser.yy"
+#line 2639 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
@@ -8960 +8960 @@
 
 /* Line 1806 of yacc.c  */
-#line 2642 "parser.yy"
+#line 2641 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8967 +8967 @@
 
 /* Line 1806 of yacc.c  */
-#line 2644 "parser.yy"
+#line 2643 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8974 +8974 @@
 
 /* Line 1806 of yacc.c  */
-#line 2646 "parser.yy"
+#line 2645 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8981 +8981 @@
 
 /* Line 1806 of yacc.c  */
-#line 2648 "parser.yy"
+#line 2647 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8988 +8988 @@
 
 /* Line 1806 of yacc.c  */
-#line 2654 "parser.yy"
+#line 2653 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8995 +8995 @@
 
 /* Line 1806 of yacc.c  */
-#line 2656 "parser.yy"
+#line 2655 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9002 +9002 @@
 
 /* Line 1806 of yacc.c  */
-#line 2658 "parser.yy"
+#line 2657 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9009 +9009 @@
 
 /* Line 1806 of yacc.c  */
-#line 2663 "parser.yy"
+#line 2662 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
     break;
@@ -9016 +9016 @@
 
 /* Line 1806 of yacc.c  */
-#line 2665 "parser.yy"
+#line 2664 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -9023 +9023 @@
 
 /* Line 1806 of yacc.c  */
-#line 2667 "parser.yy"
+#line 2666 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9030 +9030 @@
 
 /* Line 1806 of yacc.c  */
-#line 2673 "parser.yy"
+#line 2672 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     break;
@@ -9037 +9037 @@
 
 /* Line 1806 of yacc.c  */
-#line 2675 "parser.yy"
+#line 2674 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -9044 +9044 @@
 
 /* Line 1806 of yacc.c  */
-#line 2681 "parser.yy"
+#line 2680 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
     break;
@@ -9051 +9051 @@
 
 /* Line 1806 of yacc.c  */
-#line 2683 "parser.yy"
+#line 2682 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     break;
@@ -9058 +9058 @@
 
 /* Line 1806 of yacc.c  */
-#line 2685 "parser.yy"
+#line 2684 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
     break;
@@ -9065 +9065 @@
 
 /* Line 1806 of yacc.c  */
-#line 2687 "parser.yy"
+#line 2686 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
     break;
@@ -9072 +9072 @@
 
 /* Line 1806 of yacc.c  */
-#line 2722 "parser.yy"
+#line 2721 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9079 +9079 @@
 
 /* Line 1806 of yacc.c  */
-#line 2724 "parser.yy"
+#line 2723 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9086 +9086 @@
 
 /* Line 1806 of yacc.c  */
-#line 2729 "parser.yy"
+#line 2728 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( nullptr ); }
     break;
@@ -9093 +9093 @@
 
 /* Line 1806 of yacc.c  */
-#line 2731 "parser.yy"
+#line 2730 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9100 +9100 @@
 
 /* Line 1806 of yacc.c  */
-#line 2733 "parser.yy"
+#line 2732 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( nullptr ) ); }
     break;
@@ -9107 +9107 @@
 
 /* Line 1806 of yacc.c  */
-#line 2735 "parser.yy"
+#line 2734 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -9114 +9114 @@
 
 /* Line 1806 of yacc.c  */
-#line 2737 "parser.yy"
+#line 2736 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9121 +9121 @@
 
 /* Line 1806 of yacc.c  */
-#line 2743 "parser.yy"
+#line 2742 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9128 +9128 @@
 
 /* Line 1806 of yacc.c  */
-#line 2745 "parser.yy"
+#line 2744 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9135 +9135 @@
 
 /* Line 1806 of yacc.c  */
-#line 2747 "parser.yy"
+#line 2746 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9142 +9142 @@
 
 /* Line 1806 of yacc.c  */
-#line 2752 "parser.yy"
+#line 2751 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
     break;
@@ -9149 +9149 @@
 
 /* Line 1806 of yacc.c  */
-#line 2754 "parser.yy"
+#line 2753 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -9156 +9156 @@
 
 /* Line 1806 of yacc.c  */
-#line 2756 "parser.yy"
+#line 2755 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9163 +9163 @@
 
 /* Line 1806 of yacc.c  */
-#line 2763 "parser.yy"
+#line 2762 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9170 +9170 @@
 
 /* Line 1806 of yacc.c  */
-#line 2774 "parser.yy"
+#line 2773 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     break;
@@ -9177 +9177 @@
 
 /* Line 1806 of yacc.c  */
-#line 2777 "parser.yy"
+#line 2776 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     break;
@@ -9184 +9184 @@
 
 /* Line 1806 of yacc.c  */
-#line 2779 "parser.yy"
+#line 2778 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
     break;
@@ -9191 +9191 @@
 
 /* Line 1806 of yacc.c  */
-#line 2782 "parser.yy"
+#line 2781 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     break;
@@ -9198 +9198 @@
 
 /* Line 1806 of yacc.c  */
-#line 2784 "parser.yy"
+#line 2783 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
     break;
@@ -9205 +9205 @@
 
 /* Line 1806 of yacc.c  */
-#line 2786 "parser.yy"
+#line 2785 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
     break;
@@ -9212 +9212 @@
 
 /* Line 1806 of yacc.c  */
-#line 2801 "parser.yy"
+#line 2800 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9219 +9219 @@
 
 /* Line 1806 of yacc.c  */
-#line 2803 "parser.yy"
+#line 2802 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9226 +9226 @@
 
 /* Line 1806 of yacc.c  */
-#line 2808 "parser.yy"
+#line 2807 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
@@ -9233 +9233 @@
 
 /* Line 1806 of yacc.c  */
-#line 2810 "parser.yy"
+#line 2809 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9240 +9240 @@
 
 /* Line 1806 of yacc.c  */
-#line 2812 "parser.yy"
+#line 2811 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9247 +9247 @@
 
 /* Line 1806 of yacc.c  */
-#line 2814 "parser.yy"
+#line 2813 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -9254 +9254 @@
 
 /* Line 1806 of yacc.c  */
-#line 2816 "parser.yy"
+#line 2815 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addQualifiers( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9261 +9261 @@
 
 /* Line 1806 of yacc.c  */
-#line 2822 "parser.yy"
+#line 2821 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9268 +9268 @@
 
 /* Line 1806 of yacc.c  */
-#line 2824 "parser.yy"
+#line 2823 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -9275 +9275 @@
 
 /* Line 1806 of yacc.c  */
-#line 2826 "parser.yy"
+#line 2825 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9282 +9282 @@
 
 /* Line 1806 of yacc.c  */
-#line 2831 "parser.yy"
+#line 2830 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -9289 +9289 @@
 
 /* Line 1806 of yacc.c  */
-#line 2833 "parser.yy"
+#line 2832 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9296 +9296 @@
 
 /* Line 1806 of yacc.c  */
-#line 2843 "parser.yy"
+#line 2842 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9303 +9303 @@
 
 /* Line 1806 of yacc.c  */
-#line 2854 "parser.yy"
+#line 2853 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9310 +9310 @@
 
 /* Line 1806 of yacc.c  */
-#line 2856 "parser.yy"
+#line 2855 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -9317 +9317 @@
 
 /* Line 1806 of yacc.c  */
-#line 2858 "parser.yy"
+#line 2857 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9324 +9324 @@
 
 /* Line 1806 of yacc.c  */
-#line 2860 "parser.yy"
+#line 2859 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -9331 +9331 @@
 
 /* Line 1806 of yacc.c  */
-#line 2862 "parser.yy"
+#line 2861 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9338 +9338 @@
 
 /* Line 1806 of yacc.c  */
-#line 2864 "parser.yy"
+#line 2863 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -9345 +9345 @@
 
 /* Line 1806 of yacc.c  */
-#line 2871 "parser.yy"
+#line 2870 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
@@ -9352 +9352 @@
 
 /* Line 1806 of yacc.c  */
-#line 2873 "parser.yy"
+#line 2872 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9359 +9359 @@
 
 /* Line 1806 of yacc.c  */
-#line 2875 "parser.yy"
+#line 2874 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
@@ -9366 +9366 @@
 
 /* Line 1806 of yacc.c  */
-#line 2877 "parser.yy"
+#line 2876 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -9373 +9373 @@
 
 /* Line 1806 of yacc.c  */
-#line 2879 "parser.yy"
+#line 2878 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9380 +9380 @@
 
 /* Line 1806 of yacc.c  */
-#line 2882 "parser.yy"
+#line 2881 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
@@ -9387 +9387 @@
 
 /* Line 1806 of yacc.c  */
-#line 2884 "parser.yy"
+#line 2883 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9394 +9394 @@
 
 /* Line 1806 of yacc.c  */
-#line 2886 "parser.yy"
+#line 2885 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
@@ -9401 +9401 @@
 
 /* Line 1806 of yacc.c  */
-#line 2888 "parser.yy"
+#line 2887 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -9408 +9408 @@
 
 /* Line 1806 of yacc.c  */
-#line 2890 "parser.yy"
+#line 2889 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9415 +9415 @@
 
 /* Line 1806 of yacc.c  */
-#line 2895 "parser.yy"
+#line 2894 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     break;
@@ -9422 +9422 @@
 
 /* Line 1806 of yacc.c  */
-#line 2897 "parser.yy"
+#line 2896 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     break;
@@ -9429 +9429 @@
 
 /* Line 1806 of yacc.c  */
-#line 2902 "parser.yy"
+#line 2901 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
     break;
@@ -9436 +9436 @@
 
 /* Line 1806 of yacc.c  */
-#line 2904 "parser.yy"
+#line 2903 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
     break;
@@ -9443 +9443 @@
 
 /* Line 1806 of yacc.c  */
-#line 2931 "parser.yy"
+#line 2930 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9450 +9450 @@
 
 /* Line 1806 of yacc.c  */
-#line 2942 "parser.yy"
+#line 2941 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9457 +9457 @@
 
 /* Line 1806 of yacc.c  */
-#line 2944 "parser.yy"
+#line 2943 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -9464 +9464 @@
 
 /* Line 1806 of yacc.c  */
-#line 2946 "parser.yy"
+#line 2945 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9471 +9471 @@
 
 /* Line 1806 of yacc.c  */
-#line 2948 "parser.yy"
+#line 2947 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -9478 +9478 @@
 
 /* Line 1806 of yacc.c  */
-#line 2950 "parser.yy"
+#line 2949 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -9485 +9485 @@
 
 /* Line 1806 of yacc.c  */
-#line 2952 "parser.yy"
+#line 2951 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -9492 +9492 @@
 
 /* Line 1806 of yacc.c  */
-#line 2959 "parser.yy"
+#line 2958 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     break;
@@ -9499 +9499 @@
 
 /* Line 1806 of yacc.c  */
-#line 2961 "parser.yy"
+#line 2960 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     break;
@@ -9506 +9506 @@
 
 /* Line 1806 of yacc.c  */
-#line 2963 "parser.yy"
+#line 2962 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9513 +9513 @@
 
 /* Line 1806 of yacc.c  */
-#line 2965 "parser.yy"
+#line 2964 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     break;
@@ -9520 +9520 @@
 
 /* Line 1806 of yacc.c  */
-#line 2967 "parser.yy"
+#line 2966 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     break;
@@ -9527 +9527 @@
 
 /* Line 1806 of yacc.c  */
-#line 2969 "parser.yy"
+#line 2968 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -9534 +9534 @@
 
 /* Line 1806 of yacc.c  */
-#line 2974 "parser.yy"
+#line 2973 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -9541 +9541 @@
 
 /* Line 1806 of yacc.c  */
-#line 2981 "parser.yy"
+#line 2980 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     break;
@@ -9548 +9548 @@
 
 /* Line 1806 of yacc.c  */
-#line 2983 "parser.yy"
+#line 2982 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     break;
@@ -9555 +9555 @@
 
 /* Line 1806 of yacc.c  */
-#line 3007 "parser.yy"
+#line 3006 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -9562 +9562 @@
 
 /* Line 1806 of yacc.c  */
-#line 3009 "parser.yy"
+#line 3008 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -9800 +9800 @@
 
 /* Line 2067 of yacc.c  */
-#line 3012 "parser.yy"
+#line 3011 "parser.yy"
 
 // ----end of grammar----

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 28 09:58:10 2017
-// Update Count     : 2208
+// Last Modified On : Fri Mar  3 21:35:28 2017
+// Update Count     : 2222
 //
 
@@ -1400 +1400 @@
 type_qualifier_name:
         CONST
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
         | RESTRICT
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
         | VOLATILE
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
         | LVALUE                                                                                        // CFA
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
         | ATOMIC
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
         | FORALL '('
                 {
@@ -1448 +1448 @@
         | REGISTER
                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
-        | INLINE                                                                                        // C99
-                //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
-                { $$ = new DeclarationNode; $$->isInline = true; }
-        | FORTRAN                                                                                       // C99
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
-        | NORETURN                                                                                      // C11
-                //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
-                { $$ = new DeclarationNode; $$->isNoreturn = true; }
         | THREADLOCAL                                                                           // C11
                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
+                // Put function specifiers here to simplify parsing rules, but separate them semantically.
+        | INLINE                                                                                        // C99
+                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); }
+        | FORTRAN                                                                                       // C99
+                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Fortran ); }
+        | NORETURN                                                                                      // C11
+                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Noreturn ); }
         ;
 

src/SymTab/Autogen.cc

@@ -10 +10 @@
 // Created On       : Thu Mar 03 15:45:56 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 15:02:50 2017
-// Update Count     : 13
+// Last Modified On : Fri Mar  3 22:00:55 2017
+// Update Count     : 30
 //
 
@@ -163 +163 @@
                 DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
                 LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
-                FunctionDecl * decl = new FunctionDecl( fname, sc, spec, ftype, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl * decl = new FunctionDecl( fname, sc, spec, ftype, new CompoundStmt( noLabels ),
+                                                                                                std::list< Attribute * >(), DeclarationNode::FuncSpecifier( DeclarationNode::InlineSpec ) );
                 decl->fixUniqueId();
                 return decl;
@@ -717 +718 @@
                                         TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any );
                                         TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genAssignType( inst ), nullptr, true, false ) );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genCopyType( inst ), nullptr, true, false ) );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) );
+                                        newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genAssignType( inst ), nullptr,
+                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) ) );
+                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
+                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) ) );
+                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genCopyType( inst ), nullptr,
+                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) ) );
+                                        newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr,
+                                                                                                                                                   std::list< Attribute * >(), DeclarationNode::FuncSpec( DeclarationNode::InlineSpec ) ) );
                                         typeParams.push_back( newDecl );
                                         done.insert( ty->get_baseType() );

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 21:33:55 2017
-// Update Count     : 318
+// Last Modified On : Fri Mar  3 21:02:23 2017
+// Update Count     : 332
 //
 
@@ -660 +660 @@
                 // Note, qualifiers on the typedef are superfluous for the forward declaration.
                 if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
-                        return aggDecl->get_baseStruct() ? Mutator::mutate( aggDecl->get_baseStruct() ) : new StructDecl( aggDecl->get_name() );
+                        return new StructDecl( aggDecl->get_name() );
                 } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
-                        return aggDecl->get_baseUnion() ? Mutator::mutate( aggDecl->get_baseUnion() ) : new UnionDecl( aggDecl->get_name() );
+                        return new UnionDecl( aggDecl->get_name() );
                 } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( tyDecl->get_base() ) ) {
                         return new EnumDecl( enumDecl->get_name() );
@@ -691 +691 @@
                 DeclarationWithType *ret = Mutator::mutate( objDecl );
                 typedefNames.endScope();
-                // is the type a function?
-                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) {
+
+                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClass(), ret->get_linkage(), funtype, 0, ret->get_isInline(), ret->get_isNoreturn(), objDecl->get_attributes() );
+                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClass(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
                         objDecl->get_attributes().clear();
                         objDecl->set_type( nullptr );
                         delete objDecl;
                         return newDecl;
-                } else if ( objDecl->get_isInline() || objDecl->get_isNoreturn() ) {
-                        throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", objDecl );
                 } // if
                 return ret;

src/SynTree/Declaration.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  9 14:28:05 2017
-// Update Count     : 16
+// Last Modified On : Wed Mar  1 20:11:57 2017
+// Update Count     : 17
 //
 
@@ -28 +28 @@
 
 Declaration::Declaration( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage )
-                : name( name ), storageClass( sc ), linkage( linkage ), isInline( false ), isNoreturn( false ), uniqueId( 0 ) {
+                : name( name ), storageClass( sc ), linkage( linkage ), uniqueId( 0 ) {
 }
 
 Declaration::Declaration( const Declaration &other )
-        : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), isInline( other.isInline ), isNoreturn( other.isNoreturn ), uniqueId( other.uniqueId ) {
+        : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
 }
 

src/SynTree/Declaration.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:53:35 2017
-// Update Count     : 57
+// Last Modified On : Fri Mar  3 20:59:27 2017
+// Update Count     : 96
 //
 
@@ -38 +38 @@
         LinkageSpec::Spec get_linkage() const { return linkage; }
         void set_linkage( LinkageSpec::Spec newValue ) { linkage = newValue; }
-        bool get_isInline() const { return isInline; }
-        void set_isInline( bool newValue ) { isInline = newValue; }
-        bool get_isNoreturn() const { return isNoreturn; }
-        void set_isNoreturn( bool newValue ) { isNoreturn = newValue; }
         UniqueId get_uniqueId() const { return uniqueId; }
         bool get_extension() const { return extension; }
@@ -59 +55 @@
         DeclarationNode::StorageClass storageClass;
         LinkageSpec::Spec linkage;
-        bool isInline, isNoreturn;
         UniqueId uniqueId;
         bool extension = false;
@@ -66 +61 @@
 class DeclarationWithType : public Declaration {
   public:
-        DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes );
+        DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpec fs = DeclarationNode::FuncSpec() );
         DeclarationWithType( const DeclarationWithType &other );
         virtual ~DeclarationWithType();
@@ -83 +78 @@
         std::list< Attribute * >& get_attributes() { return attributes; }
         const std::list< Attribute * >& get_attributes() const { return attributes; }
+
+        DeclarationNode::FuncSpec get_funcSpec() const { return fs; }
+        void set_functionSpecifiers( DeclarationNode::FuncSpec newValue ) { fs = newValue; }
 
         virtual DeclarationWithType *clone() const = 0;
@@ -97 +95 @@
         ConstantExpr *asmName;
         std::list< Attribute * > attributes;
+        DeclarationNode::FuncSpec fs;
 };
 
@@ -102 +101 @@
         typedef DeclarationWithType Parent;
   public:
-        ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes = std::list< Attribute * >(), bool isInline = false, bool isNoreturn = false );
+        ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init,
+                                const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpec fs = DeclarationNode::FuncSpec() );
         ObjectDecl( const ObjectDecl &other );
         virtual ~ObjectDecl();
@@ -129 +129 @@
         typedef DeclarationWithType Parent;
   public:
-        FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, const std::list< Attribute * > attributes = std::list< Attribute * >() );
+        FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements,
+                                  const std::list< Attribute * > attributes = std::list< Attribute * >(), DeclarationNode::FuncSpec fs = DeclarationNode::FuncSpec() );
         FunctionDecl( const FunctionDecl &other );
         virtual ~FunctionDecl();

src/SynTree/DeclarationWithType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Dec 13 14:49:43 2016
-// Update Count     : 7
+// Last Modified On : Fri Mar  3 20:59:28 2017
+// Update Count     : 19
 //
 
@@ -19 +19 @@
 #include "Common/utility.h"
 
-DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes )
-        : Declaration( name, sc, linkage ), asmName( nullptr ), attributes( attributes ) {
+DeclarationWithType::DeclarationWithType( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, DeclarationNode::FuncSpec fs )
+        : Declaration( name, sc, linkage ), asmName( nullptr ), attributes( attributes ), fs( fs ) {
 }
 
 DeclarationWithType::DeclarationWithType( const DeclarationWithType &other )
-                : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ) {
+        : Declaration( other ), mangleName( other.mangleName ), scopeLevel( other.scopeLevel ), fs( other.fs ) {
         cloneAll( other.attributes, attributes );
         asmName = maybeClone( other.asmName );

src/SynTree/FunctionDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 15:01:52 2017
-// Update Count     : 23
+// Last Modified On : Fri Mar  3 21:29:41 2017
+// Update Count     : 55
 //
 
@@ -26 +26 @@
 extern bool translation_unit_nomain;
 
-FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, bool isInline, bool isNoreturn, std::list< Attribute * > attributes )
-                : Parent( name, sc, linkage, attributes ), type( type ), statements( statements ) {
-        set_isInline( isInline );
-        set_isNoreturn( isNoreturn );
-        // this is a brazen hack to force the function "main" to have Cforall linkage
-        // because we want to replace the main even if it is inside an extern
+FunctionDecl::FunctionDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, FunctionType *type, CompoundStmt *statements, std::list< Attribute * > attributes, DeclarationNode::FuncSpec fs )
+                : Parent( name, sc, linkage, attributes, fs ), type( type ), statements( statements ) {
+        set_functionSpecifiers( fs );
+
+        // hack forcing the function "main" to have Cforall linkage to replace main even if it is inside an extern
         if ( name == "main" ) {
                 set_linkage( CodeGen::FixMain::mainLinkage() );
@@ -65 +64 @@
                 os << LinkageSpec::linkageName( get_linkage() ) << " ";
         } // if
-        if ( get_isInline() ) {
-                os << "inline ";
-        } // if
-        if ( get_isNoreturn() ) {
-                os << "_Noreturn ";
-        } // if
 
         printAll( get_attributes(), os, indent );
 
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-                os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+                os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
         } // if
+        DeclarationNode::print_FuncSpec( os, get_funcSpec() );
+
         if ( get_type() ) {
                 get_type()->print( os, indent );
@@ -97 +92 @@
                 os << get_name() << ": ";
         } // if
-        if ( get_isInline() ) {
-                os << "inline ";
-        } // if
-        if ( get_isNoreturn() ) {
-                os << "_Noreturn ";
-        } // if
 
         // xxx - should printShort print attributes?
 
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-                os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+                os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
         } // if
+        DeclarationNode::print_FuncSpec( os, get_funcSpec() );
+
         if ( get_type() ) {
                 get_type()->print( os, indent );

src/SynTree/NamedTypeDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun 13 08:13:55 2015
-// Update Count     : 3
+// Last Modified On : Tue Feb 28 16:13:24 2017
+// Update Count     : 4
 //
 
@@ -40 +40 @@
         } // if
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-                os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+                os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
         } // if
         os << typeString();
@@ -64 +64 @@
         } // if
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-                os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+                os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
         } // if
         os << typeString();

src/SynTree/ObjectDecl.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Oct  1 23:05:56 2016
-// Update Count     : 32
+// Last Modified On : Fri Mar  3 20:59:27 2017
+// Update Count     : 45
 //
 
@@ -22 +22 @@
 #include "Statement.h"
 
-ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, bool isInline, bool isNoreturn )
-        : Parent( name, sc, linkage, attributes ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
-        set_isInline( isInline );
-        set_isNoreturn( isNoreturn );
+ObjectDecl::ObjectDecl( const std::string &name, DeclarationNode::StorageClass sc, LinkageSpec::Spec linkage, Expression *bitfieldWidth, Type *type, Initializer *init, const std::list< Attribute * > attributes, DeclarationNode::FuncSpec fs )
+        : Parent( name, sc, linkage, attributes, fs ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
+        set_functionSpecifiers( fs );
 }
 
@@ -50 +49 @@
 
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-                os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+                os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
         } // if
 
@@ -86 +85 @@
 
         if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-                os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+                os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
         } // if
 

src/SynTree/Type.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 16:38:53 2017
-// Update Count     : 34
+// Last Modified On : Wed Mar  1 09:11:45 2017
+// Update Count     : 41
 //
 
@@ -21 +21 @@
 #include "SynTree.h"
 #include "Visitor.h"
-#include "Common/utility.h"
 
 class Type : public BaseSyntaxNode {
@@ -213 +212 @@
         bool get_isVarArgs() const { return isVarArgs; }
         void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
-
         bool isTtype() const;