Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 44a8185351c38769b27c73139cd5861fa62279f3)
+++ src/Parser/parser.yy	(revision fe26fbfeb1eddf74e6ddf2ee4ac0146237cac6eb)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jan 18 15:51:25 2017
-// Update Count     : 2135
+// Last Modified On : Mon Feb  6 16:00:29 2017
+// Update Count     : 2181
 //
 
@@ -32,4 +32,5 @@
 //
 // 1. designation with and without '=' (use ':' instead)
+// 2. attributes not allowed in parenthesis of declarator
 //
 // All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
@@ -65,4 +66,23 @@
 	to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
 } // appendStr
+
+DeclarationNode * distAttr( DeclarationNode * specifier, DeclarationNode * declList ) {
+	// distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
+	DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
+	//cur->addType( specifier );
+	for ( cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+		cl->cloneBaseType( cur );
+	} // for
+	declList->addType( cl );
+//	delete cl;
+	return declList;
+} // distAttr
+
+void distExt( DeclarationNode * declaration ) {
+	// distribute EXTENSION across all declarations
+	for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+		iter->set_extension( true );
+	} // for
+} // distExt
 %}
 
@@ -119,16 +139,16 @@
 {
 	Token tok;
-	ParseNode *pn;
-	ExpressionNode *en;
-	DeclarationNode *decl;
+	ParseNode * pn;
+	ExpressionNode * en;
+	DeclarationNode * decl;
 	DeclarationNode::Aggregate aggKey;
 	DeclarationNode::TypeClass tclass;
-	StatementNode *sn;
-	ConstantExpr *constant;
-	ForCtl *fctl;
-	LabelNode *label;
-	InitializerNode *in;
+	StatementNode * sn;
+	ConstantExpr * constant;
+	ForCtl * fctl;
+	LabelNode * label;
+	InitializerNode * in;
 	OperKinds op;
-	std::string *str;
+	std::string * str;
 	bool flag;
 }
@@ -152,5 +172,5 @@
 %type<fctl> for_control_expression
 %type<en> subrange
-%type<constant> asm_name_opt
+%type<decl> asm_name_opt
 %type<en> asm_operands_opt asm_operands_list asm_operand
 %type<label> label_list
@@ -171,12 +191,10 @@
 
 // declarations
-%type<decl> abstract_array abstract_declarator abstract_function abstract_parameter_array
-%type<decl> abstract_parameter_declaration abstract_parameter_declarator abstract_parameter_function
-%type<decl> abstract_parameter_ptr abstract_ptr
+%type<decl> abstract_declarator abstract_ptr abstract_array abstract_function array_dimension multi_array_dimension
+%type<decl> abstract_parameter_declarator abstract_parameter_ptr abstract_parameter_array abstract_parameter_function array_parameter_dimension array_parameter_1st_dimension
+%type<decl> abstract_parameter_declaration
 
 %type<aggKey> aggregate_key
-%type<decl>  aggregate_name
-
-%type<decl> array_dimension array_parameter_1st_dimension array_parameter_dimension multi_array_dimension
+%type<decl>  aggregate_type
 
 %type<decl> assertion assertion_list_opt
@@ -191,7 +209,7 @@
 %type<decl> declaration_specifier declarator declaring_list
 
-%type<decl> elaborated_type_name
-
-%type<decl> enumerator_list enum_name
+%type<decl> elaborated_type
+
+%type<decl> enumerator_list enum_type
 %type<en> enumerator_value_opt
 
@@ -206,22 +224,23 @@
 %type<decl> identifier_parameter_ptr identifier_list
 
-%type<decl> new_abstract_array new_abstract_declarator_no_tuple new_abstract_declarator_tuple
-%type<decl> new_abstract_function new_abstract_parameter_declaration new_abstract_parameter_list
-%type<decl> new_abstract_ptr new_abstract_tuple
-
-%type<decl> new_array_parameter_1st_dimension
-
-%type<decl> new_trait_declaring_list new_declaration new_field_declaring_list
-%type<decl> new_function_declaration new_function_return new_function_specifier
-
-%type<decl> new_identifier_parameter_array new_identifier_parameter_declarator_no_tuple
-%type<decl> new_identifier_parameter_declarator_tuple new_identifier_parameter_ptr
-
-%type<decl> new_parameter_declaration new_parameter_list new_parameter_type_list new_parameter_type_list_opt
-
-%type<decl> new_typedef_declaration new_variable_declaration new_variable_specifier
-
-%type<decl> old_declaration old_declaration_list old_declaration_list_opt old_function_array
-%type<decl> old_function_declarator old_function_no_ptr old_function_ptr
+%type<decl> cfa_abstract_array cfa_abstract_declarator_no_tuple cfa_abstract_declarator_tuple
+%type<decl> cfa_abstract_function cfa_abstract_parameter_declaration cfa_abstract_parameter_list
+%type<decl> cfa_abstract_ptr cfa_abstract_tuple
+
+%type<decl> cfa_array_parameter_1st_dimension
+
+%type<decl> cfa_trait_declaring_list cfa_declaration cfa_field_declaring_list
+%type<decl> cfa_function_declaration cfa_function_return cfa_function_specifier
+
+%type<decl> cfa_identifier_parameter_array cfa_identifier_parameter_declarator_no_tuple
+%type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
+
+%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list cfa_parameter_type_list_opt
+
+%type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
+
+%type<decl> c_declaration
+%type<decl> KR_function_declarator KR_function_no_ptr KR_function_ptr KR_function_array
+%type<decl> KR_declaration_list KR_declaration_list_opt
 
 %type<decl> parameter_declaration parameter_list parameter_type_list
@@ -237,7 +256,9 @@
 %type<decl> type_declarator type_declarator_name type_declaring_list
 
-%type<decl> typedef type_array typedef_declaration typedef_declaration_specifier typedef_expression
-%type<decl> type_function type_parameter_array type_parameter_function type_parameter_ptr
-%type<decl> type_parameter_redeclarator type_ptr variable_type_redeclarator typedef_type_specifier
+%type<decl> typedef typedef_type_specifier typedef_declaration typedef_declaration_specifier typedef_expression
+
+%type<decl> variable_type_redeclarator type_ptr type_array type_function
+
+%type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
 %type<decl> typegen_declaration_specifier typegen_type_specifier typegen_name
 
@@ -249,6 +270,6 @@
 %type<decl> type_qualifier type_qualifier_name type_qualifier_list type_qualifier_list_opt type_specifier
 
-%type<decl> variable_abstract_array variable_abstract_declarator variable_abstract_function
-%type<decl> variable_abstract_ptr variable_array variable_declarator variable_function variable_ptr
+%type<decl> variable_declarator variable_ptr variable_array variable_function
+%type<decl> variable_abstract_declarator variable_abstract_ptr variable_abstract_array variable_abstract_function
 
 %type<decl> attribute_list_opt attribute_list attribute_name_list attribute attribute_name
@@ -659,5 +680,5 @@
 tuple:													// CFA, tuple
 		// CFA, one assignment_expression is factored out of comma_expression to eliminate a shift/reduce conflict with
-		// comma_expression in new_identifier_parameter_array and new_abstract_array
+		// comma_expression in cfa_identifier_parameter_array and cfa_abstract_array
 //	'[' ']'
 //		{ $$ = new ExpressionNode( build_tuple() ); }
@@ -723,5 +744,6 @@
 	  push push
 	  local_label_declaration_opt						// GCC, local labels
-	  block_item_list pop '}'							// C99, intermix declarations and statements
+	  block_item_list									// C99, intermix declarations and statements
+	  pop '}'
 		{ $$ = new StatementNode( build_compound( $5 ) ); }
 	;
@@ -737,11 +759,15 @@
 		{ $$ = new StatementNode( $1 ); }
 	| EXTENSION declaration								// GCC
-		{	// mark all fields in list
-			for ( DeclarationNode *iter = $2; iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
-				iter->set_extension( true );
+		{
+			distExt( $2 );
 			$$ = new StatementNode( $2 );
 		}
 	| function_definition
 		{ $$ = new StatementNode( $1 ); }
+	| EXTENSION function_definition						// GCC
+		{
+			distExt( $2 );
+			$$ = new StatementNode( $2 );
+		}
 	| statement pop
 	;
@@ -960,10 +986,10 @@
 	| type_specifier variable_abstract_declarator
 		{ $$ = $2->addType( $1 ); }
-	| new_abstract_declarator_tuple no_attr_identifier	// CFA
+	| cfa_abstract_declarator_tuple no_attr_identifier	// CFA
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = $1->addName( $2 );
 		}
-	| new_abstract_declarator_tuple						// CFA
+	| cfa_abstract_declarator_tuple						// CFA
 	;
 
@@ -1044,13 +1070,13 @@
 	;
 
-old_declaration_list_opt:								// used to declare parameter types in K&R style functions
+KR_declaration_list_opt:								// used to declare parameter types in K&R style functions
 	pop
 		{ $$ = nullptr; }
-	| old_declaration_list
-	;
-
-old_declaration_list:
-	old_declaration
-	| old_declaration_list push old_declaration
+	| KR_declaration_list
+	;
+
+KR_declaration_list:
+	c_declaration
+	| KR_declaration_list push c_declaration
 		{ $$ = $1->appendList( $3 ); }
 	;
@@ -1072,6 +1098,6 @@
 
 declaration:											// CFA, new & old style declarations
-	new_declaration
-	| old_declaration
+	cfa_declaration
+	| c_declaration
 	;
 
@@ -1087,19 +1113,19 @@
 //		[10] * char y;		char *y[10];	// array of 10 pointers to char
 
-new_declaration:										// CFA
-	new_variable_declaration pop ';'
-	| new_typedef_declaration pop ';'
-	| new_function_declaration pop ';'
+cfa_declaration:										// CFA
+	cfa_variable_declaration pop ';'
+	| cfa_typedef_declaration pop ';'
+	| cfa_function_declaration pop ';'
 	| type_declaring_list pop ';'
 	| trait_specifier pop ';'
 	;
 
-new_variable_declaration:								// CFA
-	new_variable_specifier initializer_opt
+cfa_variable_declaration:								// CFA
+	cfa_variable_specifier initializer_opt
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = $1->addInitializer( $2 );
 		}
-	| declaration_qualifier_list new_variable_specifier initializer_opt
+	| declaration_qualifier_list cfa_variable_specifier initializer_opt
 		// declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to preclude
 		// them as a type_qualifier cannot appear in that context.
@@ -1108,5 +1134,5 @@
 			$$ = $2->addQualifiers( $1 )->addInitializer( $3 );;
 		}
-	| new_variable_declaration pop ',' push identifier_or_type_name initializer_opt
+	| cfa_variable_declaration pop ',' push identifier_or_type_name initializer_opt
 		{
 			typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
@@ -1115,18 +1141,18 @@
 	;
 
-new_variable_specifier:									// CFA
+cfa_variable_specifier:									// CFA
 		// A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
 		// storage-class
-	new_abstract_declarator_no_tuple identifier_or_type_name asm_name_opt
+	cfa_abstract_declarator_no_tuple identifier_or_type_name asm_name_opt
 		{
 			typedefTable.setNextIdentifier( *$2 );
 			$$ = $1->addName( $2 )->addAsmName( $3 );
 		}
-	| new_abstract_tuple identifier_or_type_name asm_name_opt
+	| cfa_abstract_tuple identifier_or_type_name asm_name_opt
 		{
 			typedefTable.setNextIdentifier( *$2 );
 			$$ = $1->addName( $2 )->addAsmName( $3 );
 		}
-	| type_qualifier_list new_abstract_tuple identifier_or_type_name asm_name_opt
+	| type_qualifier_list cfa_abstract_tuple identifier_or_type_name asm_name_opt
 		{
 			typedefTable.setNextIdentifier( *$3 );
@@ -1135,26 +1161,26 @@
 	;
 
-new_function_declaration:								// CFA
-	new_function_specifier
+cfa_function_declaration:								// CFA
+	cfa_function_specifier
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = $1;
 		}
-	| type_qualifier_list new_function_specifier
+	| type_qualifier_list cfa_function_specifier
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = $2->addQualifiers( $1 );
 		}
-	| declaration_qualifier_list new_function_specifier
+	| declaration_qualifier_list cfa_function_specifier
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = $2->addQualifiers( $1 );
 		}
-	| declaration_qualifier_list type_qualifier_list new_function_specifier
+	| declaration_qualifier_list type_qualifier_list cfa_function_specifier
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
 		}
-	| new_function_declaration pop ',' push identifier_or_type_name
+	| cfa_function_declaration pop ',' push identifier_or_type_name
 		{
 			typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
@@ -1163,15 +1189,15 @@
 	;
 
-new_function_specifier:									// CFA
-//	'[' ']' identifier_or_type_name '(' push new_parameter_type_list_opt pop ')' // S/R conflict
+cfa_function_specifier:									// CFA
+//	'[' ']' identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')' // S/R conflict
 //		{
 //			$$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
 //		}
-//	'[' ']' identifier '(' push new_parameter_type_list_opt pop ')'
+//	'[' ']' identifier '(' push cfa_parameter_type_list_opt pop ')'
 //		{
 //			typedefTable.setNextIdentifier( *$5 );
 //			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
 //		}
-//	| '[' ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')'
+//	| '[' ']' TYPEDEFname '(' push cfa_parameter_type_list_opt pop ')'
 //		{
 //			typedefTable.setNextIdentifier( *$5 );
@@ -1181,15 +1207,15 @@
 		// identifier_or_type_name must be broken apart because of the sequence:
 		//
-		//   '[' ']' identifier_or_type_name '(' new_parameter_type_list_opt ')'
+		//   '[' ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
 		//   '[' ']' type_specifier
 		//
 		// type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be
 		// flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name.
-	new_abstract_tuple identifier_or_type_name '(' push new_parameter_type_list_opt pop ')'
-		// To obtain LR(1 ), this rule must be factored out from function return type (see new_abstract_declarator).
+	cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
+		// To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
 		{
 			$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
 		}
-	| new_function_return identifier_or_type_name '(' push new_parameter_type_list_opt pop ')'
+	| cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
 		{
 			$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
@@ -1197,25 +1223,25 @@
 	;
 
-new_function_return:									// CFA
-	'[' push new_parameter_list pop ']'
+cfa_function_return:									// CFA
+	'[' push cfa_parameter_list pop ']'
 		{ $$ = DeclarationNode::newTuple( $3 ); }
-	| '[' push new_parameter_list pop ',' push new_abstract_parameter_list pop ']'
-		// To obtain LR(1 ), the last new_abstract_parameter_list is added into this flattened rule to lookahead to the
+	| '[' push cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ']'
+		// To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the
 		// ']'.
 		{ $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
 	;
 
-new_typedef_declaration:								// CFA
-	TYPEDEF new_variable_specifier
+cfa_typedef_declaration:								// CFA
+	TYPEDEF cfa_variable_specifier
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::TD );
 			$$ = $2->addTypedef();
 		}
-	| TYPEDEF new_function_specifier
+	| TYPEDEF cfa_function_specifier
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::TD );
 			$$ = $2->addTypedef();
 		}
-	| new_typedef_declaration pop ',' push no_attr_identifier
+	| cfa_typedef_declaration pop ',' push no_attr_identifier
 		{
 			typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
@@ -1260,15 +1286,40 @@
 		{
 			typedefTable.addToEnclosingScope( *$2, TypedefTable::TD );
-			$$ = DeclarationNode::newName( 0 ); // XXX
+			$$ = DeclarationNode::newName( 0 );			// unimplemented
 		}
 	| typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
 		{
 			typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
-			$$ = DeclarationNode::newName( 0 ); // XXX
-		}
-	;
-
-old_declaration:
-	declaring_list pop ';'
+			$$ = DeclarationNode::newName( 0 );			// unimplemented
+		}
+	;
+
+//c_declaration:
+//	declaring_list pop ';'
+//	| typedef_declaration pop ';'
+//	| typedef_expression pop ';'						// GCC, naming expression type
+//	| sue_declaration_specifier pop ';'
+//	;
+//
+//declaring_list:
+//		// A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
+//		// storage-class
+//	 declarator asm_name_opt initializer_opt
+//		{
+//			typedefTable.addToEnclosingScope( TypedefTable::ID );
+//			$$ = ( $2->addType( $1 ))->addAsmName( $3 )->addInitializer( $4 );
+//		}
+//	| declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
+//		{
+//			typedefTable.addToEnclosingScope( TypedefTable::ID );
+//			$$ = $1->appendList( $1->cloneBaseType( $4->addAsmName( $5 )->addInitializer( $6 ) ) );
+//		}
+//	;
+
+c_declaration:
+	declaration_specifier declaring_list pop ';'
+		{
+			$$ = distAttr( $1, $2 );
+		}
 	| typedef_declaration pop ';'
 	| typedef_expression pop ';'						// GCC, naming expression type
@@ -1279,13 +1330,13 @@
 		// A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
 		// storage-class
-	declaration_specifier declarator asm_name_opt initializer_opt
+	declarator asm_name_opt initializer_opt
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = ( $2->addType( $1 ))->addAsmName( $3 )->addInitializer( $4 );
+			$$ = $1->addAsmName( $2 )->addInitializer( $3 );
 		}
 	| declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
-			$$ = $1->appendList( $1->cloneBaseType( $4->addAsmName( $5 )->addInitializer( $6 ) ) );
+			$$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) );
 		}
 	;
@@ -1474,6 +1525,6 @@
 
 sue_type_specifier:
-	elaborated_type_name								// struct, union, enum
-	| type_qualifier_list elaborated_type_name
+	elaborated_type										// struct, union, enum
+	| type_qualifier_list elaborated_type
 		{ $$ = $2->addQualifiers( $1 ); }
 	| sue_type_specifier type_qualifier
@@ -1500,31 +1551,31 @@
 	;
 
-elaborated_type_name:
-	aggregate_name
-	| enum_name
-	;
-
-aggregate_name:
-	aggregate_key '{' field_declaration_list '}'
-		{ $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $3, true ); }
-	| aggregate_key no_attr_identifier_or_type_name
-		{
-			typedefTable.makeTypedef( *$2 );
-			$$ = DeclarationNode::newAggregate( $1, $2, nullptr, nullptr, false );
-		}
-	| aggregate_key no_attr_identifier_or_type_name
-		{ typedefTable.makeTypedef( *$2 ); }
-		'{' field_declaration_list '}'
-		{ $$ = DeclarationNode::newAggregate( $1, $2, nullptr, $5, true ); }
-	| aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-		{ $$ = DeclarationNode::newAggregate( $1, nullptr, $3, $6, false ); }
-	| aggregate_key typegen_name						// CFA, S/R conflict
-		{ $$ = $2; }
+elaborated_type:
+	aggregate_type
+	| enum_type
+	;
+
+aggregate_type:
+	aggregate_key attribute_list_opt '{' field_declaration_list '}'
+		{ $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $4, true )->addQualifiers( $2 ); }
+	| aggregate_key attribute_list_opt no_attr_identifier_or_type_name
+		{
+			typedefTable.makeTypedef( *$3 );
+			$$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
+		}
+	| aggregate_key attribute_list_opt no_attr_identifier_or_type_name
+		{ typedefTable.makeTypedef( *$3 ); }
+	  '{' field_declaration_list '}'
+		{ $$ = 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 ); }
+	| aggregate_key attribute_list_opt typegen_name		// CFA, S/R conflict
+		{ $$ = $3->addQualifiers( $2 ); }
 	;
 
 aggregate_key:
-	STRUCT attribute_list_opt
+	STRUCT
 		{ $$ = DeclarationNode::Struct; }
-	| UNION attribute_list_opt
+	| UNION
 		{ $$ = DeclarationNode::Union; }
 	;
@@ -1538,31 +1589,34 @@
 
 field_declaration:
-	new_field_declaring_list ';'						// CFA, new style field declaration
-	| EXTENSION new_field_declaring_list ';'			// GCC
-		{ $$ = $2->set_extension( true ); }
-	| field_declaring_list ';'
-	| EXTENSION field_declaring_list ';'				// GCC
-		{	// mark all fields in list
-			for ( DeclarationNode *iter = $2; iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
-				iter->set_extension( true );
+	cfa_field_declaring_list ';'						// CFA, new style field declaration
+	| EXTENSION cfa_field_declaring_list ';'			// GCC
+		{
+			distExt( $2 );								// mark all fields in list
 			$$ = $2;
 		}
-	;
-
-new_field_declaring_list:								// CFA, new style field declaration
-	new_abstract_declarator_tuple						// CFA, no field name
-	| new_abstract_declarator_tuple no_attr_identifier_or_type_name
+	| type_specifier field_declaring_list ';'
+		{
+			$$ = distAttr( $1, $2 ); }
+	| EXTENSION type_specifier field_declaring_list ';'	// GCC
+		{
+			distExt( $3 );								// mark all fields in list
+			$$ = distAttr( $2, $3 );
+		}
+	;
+
+cfa_field_declaring_list:								// CFA, new style field declaration
+	cfa_abstract_declarator_tuple						// CFA, no field name
+	| cfa_abstract_declarator_tuple no_attr_identifier_or_type_name
 		{ $$ = $1->addName( $2 ); }
-	| new_field_declaring_list ',' no_attr_identifier_or_type_name
+	| cfa_field_declaring_list ',' no_attr_identifier_or_type_name
 		{ $$ = $1->appendList( $1->cloneType( $3 ) ); }
-	| new_field_declaring_list ','						// CFA, no field name
+	| cfa_field_declaring_list ','						// CFA, no field name
 		{ $$ = $1->appendList( $1->cloneType( 0 ) ); }
 	;
 
 field_declaring_list:
-	type_specifier field_declarator
-		{ $$ = $2->addType( $1 ); }
+	field_declarator
 	| field_declaring_list ',' attribute_list_opt field_declarator
-		{ $$ = $1->appendList( $1->cloneBaseType( $4 ) ); }
+		{ $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
 	;
 
@@ -1593,20 +1647,16 @@
 	;
 
-enum_key:
-	ENUM attribute_list_opt
-	;
-
-enum_name:
-	enum_key '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( nullptr, $3 ); }
-	| enum_key no_attr_identifier_or_type_name
-		{
-			typedefTable.makeTypedef( *$2 );
-			$$ = DeclarationNode::newEnum( $2, 0 );
-		}
-	| enum_key no_attr_identifier_or_type_name
-		{ typedefTable.makeTypedef( *$2 ); }
-		'{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( $2, $5 ); }
+enum_type:
+	ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
+		{ $$ = DeclarationNode::newEnum( nullptr, $4 )->addQualifiers( $2 ); }
+	| ENUM attribute_list_opt no_attr_identifier_or_type_name
+		{
+			typedefTable.makeTypedef( *$3 );
+			$$ = DeclarationNode::newEnum( $3, 0 )->addQualifiers( $2 );
+		}
+	| ENUM attribute_list_opt no_attr_identifier_or_type_name
+		{ typedefTable.makeTypedef( *$3 ); }
+	  '{' enumerator_list comma_opt '}'
+		{ $$ = DeclarationNode::newEnum( $3, $6 )->addQualifiers( $2 ); }
 	;
 
@@ -1627,36 +1677,36 @@
 // Minimum of one parameter after which ellipsis is allowed only at the end.
 
-new_parameter_type_list_opt:							// CFA
+cfa_parameter_type_list_opt:							// CFA
 	// empty
 		{ $$ = nullptr; }
-	| new_parameter_type_list
-	;
-
-new_parameter_type_list:								// CFA, abstract + real
-	new_abstract_parameter_list
-	| new_parameter_list
-	| new_parameter_list pop ',' push new_abstract_parameter_list
+	| cfa_parameter_type_list
+	;
+
+cfa_parameter_type_list:								// CFA, abstract + real
+	cfa_abstract_parameter_list
+	| cfa_parameter_list
+	| cfa_parameter_list pop ',' push cfa_abstract_parameter_list
 		{ $$ = $1->appendList( $5 ); }
-	| new_abstract_parameter_list pop ',' push ELLIPSIS
+	| cfa_abstract_parameter_list pop ',' push ELLIPSIS
 		{ $$ = $1->addVarArgs(); }
-	| new_parameter_list pop ',' push ELLIPSIS
+	| cfa_parameter_list pop ',' push ELLIPSIS
 		{ $$ = $1->addVarArgs(); }
 	;
 
-new_parameter_list:										// CFA
-		// To obtain LR(1) between new_parameter_list and new_abstract_tuple, the last new_abstract_parameter_list is
-		// factored out from new_parameter_list, flattening the rules to get lookahead to the ']'.
-	new_parameter_declaration
-	| new_abstract_parameter_list pop ',' push new_parameter_declaration
+cfa_parameter_list:										// CFA
+		// To obtain LR(1) between cfa_parameter_list and cfa_abstract_tuple, the last cfa_abstract_parameter_list is
+		// factored out from cfa_parameter_list, flattening the rules to get lookahead to the ']'.
+	cfa_parameter_declaration
+	| cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
 		{ $$ = $1->appendList( $5 ); }
-	| new_parameter_list pop ',' push new_parameter_declaration
+	| cfa_parameter_list pop ',' push cfa_parameter_declaration
 		{ $$ = $1->appendList( $5 ); }
-	| new_parameter_list pop ',' push new_abstract_parameter_list pop ',' push new_parameter_declaration
+	| cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
 		{ $$ = $1->appendList( $5 )->appendList( $9 ); }
 	;
 
-new_abstract_parameter_list:							// CFA, new & old style abstract
-	new_abstract_parameter_declaration
-	| new_abstract_parameter_list pop ',' push new_abstract_parameter_declaration
+cfa_abstract_parameter_list:							// CFA, new & old style abstract
+	cfa_abstract_parameter_declaration
+	| cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration
 		{ $$ = $1->appendList( $5 ); }
 	;
@@ -1686,24 +1736,24 @@
 // for typedef name by using type_parameter_redeclarator instead of typedef_redeclarator, and function prototypes.
 
-new_parameter_declaration:								// CFA, new & old style parameter declaration
+cfa_parameter_declaration:								// CFA, new & old style parameter declaration
 	parameter_declaration
-	| new_identifier_parameter_declarator_no_tuple identifier_or_type_name assignment_opt
+	| cfa_identifier_parameter_declarator_no_tuple identifier_or_type_name assignment_opt
 		{ $$ = $1->addName( $2 ); }
-	| new_abstract_tuple identifier_or_type_name assignment_opt
-		// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
+	| cfa_abstract_tuple identifier_or_type_name assignment_opt
+		// To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
 		{ $$ = $1->addName( $2 ); }
-	| type_qualifier_list new_abstract_tuple identifier_or_type_name assignment_opt
+	| type_qualifier_list cfa_abstract_tuple identifier_or_type_name assignment_opt
 		{ $$ = $2->addName( $3 )->addQualifiers( $1 ); }
-	| new_function_specifier
-	;
-
-new_abstract_parameter_declaration:						// CFA, new & old style parameter declaration
+	| cfa_function_specifier
+	;
+
+cfa_abstract_parameter_declaration:						// CFA, new & old style parameter declaration
 	abstract_parameter_declaration
-	| new_identifier_parameter_declarator_no_tuple
-	| new_abstract_tuple
-		// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
-	| type_qualifier_list new_abstract_tuple
+	| cfa_identifier_parameter_declarator_no_tuple
+	| cfa_abstract_tuple
+		// To obtain LR(1), these rules must be duplicated here (see cfa_abstract_declarator).
+	| type_qualifier_list cfa_abstract_tuple
 		{ $$ = $2->addQualifiers( $1 ); }
-	| new_abstract_function
+	| cfa_abstract_function
 	;
 
@@ -1757,16 +1807,13 @@
 
 type_name_no_function:									// sizeof, alignof, cast (constructor)
-	new_abstract_declarator_tuple						// CFA
-	| type_specifier
-	| type_specifier variable_abstract_declarator
-		{ $$ = $2->addType( $1 ); }
-	;
-
-type_name:												// typeof, assertion
-	new_abstract_declarator_tuple						// CFA
-	| new_abstract_function								// CFA
+	cfa_abstract_declarator_tuple						// CFA
 	| type_specifier
 	| type_specifier abstract_declarator
 		{ $$ = $2->addType( $1 ); }
+	;
+
+type_name:												// typeof, assertion
+	type_name_no_function
+	| cfa_abstract_function								// CFA
 	;
 
@@ -1982,20 +2029,20 @@
 
 trait_declaration:									// CFA
-	new_trait_declaring_list pop ';'
+	cfa_trait_declaring_list pop ';'
 	| trait_declaring_list pop ';'
 	;
 
-new_trait_declaring_list:								// CFA
-	new_variable_specifier
+cfa_trait_declaring_list:								// CFA
+	cfa_variable_specifier
 		{
 			typedefTable.addToEnclosingScope2( TypedefTable::ID );
 			$$ = $1;
 		}
-	| new_function_specifier
+	| cfa_function_specifier
 		{
 			typedefTable.addToEnclosingScope2( TypedefTable::ID );
 			$$ = $1;
 		}
-	| new_trait_declaring_list pop ',' push identifier_or_type_name
+	| cfa_trait_declaring_list pop ',' push identifier_or_type_name
 		{
 			typedefTable.addToEnclosingScope2( *$5, TypedefTable::ID );
@@ -2043,10 +2090,10 @@
 	| asm_statement										// GCC, global assembler statement
 		{}
-	| EXTERN STRINGliteral
+	| EXTERN STRINGliteral								// C++-style linkage specifier
 		{
 			linkageStack.push( linkage );				// handle nested extern "C"/"Cforall"
 			linkage = LinkageSpec::linkageCheck( $2 );
 		}
-	  '{' external_definition_list_opt '}'				// C++-style linkage specifier
+	  '{' external_definition_list_opt '}'
 		{
 			linkage = linkageStack.top();
@@ -2054,8 +2101,7 @@
 			$$ = $5;
 		}
-	| EXTENSION external_definition
-		{	// mark all fields in list
-			for ( DeclarationNode *iter = $2; iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
-				iter->set_extension( true );
+	| EXTENSION external_definition						// GCC, multiple __extension__ allowed, meaning unknown
+		{
+			distExt( $2 );								// mark all fields in list
 			$$ = $2;
 		}
@@ -2075,5 +2121,5 @@
 			$$ = $1->addFunctionBody( $2 );
 		}
-	| old_function_declarator push old_declaration_list_opt compound_statement
+	| KR_function_declarator push KR_declaration_list_opt compound_statement
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -2084,5 +2130,5 @@
 
 function_definition:
-	new_function_declaration compound_statement			// CFA
+	cfa_function_declaration compound_statement			// CFA
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -2116,5 +2162,5 @@
 
 		// Old-style K&R function definition, OBSOLESCENT (see 4)
-	| declaration_specifier old_function_declarator push old_declaration_list_opt compound_statement
+	| declaration_specifier KR_function_declarator push KR_declaration_list_opt compound_statement
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -2122,5 +2168,5 @@
 			$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addType( $1 );
 		}
-	| type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
+	| type_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -2130,5 +2176,5 @@
 
 		// Old-style K&R function definition with "implicit int" type_specifier, OBSOLESCENT (see 4)
-	| declaration_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
+	| declaration_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -2136,5 +2182,5 @@
 			$$ = $2->addOldDeclList( $4 )->addFunctionBody( $5 )->addQualifiers( $1 );
 		}
-	| declaration_qualifier_list type_qualifier_list old_function_declarator push old_declaration_list_opt compound_statement
+	| declaration_qualifier_list type_qualifier_list KR_function_declarator push KR_declaration_list_opt compound_statement
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -2159,5 +2205,9 @@
 		{ $$ = nullptr; }
 	| ASM '(' string_literal ')' attribute_list_opt
-		{ $$ = $3; }
+		{
+			DeclarationNode * name = new DeclarationNode();
+			name->asmName = $3;
+			$$ = name->addQualifiers( $5 );
+		}
 	;
 
@@ -2182,5 +2232,5 @@
 	attribute_name
 	| attribute_name_list ',' attribute_name
-		{ $$ = $1->addQualifiers( $3 ); } 
+		{ $$ = $3->addQualifiers( $1 ); }
 	;
 
@@ -2257,6 +2307,6 @@
 	| ptrref_operator type_qualifier_list variable_declarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' variable_ptr ')'
-		{ $$ = $2; }
+	| '(' variable_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }				// redundant parenthesis
 	;
 
@@ -2318,38 +2368,41 @@
 	;
 
-// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4) that is not redefining a typedef name
-// (see function_declarator for additional comments). The pattern precludes returning arrays and functions versus
-// pointers to arrays and functions.
-
-old_function_declarator:
-	old_function_no_ptr
-	| old_function_ptr
-	| old_function_array
-	;
-
-old_function_no_ptr:
+// This pattern parses an old-style K&R function declarator (OBSOLESCENT, see 4)
+//
+//   f( a, b, c ) int a, *b, c[]; {}
+//
+// that is not redefining a typedef name (see function_declarator for additional comments). The pattern precludes
+// returning arrays and functions versus pointers to arrays and functions.
+
+KR_function_declarator:
+	KR_function_no_ptr
+	| KR_function_ptr
+	| KR_function_array
+	;
+
+KR_function_no_ptr:
 	paren_identifier '(' identifier_list ')'			// function_declarator handles empty parameter
 		{ $$ = $1->addIdList( $3 ); }
-	| '(' old_function_ptr ')' '(' identifier_list ')'
-		{ $$ = $2->addIdList( $5 ); }
-	| '(' old_function_no_ptr ')'						// redundant parenthesis
+	| '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
+		{ $$ = $2->addParamList( $6 ); }
+	| '(' KR_function_no_ptr ')'						// redundant parenthesis
 		{ $$ = $2; }
 	;
 
-old_function_ptr:
-	ptrref_operator old_function_declarator
+KR_function_ptr:
+	ptrref_operator KR_function_declarator
 		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| ptrref_operator type_qualifier_list old_function_declarator
+	| ptrref_operator type_qualifier_list KR_function_declarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' old_function_ptr ')'
+	| '(' KR_function_ptr ')'
 		{ $$ = $2; }
 	;
 
-old_function_array:
-	'(' old_function_ptr ')' array_dimension
+KR_function_array:
+	'(' KR_function_ptr ')' array_dimension
 		{ $$ = $2->addArray( $4 ); }
-	| '(' old_function_array ')' multi_array_dimension	// redundant parenthesis
+	| '(' KR_function_array ')' multi_array_dimension	// redundant parenthesis
 		{ $$ = $2->addArray( $4 ); }
-	| '(' old_function_array ')'						// redundant parenthesis
+	| '(' KR_function_array ')'							// redundant parenthesis
 		{ $$ = $2; }
 	;
@@ -2386,6 +2439,6 @@
 	| ptrref_operator type_qualifier_list variable_type_redeclarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' type_ptr ')'
-		{ $$ = $2; }
+	| '(' type_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }
 	;
 
@@ -2410,8 +2463,8 @@
 	;
 
-// This pattern parses a declaration for a parameter variable or function prototype that is not redefining a typedef
-// name and allows the C99 array options, which can only appear in a parameter list.  The pattern precludes declaring an
-// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
-// arrays and functions.
+// This pattern parses a declaration for a parameter variable of a function prototype or actual that is not redefining a
+// typedef name and allows the C99 array options, which can only appear in a parameter list.  The pattern precludes
+// declaring an array of functions versus a pointer to an array of functions, and returning arrays and functions versus
+// pointers to arrays and functions.
 
 identifier_parameter_declarator:
@@ -2430,6 +2483,6 @@
 	| ptrref_operator type_qualifier_list identifier_parameter_declarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' identifier_parameter_ptr ')'
-		{ $$ = $2; }
+	| '(' identifier_parameter_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }
 	;
 
@@ -2460,23 +2513,5 @@
 //		int f( int foo ); // redefine typedef name in new scope
 //
-// and allows the C99 array options, which can only appear in a parameter list.  In addition, the pattern handles the
-// special meaning of parenthesis around a typedef name:
-//
-//		ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in
-//		parentheses is taken to be an abstract declarator that specifies a function with a single parameter,
-//		not as redundant parentheses around the identifier."
-//
-// For example:
-//
-//		typedef float T;
-//		int f( int ( T [5] ) );					// see abstract_parameter_declarator
-//		int g( int ( T ( int ) ) );				// see abstract_parameter_declarator
-//		int f( int f1( T a[5] ) );				// see identifier_parameter_declarator
-//		int g( int g1( T g2( int p ) ) );		// see identifier_parameter_declarator
-//
-// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type list, and
-// not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes declaring an array of
-// functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to arrays and
-// functions.
+// and allows the C99 array options, which can only appear in a parameter list.
 
 type_parameter_redeclarator:
@@ -2508,6 +2543,6 @@
 	| ptrref_operator type_qualifier_list type_parameter_redeclarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' type_parameter_ptr ')'
-		{ $$ = $2; }
+	| '(' type_parameter_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }
 	;
 
@@ -2530,5 +2565,8 @@
 //
 //		sizeof( int );
+//		sizeof( int * );
 //		sizeof( int [10] );
+//		sizeof( int (*)() );
+//		sizeof( int () );
 //
 // The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
@@ -2552,6 +2590,6 @@
 	| ptrref_operator type_qualifier_list abstract_declarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' abstract_ptr ')'
-		{ $$ = $2; }
+	| '(' abstract_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }
 	;
 
@@ -2598,9 +2636,29 @@
 // identifier to which the type applies, e.g.:
 //
-//		int f( int );			// abstract variable parameter; no parameter name specified
+//		int f( int );			// not handled here
+//		int f( int * );			// abstract function-prototype parameter; no parameter name specified
+//		int f( int (*)() );		// abstract function-prototype parameter; no parameter name specified
 //		int f( int (int) );		// abstract function-prototype parameter; no parameter name specified
 //
 // The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
+// and functions versus pointers to arrays and functions. In addition, the pattern handles the
+// special meaning of parenthesis around a typedef name:
+//
+//		ISO/IEC 9899:1999 Section 6.7.5.3(11) : "In a parameter declaration, a single typedef name in
+//		parentheses is taken to be an abstract declarator that specifies a function with a single parameter,
+//		not as redundant parentheses around the identifier."
+//
+// For example:
+//
+//		typedef float T;
+//		int f( int ( T [5] ) );					// see abstract_parameter_declarator
+//		int g( int ( T ( int ) ) );				// see abstract_parameter_declarator
+//		int f( int f1( T a[5] ) );				// see identifier_parameter_declarator
+//		int g( int g1( T g2( int p ) ) );		// see identifier_parameter_declarator
+//
+// In essence, a '(' immediately to the left of typedef name, T, is interpreted as starting a parameter type list, and
+// not as redundant parentheses around a redeclaration of T. Finally, the pattern also precludes declaring an array of
+// functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to arrays and
+// functions.
 
 abstract_parameter_declarator:
@@ -2614,13 +2672,13 @@
 abstract_parameter_ptr:
 	ptrref_operator
-		{ $$ = DeclarationNode::newPointer( 0 ); }
+		{ $$ = DeclarationNode::newPointer( nullptr ); }
 	| ptrref_operator type_qualifier_list
 		{ $$ = DeclarationNode::newPointer( $2 ); }
 	| ptrref_operator abstract_parameter_declarator
-		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+		{ $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); }
 	| ptrref_operator type_qualifier_list abstract_parameter_declarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' abstract_parameter_ptr ')'
-		{ $$ = $2; }
+	| '(' abstract_parameter_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }
 	;
 
@@ -2674,11 +2732,12 @@
 	;
 
-// This pattern parses a declaration of an abstract variable, i.e., there is no identifier to which the type applies,
-// e.g.:
-//
-//		sizeof( int ); // abstract variable; no identifier name specified
-//
-// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
-// and functions versus pointers to arrays and functions.
+// This pattern parses a declaration of an abstract variable, but does not allow "int ()" for a function pointer.
+//
+//		struct S {
+//          int;
+//          int *;
+//          int [10];
+//          int (*)();
+//      };
 
 variable_abstract_declarator:
@@ -2699,6 +2758,6 @@
 	| ptrref_operator type_qualifier_list variable_abstract_declarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' variable_abstract_ptr ')'
-		{ $$ = $2; }
+	| '(' variable_abstract_ptr ')' attribute_list_opt
+		{ $$ = $2->addQualifiers( $4 ); }
 	;
 
@@ -2723,58 +2782,58 @@
 // identifier or typedef name and allows the C99 array options, which can only appear in a parameter list.
 
-new_identifier_parameter_declarator_tuple:				// CFA
-	new_identifier_parameter_declarator_no_tuple
-	| new_abstract_tuple
-	| type_qualifier_list new_abstract_tuple
+cfa_identifier_parameter_declarator_tuple:				// CFA
+	cfa_identifier_parameter_declarator_no_tuple
+	| cfa_abstract_tuple
+	| type_qualifier_list cfa_abstract_tuple
 		{ $$ = $2->addQualifiers( $1 ); }
 	;
 
-new_identifier_parameter_declarator_no_tuple:			// CFA
-	new_identifier_parameter_ptr
-	| new_identifier_parameter_array
-	;
-
-new_identifier_parameter_ptr:							// CFA
+cfa_identifier_parameter_declarator_no_tuple:			// CFA
+	cfa_identifier_parameter_ptr
+	| cfa_identifier_parameter_array
+	;
+
+cfa_identifier_parameter_ptr:							// CFA
 	ptrref_operator type_specifier
 		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
 	| type_qualifier_list ptrref_operator type_specifier
 		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| ptrref_operator new_abstract_function
+	| ptrref_operator cfa_abstract_function
 		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list ptrref_operator new_abstract_function
+	| type_qualifier_list ptrref_operator cfa_abstract_function
 		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| ptrref_operator new_identifier_parameter_declarator_tuple
+	| ptrref_operator cfa_identifier_parameter_declarator_tuple
 		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list ptrref_operator new_identifier_parameter_declarator_tuple
+	| type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
 		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
 	;
 
-new_identifier_parameter_array:							// CFA
+cfa_identifier_parameter_array:							// CFA
 		// Only the first dimension can be empty or have qualifiers. Empty dimension must be factored out due to
 		// shift/reduce conflict with new-style empty (void) function return type.
 	'[' ']' type_specifier
 		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension type_specifier
+	| cfa_array_parameter_1st_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
 	| '[' ']' multi_array_dimension type_specifier
 		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension multi_array_dimension type_specifier
+	| cfa_array_parameter_1st_dimension multi_array_dimension type_specifier
 		{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
 	| multi_array_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
 
-	| '[' ']' new_identifier_parameter_ptr
+	| '[' ']' cfa_identifier_parameter_ptr
 		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension new_identifier_parameter_ptr
+	| cfa_array_parameter_1st_dimension cfa_identifier_parameter_ptr
 		{ $$ = $2->addNewArray( $1 ); }
-	| '[' ']' multi_array_dimension new_identifier_parameter_ptr
+	| '[' ']' multi_array_dimension cfa_identifier_parameter_ptr
 		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr
+	| cfa_array_parameter_1st_dimension multi_array_dimension cfa_identifier_parameter_ptr
 		{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
-	| multi_array_dimension new_identifier_parameter_ptr
+	| multi_array_dimension cfa_identifier_parameter_ptr
 		{ $$ = $2->addNewArray( $1 ); }
 	;
 
-new_array_parameter_1st_dimension:
+cfa_array_parameter_1st_dimension:
 	'[' push type_qualifier_list '*' pop ']'			// remaining C99
 		{ $$ = DeclarationNode::newVarArray( $3 ); }
@@ -2798,6 +2857,6 @@
 // These rules need LR(3):
 //
-//		new_abstract_tuple identifier_or_type_name
-//		'[' new_parameter_list ']' identifier_or_type_name '(' new_parameter_type_list_opt ')'
+//		cfa_abstract_tuple identifier_or_type_name
+//		'[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
 //
 // since a function return type can be syntactically identical to a tuple type:
@@ -2807,36 +2866,36 @@
 //
 // Therefore, it is necessary to look at the token after identifier_or_type_name to know when to reduce
-// new_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the necessary
-// lookahead. To accomplish this, new_abstract_declarator has an entry point without tuple, and tuple declarations are
-// duplicated when appearing with new_function_specifier.
-
-new_abstract_declarator_tuple:							// CFA
-	new_abstract_tuple
-	| type_qualifier_list new_abstract_tuple
+// cfa_abstract_tuple. To make this LR(1), several rules have to be flattened (lengthened) to allow the necessary
+// lookahead. To accomplish this, cfa_abstract_declarator has an entry point without tuple, and tuple declarations are
+// duplicated when appearing with cfa_function_specifier.
+
+cfa_abstract_declarator_tuple:							// CFA
+	cfa_abstract_tuple
+	| type_qualifier_list cfa_abstract_tuple
 		{ $$ = $2->addQualifiers( $1 ); }
-	| new_abstract_declarator_no_tuple
-	;
-
-new_abstract_declarator_no_tuple:						// CFA
-	new_abstract_ptr
-	| new_abstract_array
-	;
-
-new_abstract_ptr:										// CFA
+	| cfa_abstract_declarator_no_tuple
+	;
+
+cfa_abstract_declarator_no_tuple:						// CFA
+	cfa_abstract_ptr
+	| cfa_abstract_array
+	;
+
+cfa_abstract_ptr:										// CFA
 	ptrref_operator type_specifier
 		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
 	| type_qualifier_list ptrref_operator type_specifier
 		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| ptrref_operator new_abstract_function
+	| ptrref_operator cfa_abstract_function
 		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list ptrref_operator new_abstract_function
+	| type_qualifier_list ptrref_operator cfa_abstract_function
 		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
-	| ptrref_operator new_abstract_declarator_tuple
+	| ptrref_operator cfa_abstract_declarator_tuple
 		{ $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-	| type_qualifier_list ptrref_operator new_abstract_declarator_tuple
+	| type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
 		{ $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
 	;
 
-new_abstract_array:										// CFA
+cfa_abstract_array:										// CFA
 		// Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce conflict with
 		// empty (void) function return type.
@@ -2847,23 +2906,23 @@
 	| multi_array_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
-	| '[' ']' new_abstract_ptr
+	| '[' ']' cfa_abstract_ptr
 		{ $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
-	| '[' ']' multi_array_dimension new_abstract_ptr
+	| '[' ']' multi_array_dimension cfa_abstract_ptr
 		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
-	| multi_array_dimension new_abstract_ptr
+	| multi_array_dimension cfa_abstract_ptr
 		{ $$ = $2->addNewArray( $1 ); }
 	;
 
-new_abstract_tuple:										// CFA
-	'[' push new_abstract_parameter_list pop ']'
+cfa_abstract_tuple:										// CFA
+	'[' push cfa_abstract_parameter_list pop ']'
 		{ $$ = DeclarationNode::newTuple( $3 ); }
 	;
 
-new_abstract_function:									// CFA
-//	'[' ']' '(' new_parameter_type_list_opt ')'
+cfa_abstract_function:									// CFA
+//	'[' ']' '(' cfa_parameter_type_list_opt ')'
 //		{ $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
-	new_abstract_tuple '(' push new_parameter_type_list_opt pop ')'
+	cfa_abstract_tuple '(' push cfa_parameter_type_list_opt pop ')'
 		{ $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
-	| new_function_return '(' push new_parameter_type_list_opt pop ')'
+	| cfa_function_return '(' push cfa_parameter_type_list_opt pop ')'
 		{ $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
 	;
