Index: doc/proposals/flags.md
===================================================================
--- doc/proposals/flags.md	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
+++ doc/proposals/flags.md	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -0,0 +1,78 @@
+## Flag Enums ##
+
+A common programming problem is to represent a value from a set of boolean flags, each of which can be either on or off. C already has enums and bitfields, which can be naturally used to represent the individual flags, but are un-ergonomic to combine together. This proposal introduces "flag enums", a variant of the usual enums specialized to represent flags in a more ergonomic way.
+
+As an example, a flag enum for the TCP control bits could be defined as follows:
+
+	```
+	enum TCP_Flags {
+		FIN,
+		SYN,
+		RST,
+		PSH,
+		ACK,
+		URG,
+		ECE,
+		CWR,
+		NS
+	} __attribute__((flag));
+	```
+
+The `__attribute__` syntax is ugly, but represents the smallest backwards compatibility break; a new SUE for enum flags (e.g. `flag enum TCP_Flags { ... };` or even `flag TCP_Flags { ... };`) might also be reasonable.
+
+A flag enum would be different than a normal enum in two ways: it would auto-generate discriminant values differently, and it would have a number of bitwise operators defined on it by default.
+
+Normal enums generate their discriminant values sequentially starting at zero (`0, 1, 2, 3, ...`), while a flag enum would generate its discriminant values as successive powers of two starting at `1`. E.g. the `TCP_Flags` declaration above would codegen to an enum like below:
+
+	```
+	enum TCP_Flags {
+		FIN = 0x1,
+		SYN = 0x2,
+		RST = 0x4,
+		PSH = 0x8,
+		ACK = 0x10,
+		URG = 0x20,
+		ECE = 0x40,
+		CWR = 0x80,
+		NS = 0x100
+	};
+	```
+
+The precise rule used would be that if no enum discriminant is given, the discriminant is the smallest power of two larger than the previous discriminant (`1` if there is no previous discriminant). This would allow some flexibility for cases like these:
+
+	```
+	enum FunFlags {
+		NONE = 0,           // Named empty value
+		FOO,  // == 0x1
+		BAZ = 0x6,          // Multi-bit flag: 0x4 | 0x2
+		BAR,  // == 0x8
+		FOOBAR = FOO | BAR  // Named combination flag
+	} __attribute__((flag));
+	```
+
+Secondly, we would auto-generate a number of useful operators for any flag enum, as follows:
+* The default constructor for any flag enum would be defined, and would produce a flag with an underlying value of 0.
+* Assignment from and equality/inequality to `zero_t` should also be defined based on the underlying enum value.
+* The bitwise operators `?&?, ?|?, ?^?, ~?` and their assignment variants `?&=?, ?|=?, ?^=?` shall be defined with the semantics of the underlying enum value; `?-?` and `?-=?` should also be defined such that `a - b == a & ~b` (a set difference operation).
+
+With these operations defined, flag enums would support a full set of useful flag operations, using existing, known syntax, as follows:
+
+	```
+	FunFlags f = some_val();
+	if ( f ) { sout | "f has some flag(s) set" | endl; }
+	if ( f & FOO ) { sout | "f has FOO set" | endl; }
+	f |= FOO; // set FOO
+	f -= FOO; // unset FOO
+	f ^= FOO; // toggle FOO
+	```
+
+In each of the cases above, `FOO` could be replaced by `(BAR | BAZ)` to do the same operation or test on multiple flags at once.
+
+### Related Work ###
+C# has the [`[Flags]`][1] enum attribute, but their proposal does not go as far; specifically, the flag discriminants must be manually specified, and they do not automatically implement the bitwise operators on the flags. 
+
+Java has [`EnumSet`][2] which represents the set of flags for a given enum (C++ [`bitset`][3] can be used similarly). The main disadvantage of applying this approach to Cforall is that C enum types already implicitly convert to int, and the bitwise operators already have interpretations on enums with `int` results based on this conversion. As such, all flags need to be wrapped in a set to be used type-safely with the bitwise operators.
+
+[1]: https://msdn.microsoft.com/en-us/library/system.enum.hasflag(v=vs.110).aspx
+[2]: http://docs.oracle.com/javase/7/docs/api/java/util/EnumSet.html
+[3]: http://en.cppreference.com/w/cpp/utility/bitset
Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/CodeGen/CodeGenerator.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,10 +134,6 @@
 
 		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,5 +831,4 @@
 	}
 
-
 	void CodeGenerator::visit( ReturnStmt * returnStmt ) {
 		output << "return ";
@@ -899,6 +894,7 @@
 	}
 
-	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,20 +909,13 @@
 			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 ) {
Index: src/CodeGen/CodeGenerator.h
===================================================================
--- src/CodeGen/CodeGenerator.h	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/CodeGen/CodeGenerator.h	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +123,5 @@
 
 		void printDesignators( std::list< Expression * > & );
-		void handleStorageClass( Declaration *decl );
+		void handleStorageClass( DeclarationWithType *decl );
 		void handleAggregate( AggregateDecl *aggDecl );
 		void handleTypedef( NamedTypeDecl *namedType );
Index: src/CodeGen/FixNames.cc
===================================================================
--- src/CodeGen/FixNames.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/CodeGen/FixNames.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -9,7 +9,7 @@
 // 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,5 +44,5 @@
 			LinkageSpec::Cforall, 
 			main_type = new FunctionType( Type::Qualifiers(), true ), 
-			nullptr, false, false
+			nullptr
 		) };
 		main_type->get_returnVals().push_back( 
@@ -50,5 +50,5 @@
 		);
 
-		auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
+		auto && name = SymTab::Mangler::mangle( mainDecl.get() );
 		// std::cerr << name << std::endl;
 		return name;
@@ -61,5 +61,5 @@
 			LinkageSpec::Cforall, 
 			main_type = new FunctionType( Type::Qualifiers(), false ), 
-			nullptr, false, false
+			nullptr
 		) };
 		main_type->get_returnVals().push_back( 
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/GenPoly/Box.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +299,6 @@
 		// 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,5 +911,5 @@
 			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 );
 		}
 
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/GenPoly/Specialize.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -9,7 +9,7 @@
 // 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,5 +155,5 @@
 		} // 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();
 
Index: src/InitTweak/FixGlobalInit.cc
===================================================================
--- src/InitTweak/FixGlobalInit.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/InitTweak/FixGlobalInit.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,7 +87,7 @@
 			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 ) );
 	}
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/InitTweak/FixInit.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +731,5 @@
 
 							// 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 );
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/Parser/DeclarationNode.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,13 +32,14 @@
 
 // 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,6 +51,4 @@
 		storageClass( NoStorageClass ),
 		bitfieldWidth( nullptr ),
-		isInline( false ),
-		isNoreturn( false ),
 		hasEllipsis( false ),
 		linkage( ::linkage ),
@@ -92,6 +91,5 @@
 	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,4 +116,14 @@
 }
 
+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,7 +138,7 @@
 	} // 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,10 +191,51 @@
 } // 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,38 +245,4 @@
 	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,10 +443,10 @@
 
 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,18 +455,28 @@
 
 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,5 +506,5 @@
 		src = nullptr;
 	} else {
-		dst->qualifiers |= src->qualifiers;
+		dst->typeQualifiers |= src->typeQualifiers;
 	} // if
 } // addQualifiersToType
@@ -539,10 +564,10 @@
 		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,15 +576,15 @@
 					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,5 +593,5 @@
 					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,5 +605,5 @@
 					dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
 				} // if
-				dst->base->qualifiers |= src->qualifiers;
+				dst->base->typeQualifiers |= src->typeQualifiers;
 				src = nullptr;
 				break;
@@ -612,5 +637,5 @@
 						type->aggInst.hoistType = o->type->enumeration.body;
 					} // if
-					type->qualifiers |= o->type->qualifiers;
+					type->typeQualifiers |= o->type->typeQualifiers;
 				} else {
 					type = o->type;
@@ -768,5 +793,5 @@
 					p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
 				} // if
-				p->type->base->qualifiers |= type->qualifiers;
+				p->type->base->typeQualifiers |= type->typeQualifiers;
 				break;
 
@@ -805,5 +830,5 @@
 					lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
 				} // if
-				lastArray->base->qualifiers |= type->qualifiers;
+				lastArray->base->typeQualifiers |= type->typeQualifiers;
 				break;
 			  default:
@@ -1005,10 +1030,8 @@
 	} // 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,13 +1040,24 @@
 
 	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,8 +1066,6 @@
 
 	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
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/Parser/ParseNode.h	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,4 +19,5 @@
 #include <string>
 #include <list>
+#include <bitset>
 #include <iterator>
 #include <memory>
@@ -203,10 +204,8 @@
 	// 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,24 +216,26 @@
 	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,6 +325,10 @@
 	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;
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/Parser/TypeData.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +157,5 @@
 TypeData * TypeData::clone() const {
 	TypeData * newtype = new TypeData( kind );
-	newtype->qualifiers = qualifiers;
+	newtype->typeQualifiers = typeQualifiers;
 	newtype->base = maybeClone( base );
 	newtype->forall = maybeClone( forall );
@@ -226,6 +226,6 @@
 
 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,9 +250,9 @@
 		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,5 +301,5 @@
 		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,5 +399,5 @@
 			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,10 +405,10 @@
 			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,5 +417,5 @@
 			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,9 +494,9 @@
 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,8 +516,8 @@
 	  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,5 +532,5 @@
 
 		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,8 +562,8 @@
 	  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,5 +784,5 @@
 } // 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,5 +793,5 @@
 		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,5 +802,5 @@
 		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,5 +820,5 @@
 			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 {
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/Parser/TypeData.h	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,6 +76,6 @@
 	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,5 +113,5 @@
 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 );
Index: src/Parser/parser.cc
===================================================================
--- src/Parser/parser.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/Parser/parser.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -892,6 +892,6 @@
      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,49 +1092,49 @@
     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,8 +1451,8 @@
 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,5 +6909,5 @@
 /* Line 1806 of yacc.c  */
 #line 1402 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
     break;
 
@@ -6916,5 +6916,5 @@
 /* Line 1806 of yacc.c  */
 #line 1404 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
     break;
 
@@ -6923,5 +6923,5 @@
 /* Line 1806 of yacc.c  */
 #line 1406 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
     break;
 
@@ -6930,5 +6930,5 @@
 /* Line 1806 of yacc.c  */
 #line 1408 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
     break;
 
@@ -6937,5 +6937,5 @@
 /* Line 1806 of yacc.c  */
 #line 1410 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+    { (yyval.decl) = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
     break;
 
@@ -7011,6 +7011,6 @@
 
 /* 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,5 +7019,5 @@
 /* Line 1806 of yacc.c  */
 #line 1454 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
+    { (yyval.decl) = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); }
     break;
 
@@ -7025,6 +7025,6 @@
 
 /* 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,6 +7032,6 @@
 
 /* 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,5 +7039,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1464 "parser.yy"
+#line 1463 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     break;
@@ -7046,5 +7046,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1466 "parser.yy"
+#line 1465 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     break;
@@ -7053,5 +7053,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1468 "parser.yy"
+#line 1467 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     break;
@@ -7060,5 +7060,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1470 "parser.yy"
+#line 1469 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     break;
@@ -7067,5 +7067,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1472 "parser.yy"
+#line 1471 "parser.yy"
     { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
     break;
@@ -7074,5 +7074,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1474 "parser.yy"
+#line 1473 "parser.yy"
     { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
     break;
@@ -7081,5 +7081,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1476 "parser.yy"
+#line 1475 "parser.yy"
     { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
     break;
@@ -7088,5 +7088,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1478 "parser.yy"
+#line 1477 "parser.yy"
     { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
     break;
@@ -7095,5 +7095,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1480 "parser.yy"
+#line 1479 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     break;
@@ -7102,5 +7102,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1482 "parser.yy"
+#line 1481 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     break;
@@ -7109,5 +7109,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1484 "parser.yy"
+#line 1483 "parser.yy"
     { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
     break;
@@ -7116,5 +7116,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1486 "parser.yy"
+#line 1485 "parser.yy"
     { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
     break;
@@ -7123,5 +7123,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1488 "parser.yy"
+#line 1487 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
     break;
@@ -7130,5 +7130,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1490 "parser.yy"
+#line 1489 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
     break;
@@ -7137,5 +7137,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1492 "parser.yy"
+#line 1491 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
     break;
@@ -7144,5 +7144,5 @@
 
 /* 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,5 +7151,5 @@
 
 /* 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,5 +7158,5 @@
 
 /* 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,5 +7165,5 @@
 
 /* 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,5 +7172,5 @@
 
 /* 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,5 +7179,5 @@
 
 /* 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,5 +7186,5 @@
 
 /* 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,5 +7193,5 @@
 
 /* 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,5 +7200,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1527 "parser.yy"
+#line 1526 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     break;
@@ -7207,5 +7207,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1529 "parser.yy"
+#line 1528 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     break;
@@ -7214,5 +7214,5 @@
 
 /* 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,5 +7221,5 @@
 
 /* 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,5 +7228,5 @@
 
 /* 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,5 +7235,5 @@
 
 /* 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,5 +7242,5 @@
 
 /* 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,5 +7249,5 @@
 
 /* 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,5 +7256,5 @@
 
 /* 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,5 +7263,5 @@
 
 /* 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,5 +7270,5 @@
 
 /* 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,5 +7277,5 @@
 
 /* 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,5 +7284,5 @@
 
 /* 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,5 +7291,5 @@
 
 /* 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,5 +7298,5 @@
 
 /* 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,5 +7305,5 @@
 
 /* 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,5 +7312,5 @@
 
 /* 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,5 +7319,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1584 "parser.yy"
+#line 1583 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -7326,5 +7326,5 @@
 
 /* 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,5 +7333,5 @@
 
 /* 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,5 +7340,5 @@
 
 /* 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,5 +7347,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1605 "parser.yy"
+#line 1604 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); }
     break;
@@ -7354,5 +7354,5 @@
 
 /* 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,5 +7361,5 @@
 
 /* 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,5 +7368,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1615 "parser.yy"
+#line 1614 "parser.yy"
     {
 			typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) );
@@ -7378,5 +7378,5 @@
 
 /* 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,5 +7385,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1625 "parser.yy"
+#line 1624 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Struct; }
     break;
@@ -7392,5 +7392,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1627 "parser.yy"
+#line 1626 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Union; }
     break;
@@ -7399,5 +7399,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1632 "parser.yy"
+#line 1631 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7406,5 +7406,5 @@
 
 /* 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,5 +7413,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1640 "parser.yy"
+#line 1639 "parser.yy"
     {
 			distExt( (yyvsp[(2) - (3)].decl) );								// mark all fields in list
@@ -7423,5 +7423,5 @@
 
 /* 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,5 +7431,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1648 "parser.yy"
+#line 1647 "parser.yy"
     {
 			distExt( (yyvsp[(3) - (4)].decl) );								// mark all fields in list
@@ -7441,5 +7441,5 @@
 
 /* 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,5 +7448,5 @@
 
 /* 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,5 +7455,5 @@
 
 /* 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,5 +7462,5 @@
 
 /* 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,5 +7469,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1672 "parser.yy"
+#line 1671 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     break;
@@ -7476,5 +7476,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1674 "parser.yy"
+#line 1673 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     break;
@@ -7483,5 +7483,5 @@
 
 /* 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,5 +7490,5 @@
 
 /* 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,5 +7497,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1686 "parser.yy"
+#line 1685 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -7504,5 +7504,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1688 "parser.yy"
+#line 1687 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -7511,5 +7511,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1693 "parser.yy"
+#line 1692 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7518,5 +7518,5 @@
 
 /* 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,5 +7525,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1700 "parser.yy"
+#line 1699 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) ); }
     break;
@@ -7532,5 +7532,5 @@
 
 /* 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,5 +7539,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1708 "parser.yy"
+#line 1707 "parser.yy"
     {
 			typedefTable.makeTypedef( *(yyvsp[(3) - (3)].tok) );
@@ -7549,5 +7549,5 @@
 
 /* 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,5 +7556,5 @@
 
 /* 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,5 +7563,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1723 "parser.yy"
+#line 1722 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -7570,5 +7570,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1725 "parser.yy"
+#line 1724 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7577,5 +7577,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1732 "parser.yy"
+#line 1731 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7584,5 +7584,5 @@
 
 /* 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,5 +7591,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1742 "parser.yy"
+#line 1741 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7598,5 +7598,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1744 "parser.yy"
+#line 1743 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7605,5 +7605,5 @@
 
 /* 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,5 +7612,5 @@
 
 /* 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,5 +7619,5 @@
 
 /* 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,5 +7626,5 @@
 
 /* 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,5 +7633,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1767 "parser.yy"
+#line 1766 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7640,5 +7640,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1774 "parser.yy"
+#line 1773 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7647,5 +7647,5 @@
 
 /* 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,5 +7654,5 @@
 
 /* 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,5 +7661,5 @@
 
 /* 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,5 +7668,5 @@
 
 /* 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,5 +7675,5 @@
 
 /* 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,5 +7682,5 @@
 
 /* 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,5 +7689,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1814 "parser.yy"
+#line 1813 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7699,5 +7699,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1819 "parser.yy"
+#line 1818 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7709,5 +7709,5 @@
 
 /* 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,5 +7716,5 @@
 
 /* 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,5 +7723,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1838 "parser.yy"
+#line 1837 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -7730,5 +7730,5 @@
 
 /* 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,5 +7737,5 @@
 
 /* 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,5 +7744,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1875 "parser.yy"
+#line 1874 "parser.yy"
     { (yyval.in) = nullptr; }
     break;
@@ -7751,5 +7751,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1877 "parser.yy"
+#line 1876 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in); }
     break;
@@ -7758,5 +7758,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1879 "parser.yy"
+#line 1878 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     break;
@@ -7765,12 +7765,12 @@
 
 /* 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,5 +7779,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1889 "parser.yy"
+#line 1888 "parser.yy"
     { (yyval.in) = nullptr; }
     break;
@@ -7786,12 +7786,12 @@
 
 /* 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,5 +7800,5 @@
 
 /* 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,5 +7807,5 @@
 
 /* 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,5 +7814,5 @@
 
 /* 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,5 +7821,5 @@
 
 /* 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,5 +7828,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1925 "parser.yy"
+#line 1924 "parser.yy"
     { (yyval.en) = (yyvsp[(3) - (5)].en); }
     break;
@@ -7835,5 +7835,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1927 "parser.yy"
+#line 1926 "parser.yy"
     { (yyval.en) = (yyvsp[(3) - (5)].en); }
     break;
@@ -7842,5 +7842,5 @@
 
 /* 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,5 +7849,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1931 "parser.yy"
+#line 1930 "parser.yy"
     { (yyval.en) = (yyvsp[(4) - (6)].en); }
     break;
@@ -7856,5 +7856,5 @@
 
 /* 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,5 +7863,5 @@
 
 /* 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,5 +7870,5 @@
 
 /* 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,5 +7877,5 @@
 
 /* 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,5 +7884,5 @@
 
 /* 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,5 +7891,5 @@
 
 /* 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,5 +7898,5 @@
 
 /* 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,5 +7905,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1983 "parser.yy"
+#line 1982 "parser.yy"
     { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
     break;
@@ -7912,5 +7912,5 @@
 
 /* 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,5 +7919,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1991 "parser.yy"
+#line 1990 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Otype; }
     break;
@@ -7926,5 +7926,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1993 "parser.yy"
+#line 1992 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Dtype; }
     break;
@@ -7933,5 +7933,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1995 "parser.yy"
+#line 1994 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Ftype; }
     break;
@@ -7940,5 +7940,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 1997 "parser.yy"
+#line 1996 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Ttype; }
     break;
@@ -7947,5 +7947,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2002 "parser.yy"
+#line 2001 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7954,5 +7954,5 @@
 
 /* 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,5 +7961,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2009 "parser.yy"
+#line 2008 "parser.yy"
     {
 			typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
@@ -7971,5 +7971,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2014 "parser.yy"
+#line 2013 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
     break;
@@ -7978,5 +7978,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2016 "parser.yy"
+#line 2015 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -7985,5 +7985,5 @@
 
 /* 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,5 +7992,5 @@
 
 /* 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,5 +7999,5 @@
 
 /* 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,5 +8006,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2031 "parser.yy"
+#line 2030 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
@@ -8013,5 +8013,5 @@
 
 /* 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,5 +8020,5 @@
 
 /* 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,5 +8027,5 @@
 
 /* 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,5 +8034,5 @@
 
 /* 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,5 +8041,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2047 "parser.yy"
+#line 2046 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
@@ -8051,5 +8051,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2052 "parser.yy"
+#line 2051 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
@@ -8061,5 +8061,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2060 "parser.yy"
+#line 2059 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
@@ -8071,5 +8071,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2065 "parser.yy"
+#line 2064 "parser.yy"
     {
 			typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
@@ -8081,5 +8081,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2070 "parser.yy"
+#line 2069 "parser.yy"
     {
 			typedefTable.leaveTrait();
@@ -8092,5 +8092,5 @@
 
 /* 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,5 +8099,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2090 "parser.yy"
+#line 2089 "parser.yy"
     {
 			typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8109,5 +8109,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2095 "parser.yy"
+#line 2094 "parser.yy"
     {
 			typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8119,5 +8119,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2100 "parser.yy"
+#line 2099 "parser.yy"
     {
 			typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -8129,5 +8129,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2108 "parser.yy"
+#line 2107 "parser.yy"
     {
 			typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8139,5 +8139,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2113 "parser.yy"
+#line 2112 "parser.yy"
     {
 			typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -8149,5 +8149,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2123 "parser.yy"
+#line 2122 "parser.yy"
     {}
     break;
@@ -8156,5 +8156,5 @@
 
 /* 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,5 +8163,5 @@
 
 /* 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,5 +8170,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2136 "parser.yy"
+#line 2135 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8177,5 +8177,5 @@
 
 /* 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,5 +8186,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2148 "parser.yy"
+#line 2147 "parser.yy"
     {
 			linkageStack.push( linkage );				// handle nested extern "C"/"Cforall"
@@ -8196,5 +8196,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2153 "parser.yy"
+#line 2152 "parser.yy"
     {
 			linkage = linkageStack.top();
@@ -8207,5 +8207,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2159 "parser.yy"
+#line 2158 "parser.yy"
     {
 			distExt( (yyvsp[(2) - (2)].decl) );								// mark all fields in list
@@ -8217,5 +8217,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2173 "parser.yy"
+#line 2172 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8228,5 +8228,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2179 "parser.yy"
+#line 2178 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8239,5 +8239,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2188 "parser.yy"
+#line 2187 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8250,5 +8250,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2194 "parser.yy"
+#line 2193 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8261,5 +8261,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2200 "parser.yy"
+#line 2199 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8272,5 +8272,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2206 "parser.yy"
+#line 2205 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8283,5 +8283,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2212 "parser.yy"
+#line 2211 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8294,5 +8294,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2220 "parser.yy"
+#line 2219 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8305,5 +8305,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2226 "parser.yy"
+#line 2225 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8316,5 +8316,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2234 "parser.yy"
+#line 2233 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8327,5 +8327,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2240 "parser.yy"
+#line 2239 "parser.yy"
     {
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -8338,5 +8338,5 @@
 
 /* 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,5 +8345,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2260 "parser.yy"
+#line 2259 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8352,5 +8352,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2262 "parser.yy"
+#line 2261 "parser.yy"
     {
 			DeclarationNode * name = new DeclarationNode();
@@ -8363,5 +8363,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2271 "parser.yy"
+#line 2270 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8370,5 +8370,5 @@
 
 /* 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,5 +8377,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2283 "parser.yy"
+#line 2282 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (6)].decl); }
     break;
@@ -8384,5 +8384,5 @@
 
 /* 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,5 +8391,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2294 "parser.yy"
+#line 2293 "parser.yy"
     { (yyval.decl) = nullptr; }
     break;
@@ -8398,5 +8398,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2296 "parser.yy"
+#line 2295 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttribute( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -8405,5 +8405,5 @@
 
 /* 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,5 +8412,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2306 "parser.yy"
+#line 2305 "parser.yy"
     { (yyval.tok) = Token{ new string( "__const__" ) }; }
     break;
@@ -8419,5 +8419,5 @@
 
 /* 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,5 +8426,5 @@
 
 /* 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,5 +8433,5 @@
 
 /* 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,5 +8440,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2351 "parser.yy"
+#line 2350 "parser.yy"
     {
 			typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8450,5 +8450,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2356 "parser.yy"
+#line 2355 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8457,5 +8457,5 @@
 
 /* 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,5 +8464,5 @@
 
 /* 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,5 +8471,5 @@
 
 /* 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,5 +8478,5 @@
 
 /* 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,5 +8485,5 @@
 
 /* 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,5 +8492,5 @@
 
 /* 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,5 +8499,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2376 "parser.yy"
+#line 2375 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8506,5 +8506,5 @@
 
 /* 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,5 +8513,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2383 "parser.yy"
+#line 2382 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8520,5 +8520,5 @@
 
 /* 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,5 +8527,5 @@
 
 /* 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,5 +8534,5 @@
 
 /* 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,5 +8541,5 @@
 
 /* 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,5 +8548,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2404 "parser.yy"
+#line 2403 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8555,5 +8555,5 @@
 
 /* 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,5 +8562,5 @@
 
 /* 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,5 +8569,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2413 "parser.yy"
+#line 2412 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8576,5 +8576,5 @@
 
 /* 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,5 +8583,5 @@
 
 /* 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,5 +8590,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2422 "parser.yy"
+#line 2421 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8597,5 +8597,5 @@
 
 /* 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,5 +8604,5 @@
 
 /* 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,5 +8611,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2444 "parser.yy"
+#line 2443 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8618,5 +8618,5 @@
 
 /* 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,5 +8625,5 @@
 
 /* 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,5 +8632,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2453 "parser.yy"
+#line 2452 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8639,5 +8639,5 @@
 
 /* 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,5 +8646,5 @@
 
 /* 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,5 +8653,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2462 "parser.yy"
+#line 2461 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8660,5 +8660,5 @@
 
 /* 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,5 +8667,5 @@
 
 /* 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,5 +8674,5 @@
 
 /* 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,5 +8681,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2488 "parser.yy"
+#line 2487 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8688,5 +8688,5 @@
 
 /* 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,5 +8695,5 @@
 
 /* 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,5 +8702,5 @@
 
 /* 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,5 +8709,5 @@
 
 /* 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,5 +8716,5 @@
 
 /* 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,5 +8723,5 @@
 
 /* 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,5 +8730,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2508 "parser.yy"
+#line 2507 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8737,5 +8737,5 @@
 
 /* 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,5 +8744,5 @@
 
 /* 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,5 +8751,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2517 "parser.yy"
+#line 2516 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8758,5 +8758,5 @@
 
 /* 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,5 +8765,5 @@
 
 /* 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,5 +8772,5 @@
 
 /* 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,5 +8779,5 @@
 
 /* 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,5 +8786,5 @@
 
 /* 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,5 +8793,5 @@
 
 /* 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,5 +8800,5 @@
 
 /* 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,5 +8807,5 @@
 
 /* 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,5 +8814,5 @@
 
 /* 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,5 +8821,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2552 "parser.yy"
+#line 2551 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8828,5 +8828,5 @@
 
 /* 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,5 +8835,5 @@
 
 /* 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,5 +8842,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2561 "parser.yy"
+#line 2560 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8849,5 +8849,5 @@
 
 /* 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,5 +8856,5 @@
 
 /* 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,5 +8863,5 @@
 
 /* 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,5 +8870,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2584 "parser.yy"
+#line 2583 "parser.yy"
     {
 			typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8880,5 +8880,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2589 "parser.yy"
+#line 2588 "parser.yy"
     {
 			typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8890,5 +8890,5 @@
 
 /* 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,5 +8897,5 @@
 
 /* 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,5 +8904,5 @@
 
 /* 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,5 +8911,5 @@
 
 /* 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,5 +8918,5 @@
 
 /* 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,5 +8925,5 @@
 
 /* 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,5 +8932,5 @@
 
 /* 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,5 +8939,5 @@
 
 /* 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,5 +8946,5 @@
 
 /* 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,5 +8953,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2640 "parser.yy"
+#line 2639 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
@@ -8960,5 +8960,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2642 "parser.yy"
+#line 2641 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8967,5 +8967,5 @@
 
 /* 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,5 +8974,5 @@
 
 /* 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,5 +8981,5 @@
 
 /* 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,5 +8988,5 @@
 
 /* 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,5 +8995,5 @@
 
 /* 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,5 +9002,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2658 "parser.yy"
+#line 2657 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9009,5 +9009,5 @@
 
 /* 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,5 +9016,5 @@
 
 /* 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,5 +9023,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2667 "parser.yy"
+#line 2666 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9030,5 +9030,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2673 "parser.yy"
+#line 2672 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     break;
@@ -9037,5 +9037,5 @@
 
 /* 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,5 +9044,5 @@
 
 /* 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,5 +9051,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2683 "parser.yy"
+#line 2682 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     break;
@@ -9058,5 +9058,5 @@
 
 /* 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,5 +9065,5 @@
 
 /* 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,5 +9072,5 @@
 
 /* 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,5 +9079,5 @@
 
 /* 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,5 +9086,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2729 "parser.yy"
+#line 2728 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( nullptr ); }
     break;
@@ -9093,5 +9093,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2731 "parser.yy"
+#line 2730 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9100,5 +9100,5 @@
 
 /* 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,5 +9107,5 @@
 
 /* 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,5 +9114,5 @@
 
 /* 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,5 +9121,5 @@
 
 /* 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,5 +9128,5 @@
 
 /* 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,5 +9135,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2747 "parser.yy"
+#line 2746 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9142,5 +9142,5 @@
 
 /* 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,5 +9149,5 @@
 
 /* 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,5 +9156,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2756 "parser.yy"
+#line 2755 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9163,5 +9163,5 @@
 
 /* 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,5 +9170,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2774 "parser.yy"
+#line 2773 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     break;
@@ -9177,5 +9177,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2777 "parser.yy"
+#line 2776 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     break;
@@ -9184,5 +9184,5 @@
 
 /* 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,5 +9191,5 @@
 
 /* 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,5 +9198,5 @@
 
 /* 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,5 +9205,5 @@
 
 /* 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,5 +9212,5 @@
 
 /* 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,5 +9219,5 @@
 
 /* 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,5 +9226,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2808 "parser.yy"
+#line 2807 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
@@ -9233,5 +9233,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2810 "parser.yy"
+#line 2809 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -9240,5 +9240,5 @@
 
 /* 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,5 +9247,5 @@
 
 /* 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,5 +9254,5 @@
 
 /* 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,5 +9261,5 @@
 
 /* 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,5 +9268,5 @@
 
 /* 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,5 +9275,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2826 "parser.yy"
+#line 2825 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9282,5 +9282,5 @@
 
 /* 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,5 +9289,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2833 "parser.yy"
+#line 2832 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -9296,5 +9296,5 @@
 
 /* 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,5 +9303,5 @@
 
 /* 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,5 +9310,5 @@
 
 /* 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,5 +9317,5 @@
 
 /* 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,5 +9324,5 @@
 
 /* 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,5 +9331,5 @@
 
 /* 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,5 +9338,5 @@
 
 /* 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,5 +9345,5 @@
 
 /* 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,5 +9352,5 @@
 
 /* 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,5 +9359,5 @@
 
 /* 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,5 +9366,5 @@
 
 /* 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,5 +9373,5 @@
 
 /* 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,5 +9380,5 @@
 
 /* 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,5 +9387,5 @@
 
 /* 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,5 +9394,5 @@
 
 /* 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,5 +9401,5 @@
 
 /* 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,5 +9408,5 @@
 
 /* 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,5 +9415,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2895 "parser.yy"
+#line 2894 "parser.yy"
     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     break;
@@ -9422,5 +9422,5 @@
 
 /* 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,5 +9429,5 @@
 
 /* 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,5 +9436,5 @@
 
 /* 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,5 +9443,5 @@
 
 /* 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,5 +9450,5 @@
 
 /* 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,5 +9457,5 @@
 
 /* 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,5 +9464,5 @@
 
 /* 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,5 +9471,5 @@
 
 /* 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,5 +9478,5 @@
 
 /* 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,5 +9485,5 @@
 
 /* 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,5 +9492,5 @@
 
 /* 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,5 +9499,5 @@
 
 /* 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,5 +9506,5 @@
 
 /* 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,5 +9513,5 @@
 
 /* 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,5 +9520,5 @@
 
 /* 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,5 +9527,5 @@
 
 /* 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,5 +9534,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 2974 "parser.yy"
+#line 2973 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -9541,5 +9541,5 @@
 
 /* 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,5 +9548,5 @@
 
 /* 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,5 +9555,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 3007 "parser.yy"
+#line 3006 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -9562,5 +9562,5 @@
 
 /* Line 1806 of yacc.c  */
-#line 3009 "parser.yy"
+#line 3008 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -9800,5 +9800,5 @@
 
 /* Line 2067 of yacc.c  */
-#line 3012 "parser.yy"
+#line 3011 "parser.yy"
 
 // ----end of grammar----
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/Parser/parser.yy	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,13 +1400,13 @@
 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,14 +1448,13 @@
 	| 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 ); }
 	;
 
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SymTab/Autogen.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +163,6 @@
 		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,8 +718,12 @@
 					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() );
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SymTab/Validate.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,7 +660,7 @@
 		// 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,14 +691,12 @@
 		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;
Index: src/SynTree/Declaration.cc
===================================================================
--- src/SynTree/Declaration.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/Declaration.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,9 +28,9 @@
 
 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 ) {
 }
 
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/Declaration.h	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,8 +38,4 @@
 	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,5 +55,4 @@
 	DeclarationNode::StorageClass storageClass;
 	LinkageSpec::Spec linkage;
-	bool isInline, isNoreturn;
 	UniqueId uniqueId;
 	bool extension = false;
@@ -66,5 +61,5 @@
 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,4 +78,7 @@
 	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,4 +95,5 @@
 	ConstantExpr *asmName;
 	std::list< Attribute * > attributes;
+	DeclarationNode::FuncSpec fs;
 };
 
@@ -102,5 +101,6 @@
 	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,5 +129,6 @@
 	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();
Index: src/SynTree/DeclarationWithType.cc
===================================================================
--- src/SynTree/DeclarationWithType.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/DeclarationWithType.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,10 +19,10 @@
 #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 );
Index: src/SynTree/FunctionDecl.cc
===================================================================
--- src/SynTree/FunctionDecl.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/FunctionDecl.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,10 +26,9 @@
 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,16 +64,12 @@
 		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,16 +92,12 @@
 		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 );
Index: src/SynTree/NamedTypeDecl.cc
===================================================================
--- src/SynTree/NamedTypeDecl.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/NamedTypeDecl.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +40,5 @@
 	} // if
 	if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-		os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+		os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
 	} // if
 	os << typeString();
@@ -64,5 +64,5 @@
 	} // if
 	if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-		os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+		os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
 	} // if
 	os << typeString();
Index: src/SynTree/ObjectDecl.cc
===================================================================
--- src/SynTree/ObjectDecl.cc	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/ObjectDecl.cc	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,8 +22,7 @@
 #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,5 +49,5 @@
 
 	if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-		os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+		os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
 	} // if
 
@@ -86,5 +85,5 @@
 
 	if ( get_storageClass() != DeclarationNode::NoStorageClass ) {
-		os << DeclarationNode::storageName[ get_storageClass() ] << ' ';
+		os << DeclarationNode::storageClassNames[ get_storageClass() ] << ' ';
 	} // if
 
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/SynTree/Type.h	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // 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,5 +21,4 @@
 #include "SynTree.h"
 #include "Visitor.h"
-#include "Common/utility.h"
 
 class Type : public BaseSyntaxNode {
@@ -213,5 +212,4 @@
 	bool get_isVarArgs() const { return isVarArgs; }
 	void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
-
 	bool isTtype() const;
 
Index: src/libcfa/iostream
===================================================================
--- src/libcfa/iostream	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/libcfa/iostream	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb 24 21:09:09 2017
-// Update Count     : 94
+// Last Modified On : Sat Mar  4 22:04:33 2017
+// Update Count     : 95
 //
 
Index: src/libcfa/iostream.c
===================================================================
--- src/libcfa/iostream.c	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/libcfa/iostream.c	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb 24 21:09:59 2017
-// Update Count     : 307
+// Last Modified On : Sat Mar  4 22:04:16 2017
+// Update Count     : 308
 //
 
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/libcfa/stdlib	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb 24 21:07:16 2017
-// Update Count     : 101
+// Last Modified On : Sat Mar  4 22:03:54 2017
+// Update Count     : 102
 //
 
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision df47e2fe44d197c175959e907b74622b64a8430e)
+++ src/libcfa/stdlib.c	(revision 3f80888109335741bb6336c1e8cace9fe2ea46cb)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb 24 21:08:11 2017
-// Update Count     : 171
+// Last Modified On : Sat Mar  4 22:02:22 2017
+// Update Count     : 172
 //