Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 64ac636b5de5a469279d560f5378e5e32e271eec)
+++ src/Parser/DeclarationNode.cc	(revision 7c700890e7a60235a8c2486a9ee74d5b67a7024f)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 09:10:57 2017
-// Update Count     : 1007
+// Last Modified On : Fri Mar 17 08:46:05 2017
+// Update Count     : 1017
 //
 
@@ -19,5 +19,4 @@
 #include <algorithm>
 #include <cassert>
-#include <strings.h>									// ffs
 
 #include "TypeData.h"
@@ -243,12 +242,9 @@
 
 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+	assert( name );
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Aggregate );
 	newnode->type->aggregate.kind = kind;
-	if ( name ) {
-		newnode->type->aggregate.name = name;
-	} else {											// anonymous aggregate ?
-		newnode->type->aggregate.name = new string( anonymous.newName() );
-	} // if
+	newnode->type->aggregate.name = name;
 	newnode->type->aggregate.actuals = actuals;
 	newnode->type->aggregate.fields = fields;
@@ -258,11 +254,8 @@
 
 DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants, bool body ) {
+	assert( name );
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Enum );
-	if ( name ) {
-		newnode->type->enumeration.name = name;
-	} else {											// anonymous aggregate ?
-		newnode->type->enumeration.name = new string( anonymous.newName() );
-	} // if
+	newnode->type->enumeration.name = name;
 	newnode->type->enumeration.constants = constants;
 	newnode->type->enumeration.body = body;
@@ -436,8 +429,8 @@
 	const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
 
-	if ( (qsrc.val & qdst.val) != 0 ) {					// duplicates ?
+	if ( (qsrc & qdst).any() ) {						// duplicates ?
 		for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
 			if ( qsrc[i] && qdst[i] ) {
-				appendError( error, string( "duplicate " ) + Type::Qualifiers::Names[i] );
+				appendError( error, string( "duplicate " ) + Type::QualifiersNames[i] );
 			} // if
 		} // for
@@ -446,8 +439,8 @@
 
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
-	if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {	// duplicates ?
+	if ( (funcSpecs & src->funcSpecs).any() ) {			// duplicates ?
 		for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
 			if ( funcSpecs[i] && src->funcSpecs[i] ) {
-				appendError( error, string( "duplicate " ) + Type::FuncSpecifiers::Names[i] );
+				appendError( error, string( "duplicate " ) + Type::FuncSpecifiersNames[i] );
 			} // if
 		} // for
@@ -455,15 +448,15 @@
 
 	if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
-		if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
+		if ( (storageClasses & src->storageClasses ).any() ) { // duplicates ?
 			for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
 				if ( storageClasses[i] && src->storageClasses[i] ) {
-					appendError( error, string( "duplicate " ) + Type::StorageClasses::Names[i] );
+					appendError( error, string( "duplicate " ) + Type::StorageClassesNames[i] );
 				} // if
 			} // for
 			// src is the new item being added and has a single bit
 		} else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
-			appendError( error, string( "conflicting " ) + Type::StorageClasses::Names[ffs( storageClasses.val ) - 1] +
-						 " & " + Type::StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
-			src->storageClasses.val = 0;				// FIX to preserve invariant of one basic storage specifier
+			appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
+						 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
+			src->storageClasses.reset();				// FIX to preserve invariant of one basic storage specifier
 		} // if
 	} // if
@@ -473,6 +466,6 @@
 
 DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
-	funcSpecs.val |= q->funcSpecs.val;
-	storageClasses.val |= q->storageClasses.val;
+	funcSpecs |= q->funcSpecs;
+	storageClasses |= q->storageClasses;
 
 	for ( Attribute *attr: reverseIterate( q->attributes ) ) {
@@ -497,5 +490,5 @@
 		src = nullptr;
 	} else {
-		dst->qualifiers += src->qualifiers;
+		dst->qualifiers |= src->qualifiers;
 	} // if
 } // addQualifiersToType
@@ -555,10 +548,10 @@
 		switch ( dst->kind ) {
 		  case TypeData::Unknown:
-			src->qualifiers += dst->qualifiers;
+			src->qualifiers |= dst->qualifiers;
 			dst = src;
 			src = nullptr;
 			break;
 		  case TypeData::Basic:
-			dst->qualifiers += src->qualifiers;
+			dst->qualifiers |= src->qualifiers;
 			if ( src->kind != TypeData::Unknown ) {
 				assert( src->kind == TypeData::Basic );
@@ -596,5 +589,5 @@
 					dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
 				} // if
-				dst->base->qualifiers += src->qualifiers;
+				dst->base->qualifiers |= src->qualifiers;
 				src = nullptr;
 				break;
@@ -628,5 +621,5 @@
 						type->aggInst.hoistType = o->type->enumeration.body;
 					} // if
-					type->qualifiers += o->type->qualifiers;
+					type->qualifiers |= o->type->qualifiers;
 				} else {
 					type = o->type;
@@ -784,5 +777,5 @@
 					p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
 				} // if
-				p->type->base->qualifiers += type->qualifiers;
+				p->type->base->qualifiers |= type->qualifiers;
 				break;
 
@@ -821,5 +814,5 @@
 				lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
 			} // if
-			lastArray->base->qualifiers += type->qualifiers;
+			lastArray->base->qualifiers |= type->qualifiers;
 			break;
 		  default:
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 64ac636b5de5a469279d560f5378e5e32e271eec)
+++ src/Parser/TypeData.cc	(revision 7c700890e7a60235a8c2486a9ee74d5b67a7024f)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 08:32:42 2017
-// Update Count     : 559
+// Last Modified On : Fri Mar 17 08:46:10 2017
+// Update Count     : 560
 //
 
@@ -227,5 +227,5 @@
 void TypeData::print( ostream &os, int indent ) const {
 	for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
-		if ( qualifiers[i] ) os << Type::Qualifiers::Names[ i ] << ' ';
+		if ( qualifiers[i] ) os << Type::QualifiersNames[ i ] << ' ';
 	} // for
 
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision 64ac636b5de5a469279d560f5378e5e32e271eec)
+++ src/Parser/lex.ll	(revision 7c700890e7a60235a8c2486a9ee74d5b67a7024f)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu Mar  9 21:38:26 2017
- * Update Count     : 505
+ * Last Modified On : Mon Mar 13 08:36:17 2017
+ * Update Count     : 506
  */
 
@@ -313,4 +313,5 @@
 
 				/* punctuation */
+"@"				{ ASCIIOP_RETURN(); }
 "["				{ ASCIIOP_RETURN(); }
 "]"				{ ASCIIOP_RETURN(); }
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 64ac636b5de5a469279d560f5378e5e32e271eec)
+++ src/Parser/parser.yy	(revision 7c700890e7a60235a8c2486a9ee74d5b67a7024f)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 08:36:17 2017
-// Update Count     : 2310
+// Last Modified On : Thu Mar 16 12:57:03 2017
+// Update Count     : 2316
 //
 
@@ -1612,5 +1612,5 @@
 aggregate_type:											// struct, union
 	aggregate_key attribute_list_opt '{' field_declaration_list '}'
-		{ $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $4, true )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
 	| aggregate_key attribute_list_opt no_attr_identifier_or_type_name
 		{ typedefTable.makeTypedef( *$3 ); }
@@ -1618,5 +1618,5 @@
 		{ $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
 	| aggregate_key attribute_list_opt '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-		{ $$ = DeclarationNode::newAggregate( $1, nullptr, $4, $7, false )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
 	| aggregate_type_nobody
 	;
@@ -1688,6 +1688,6 @@
 	// empty
 		{ $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
-	// '@' // empty
-	// 	{ $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
+	// '@'
+	// 	{ $$ = DeclarationNode::newName( new string( DeclarationNode::anonymous.newName() ) ); } // CFA, no field name
 	| bit_subrange_size									// no field name
 		{ $$ = DeclarationNode::newBitfield( $1 ); }
@@ -1715,5 +1715,5 @@
 enum_type:												// enum
 	ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
+		{ $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
 	| ENUM attribute_list_opt no_attr_identifier_or_type_name
 		{ typedefTable.makeTypedef( *$3 ); }