Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 721f17ac6221a75230b4b1228917e6a163b53ff6)
+++ src/Parser/parser.yy	(revision 413f7f8f954fd5b76e69f982ec43ab944badd864)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 25 22:36:33 2015
-// Update Count     : 1120
+// Last Modified On : Fri Jul  3 13:53:45 2015
+// Update Count     : 1220
 // 
 
@@ -118,5 +118,5 @@
 
 %type<tok> zero_one  identifier  no_attr_identifier  no_01_identifier
-%type<tok> identifier_or_typedef_name  no_attr_identifier_or_typedef_name  no_01_identifier_or_typedef_name
+%type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  no_01_identifier_or_type_name
 %type<constant> string_literal_list
 
@@ -204,5 +204,5 @@
 %type<decl> parameter_type_list_opt
 
-%type<decl> paren_identifier paren_typedef
+%type<decl> paren_identifier paren_type
 
 %type<decl> storage_class storage_class_name storage_class_list
@@ -213,8 +213,8 @@
 %type<decl> type_declarator type_declarator_name type_declaring_list
 
-%type<decl> typedef typedef_array typedef_declaration typedef_declaration_specifier typedef_expression
-%type<decl> typedef_function typedef_parameter_array typedef_parameter_function typedef_parameter_ptr
-%type<decl> typedef_parameter_redeclarator typedef_ptr typedef_redeclarator typedef_type_specifier
-%type<decl> typegen_declaration_specifier typegen_type_specifier
+%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 type_redeclarator typedef_type_specifier
+%type<decl> typegen_declaration_specifier typegen_type_specifier typegen_name
 
 %type<decl> type_name type_name_no_function
@@ -376,5 +376,5 @@
 	| no_attr_identifier ':' assignment_expression
 		{ $$ = $3->set_asArgName( $1 ); }
-		// Only a list of no_attr_identifier_or_typedef_name is allowed in this context. However, there is insufficient
+		// Only a list of no_attr_identifier_or_type_name is allowed in this context. However, there is insufficient
 		// look ahead to distinguish between this list of parameter names and a tuple, so the tuple form must be used
 		// with an appropriate semantic check.
@@ -564,5 +564,5 @@
 		// 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
-	'[' push pop ']'
+	'[' ']'
 		{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
 	| '[' push assignment_expression pop ']'
@@ -924,6 +924,6 @@
 
 label_list:												// GCC, local label
-	no_attr_identifier_or_typedef_name			{}
-	| label_list ',' no_attr_identifier_or_typedef_name {}
+	no_attr_identifier_or_type_name			{}
+	| label_list ',' no_attr_identifier_or_type_name {}
 	;
 
@@ -965,5 +965,5 @@
 			$$ = $2->addQualifiers( $1 );
 		}
-	| new_variable_declaration pop ',' push identifier_or_typedef_name initializer_opt
+	| new_variable_declaration pop ',' push identifier_or_type_name initializer_opt
 		{
 			typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
@@ -975,15 +975,15 @@
 		// 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_typedef_name asm_name_opt
+	new_abstract_declarator_no_tuple identifier_or_type_name asm_name_opt
 		{
 			typedefTable.setNextIdentifier( *$2 );
 			$$ = $1->addName( $2 );
 		}
-	| new_abstract_tuple identifier_or_typedef_name asm_name_opt
+	| new_abstract_tuple identifier_or_type_name asm_name_opt
 		{
 			typedefTable.setNextIdentifier( *$2 );
 			$$ = $1->addName( $2 );
 		}
-	| type_qualifier_list new_abstract_tuple identifier_or_typedef_name asm_name_opt
+	| type_qualifier_list new_abstract_tuple identifier_or_type_name asm_name_opt
 		{
 			typedefTable.setNextIdentifier( *$3 );
@@ -1013,5 +1013,5 @@
 			$$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
 		}
-	| new_function_declaration pop ',' push identifier_or_typedef_name
+	| new_function_declaration pop ',' push identifier_or_type_name
 		{
 			typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
@@ -1021,27 +1021,32 @@
 
 new_function_specifier:									// CFA
-	'[' push pop ']' identifier '(' push new_parameter_type_list_opt pop ')'
-		{
-			typedefTable.setNextIdentifier( *( $5 ) );
-			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
-		}
-	| '[' push pop ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')'
-		{
-			typedefTable.setNextIdentifier( *( $5 ) );
-			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
-		}
-		// identifier_or_typedef_name must be broken apart because of the sequence:
+	'[' ']' identifier_or_type_name '(' push new_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 ')'
+//		{
+//			typedefTable.setNextIdentifier( *$5 );
+//			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+//		}
+//	| '[' ']' TYPEDEFname '(' push new_parameter_type_list_opt pop ')'
+//		{
+//			typedefTable.setNextIdentifier( *$5 );
+//			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
+//		}
+//	| '[' ']' typegen_name
+		// identifier_or_type_name must be broken apart because of the sequence:
 		//
-		//   '[' ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
+		//   '[' ']' identifier_or_type_name '(' new_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_typedef_name.
-	| new_abstract_tuple identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
+		// 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).
 		{
 			$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
 		}
-	| new_function_return identifier_or_typedef_name '(' push new_parameter_type_list_opt pop ')'
+	| new_function_return identifier_or_type_name '(' push new_parameter_type_list_opt pop ')'
 		{
 			$$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
@@ -1357,22 +1362,12 @@
 	aggregate_key '{' field_declaration_list '}'
 		{ $$ = DeclarationNode::newAggregate( $1, 0, 0, $3 ); }
-	| aggregate_key no_attr_identifier_or_typedef_name
+	| aggregate_key no_attr_identifier_or_type_name
 	 	{ $$ = DeclarationNode::newAggregate( $1, $2, 0, 0 ); }
-	| aggregate_key no_attr_identifier_or_typedef_name '{' field_declaration_list '}'
+	| aggregate_key no_attr_identifier_or_type_name '{' field_declaration_list '}'
 	 	{ $$ = DeclarationNode::newAggregate( $1, $2, 0, $4 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, 0, $4, 0, $8 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, 0 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, $7, $4, 0, $9 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, 0, $4, $8, $11 ); }
 	| aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA
 	 	{ $$ = DeclarationNode::newAggregate( $1, 0, $3, $6 ); }
-	| aggregate_key '(' type_name_list ')' no_attr_identifier_or_typedef_name // CFA
-	 	{ $$ = DeclarationNode::newAggregate( $1, $5, $3, 0 ); }
-	// | aggregate_key '(' push type_parameter_list pop ')' '(' type_name_list ')' no_attr_identifier_or_typedef_name '{' field_declaration_list '}' // CFA
-	// 	{ $$ = DeclarationNode::newAggregate( $1, $10, $4, $8, $12 ); }
+	| aggregate_key typegen_name						// CFA, S/R conflict
+		{ $$ = $2; }
 	;
 
@@ -1402,7 +1397,7 @@
 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_typedef_name
+	| new_abstract_declarator_tuple no_attr_identifier_or_type_name
 		{ $$ = $1->addName( $2 ); }
-	| new_field_declaring_list ',' no_attr_identifier_or_typedef_name
+	| new_field_declaring_list ',' no_attr_identifier_or_type_name
 		{ $$ = $1->appendList( $1->cloneType( $3 ) ); }
 	| new_field_declaring_list ','						// CFA, no field name
@@ -1425,5 +1420,5 @@
 		// A semantic check is required to ensure bit_subrange only appears on base type int.
 		{ $$ = $1->addBitfield( $2 ); }
-	| typedef_redeclarator bit_subrange_size_opt
+	| type_redeclarator bit_subrange_size_opt
 		// A semantic check is required to ensure bit_subrange only appears on base type int.
 		{ $$ = $1->addBitfield( $2 ); }
@@ -1450,14 +1445,14 @@
 	enum_key '{' enumerator_list comma_opt '}'
 		{ $$ = DeclarationNode::newEnum( 0, $3 ); }
-	| enum_key no_attr_identifier_or_typedef_name '{' enumerator_list comma_opt '}'
+	| enum_key no_attr_identifier_or_type_name '{' enumerator_list comma_opt '}'
 		{ $$ = DeclarationNode::newEnum( $2, $4 ); }
-	| enum_key no_attr_identifier_or_typedef_name
+	| enum_key no_attr_identifier_or_type_name
 		{ $$ = DeclarationNode::newEnum( $2, 0 ); }
 	;
 
 enumerator_list:
-	no_attr_identifier_or_typedef_name enumerator_value_opt
+	no_attr_identifier_or_type_name enumerator_value_opt
 		{ $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
-	| enumerator_list ',' no_attr_identifier_or_typedef_name enumerator_value_opt
+	| enumerator_list ',' no_attr_identifier_or_type_name enumerator_value_opt
 		{ $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
 	;
@@ -1529,14 +1524,14 @@
 
 // Provides optional identifier names (abstract_declarator/variable_declarator), no initialization, different semantics
-// for typedef name by using typedef_parameter_redeclarator instead of typedef_redeclarator, and function prototypes.
+// for typedef name by using type_parameter_redeclarator instead of typedef_redeclarator, and function prototypes.
 
 new_parameter_declaration:								// CFA, new & old style parameter declaration
 	parameter_declaration
-	| new_identifier_parameter_declarator_no_tuple identifier_or_typedef_name assignment_opt
+	| new_identifier_parameter_declarator_no_tuple identifier_or_type_name assignment_opt
 		{ $$ = $1->addName( $2 ); }
-	| new_abstract_tuple identifier_or_typedef_name assignment_opt
+	| new_abstract_tuple identifier_or_type_name assignment_opt
 		// To obtain LR(1), these rules must be duplicated here (see new_abstract_declarator).
 		{ $$ = $1->addName( $2 ); }
-	| type_qualifier_list new_abstract_tuple identifier_or_typedef_name assignment_opt
+	| type_qualifier_list new_abstract_tuple identifier_or_type_name assignment_opt
 		{ $$ = $2->addName( $3 )->addQualifiers( $1 ); }
 	| new_function_specifier
@@ -1559,5 +1554,5 @@
 			$$ = $2->addType( $1 )->addInitializer( new InitializerNode( $3 ) );
 		}
-	| declaration_specifier typedef_parameter_redeclarator assignment_opt
+	| declaration_specifier type_parameter_redeclarator assignment_opt
 		{
 			typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -1583,5 +1578,5 @@
 	;
 
-identifier_or_typedef_name:
+identifier_or_type_name:
 	identifier
 	| TYPEDEFname
@@ -1589,5 +1584,5 @@
 	;
 
-no_01_identifier_or_typedef_name:
+no_01_identifier_or_type_name:
 	no_01_identifier
 	| TYPEDEFname
@@ -1595,5 +1590,5 @@
 	;
 
-no_attr_identifier_or_typedef_name:
+no_attr_identifier_or_type_name:
 	no_attr_identifier
 	| TYPEDEFname
@@ -1619,5 +1614,6 @@
 	// empty
 		{ $$ = 0; }
-	| '=' initializer							{ $$ = $2; }
+	| '=' initializer
+		{ $$ = $2; }
 	;
 
@@ -1647,16 +1643,17 @@
 designation:
 	designator_list ':'									// C99, CFA uses ":" instead of "="
-	| no_attr_identifier_or_typedef_name ':'			// GCC, field name
-				{ $$ = new VarRefNode( $1 ); }
+	| no_attr_identifier_or_type_name ':'				// GCC, field name
+		{ $$ = new VarRefNode( $1 ); }
 	;
 
 designator_list:										// C99
 	designator
-	| designator_list designator					{ $$ = (ExpressionNode *)( $1->set_link( $2 )); }
+	| designator_list designator
+		{ $$ = (ExpressionNode *)( $1->set_link( $2 )); }
 	//| designator_list designator						{ $$ = new CompositeExprNode( $1, $2 ); }
 	;
 
 designator:
-	'.' no_attr_identifier_or_typedef_name				// C99, field name
+	'.' no_attr_identifier_or_type_name					// C99, field name
 		{ $$ = new VarRefNode( $2 ); }
 	| '[' push assignment_expression pop ']'			// C99, single array element
@@ -1700,10 +1697,14 @@
 
 typegen_type_specifier:									// CFA
+	typegen_name
+	| type_qualifier_list typegen_name
+		{ $$ = $2->addQualifiers( $1 ); }
+	| typegen_type_specifier type_qualifier
+		{ $$ = $1->addQualifiers( $2 ); }
+	;
+
+typegen_name:											// CFA
 	TYPEGENname '(' type_name_list ')'
 		{ $$ = DeclarationNode::newFromTypeGen( $1, $3 ); }
-	| type_qualifier_list TYPEGENname '(' type_name_list ')'
-		{ $$ = DeclarationNode::newFromTypeGen( $2, $4 )->addQualifiers( $1 ); }
-	| typegen_type_specifier type_qualifier
-		{ $$ = $1->addQualifiers( $2 ); }
 	;
 
@@ -1715,6 +1716,6 @@
 
 type_parameter:											// CFA
-	type_class no_attr_identifier_or_typedef_name
-		{ typedefTable.addToEnclosingScope(*( $2 ), TypedefTable::TD ); }
+	type_class no_attr_identifier_or_type_name
+		{ typedefTable.addToEnclosingScope( *$2, TypedefTable::TD ); }
 	  assertion_list_opt
 		{ $$ = DeclarationNode::newTypeParam( $1, $2 )->addAssertions( $4 ); }
@@ -1739,7 +1740,7 @@
 
 assertion:												// CFA
-	'|' no_attr_identifier_or_typedef_name '(' type_name_list ')'
-		{
-			typedefTable.openContext( *( $2 ) );
+	'|' no_attr_identifier_or_type_name '(' type_name_list ')'
+		{
+			typedefTable.openContext( *$2 );
 			$$ = DeclarationNode::newContextUse( $2, $4 );
 		}
@@ -1777,10 +1778,10 @@
 
 type_declarator_name:									// CFA
-	no_attr_identifier_or_typedef_name
+	no_attr_identifier_or_type_name
 		{
 			typedefTable.addToEnclosingScope( *$1, TypedefTable::TD );
 			$$ = DeclarationNode::newTypeDecl( $1, 0 );
 		}
-	| no_01_identifier_or_typedef_name '(' push type_parameter_list pop ')'
+	| no_01_identifier_or_type_name '(' push type_parameter_list pop ')'
 		{
 			typedefTable.addToEnclosingScope( *$1, TypedefTable::TG );
@@ -1790,10 +1791,10 @@
 
 context_specifier:										// CFA
-	CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{' '}'
+	CONTEXT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}'
 		{
 			typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
 			$$ = DeclarationNode::newContext( $2, $5, 0 );
 		}
-	| CONTEXT no_attr_identifier_or_typedef_name '(' push type_parameter_list pop ')' '{'
+	| CONTEXT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{'
 		{
 			typedefTable.enterContext( *$2 );
@@ -1830,5 +1831,5 @@
 			$$ = $1;
 		}
-	| new_context_declaring_list pop ',' push identifier_or_typedef_name
+	| new_context_declaring_list pop ',' push identifier_or_type_name
 		{
 			typedefTable.addToEnclosingScope2( *$5, TypedefTable::ID );
@@ -1899,5 +1900,4 @@
 external_function_definition:
 	function_definition
-
 		// These rules are a concession to the "implicit int" type_specifier because there is a significant amount of
 		// code with functions missing a type-specifier on the return type.  Parsing is possible because
@@ -1982,5 +1982,5 @@
 	variable_declarator
 	| function_declarator
-	| typedef_redeclarator
+	| type_redeclarator
 	;
 
@@ -2021,5 +2021,5 @@
 
 any_word:												// GCC
-	identifier_or_typedef_name {}
+	identifier_or_type_name {}
 	| storage_class_name {}
 	| basic_type_name {}
@@ -2103,5 +2103,5 @@
 // This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot be nested,
 // there is no context where a function definition can redefine a typedef name. To allow nested functions requires
-// further separation of variable and function declarators in typedef_redeclarator.  The pattern precludes returning
+// further separation of variable and function declarators in type_redeclarator.  The pattern precludes returning
 // arrays and functions versus pointers to arrays and functions.
 
@@ -2176,5 +2176,5 @@
 	;
 
-// This pattern parses a declaration for a variable or function prototype that redefines a typedef name, e.g.:
+// This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
 //
 //		typedef int foo;
@@ -2186,47 +2186,43 @@
 // and functions versus pointers to arrays and functions.
 
-typedef_redeclarator:
-	paren_typedef attribute_list_opt
-	| typedef_ptr
-	| typedef_array attribute_list_opt
-	| typedef_function attribute_list_opt
-	;
-
-paren_typedef:
-	TYPEDEFname
-		{
-			typedefTable.setNextIdentifier( *( $1 ) );
-			$$ = DeclarationNode::newName( $1 );
-		}
-	| '(' paren_typedef ')'
-		{ $$ = $2; }
-	;
-
-typedef_ptr:
-	'*' typedef_redeclarator
+type_redeclarator:
+	paren_type attribute_list_opt
+	| type_ptr
+	| type_array attribute_list_opt
+	| type_function attribute_list_opt
+	;
+
+paren_type:
+	typedef
+	| '(' paren_type ')'
+		{ $$ = $2; }
+	;
+
+type_ptr:
+	'*' type_redeclarator
 		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list typedef_redeclarator
+	| '*' type_qualifier_list type_redeclarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' typedef_ptr ')'
-		{ $$ = $2; }
-	;
-
-typedef_array:
-	paren_typedef array_dimension
+	| '(' type_ptr ')'
+		{ $$ = $2; }
+	;
+
+type_array:
+	paren_type array_dimension
 		{ $$ = $1->addArray( $2 ); }
-	| '(' typedef_ptr ')' array_dimension
+	| '(' type_ptr ')' array_dimension
 		{ $$ = $2->addArray( $4 ); }
-	| '(' typedef_array ')' multi_array_dimension		// redundant parenthesis
+	| '(' type_array ')' multi_array_dimension			// redundant parenthesis
 		{ $$ = $2->addArray( $4 ); }
-	| '(' typedef_array ')'								// redundant parenthesis
-		{ $$ = $2; }
-	;
-
-typedef_function:
-	paren_typedef '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+	| '(' type_array ')'								// redundant parenthesis
+		{ $$ = $2; }
+	;
+
+type_function:
+	paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $1->addParamList( $4 ); }
-	| '(' typedef_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+	| '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $2->addParamList( $6 ); }
-	| '(' typedef_function ')'							// redundant parenthesis
+	| '(' type_function ')'								// redundant parenthesis
 		{ $$ = $2; }
 	;
@@ -2299,9 +2295,9 @@
 // functions.
 
-typedef_parameter_redeclarator:
+type_parameter_redeclarator:
 	typedef attribute_list_opt
-	| typedef_parameter_ptr
-	| typedef_parameter_array attribute_list_opt
-	| typedef_parameter_function attribute_list_opt
+	| type_parameter_ptr
+	| type_parameter_array attribute_list_opt
+	| type_parameter_function attribute_list_opt
 	;
 
@@ -2312,26 +2308,31 @@
 			$$ = DeclarationNode::newName( $1 );
 		}
-	;
-
-typedef_parameter_ptr:
-	'*' typedef_parameter_redeclarator
+	| TYPEGENname
+		{
+			typedefTable.setNextIdentifier( *$1 );
+			$$ = DeclarationNode::newName( $1 );
+		}
+	;
+
+type_parameter_ptr:
+	'*' type_parameter_redeclarator
 		{ $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-	| '*' type_qualifier_list typedef_parameter_redeclarator
+	| '*' type_qualifier_list type_parameter_redeclarator
 		{ $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
-	| '(' typedef_parameter_ptr ')'
-		{ $$ = $2; }
-	;
-
-typedef_parameter_array:
+	| '(' type_parameter_ptr ')'
+		{ $$ = $2; }
+	;
+
+type_parameter_array:
 	typedef array_parameter_dimension
 		{ $$ = $1->addArray( $2 ); }
-	| '(' typedef_parameter_ptr ')' array_parameter_dimension
+	| '(' type_parameter_ptr ')' array_parameter_dimension
 		{ $$ = $2->addArray( $4 ); }
 	;
 
-typedef_parameter_function:
+type_parameter_function:
 	typedef '(' push parameter_type_list_opt pop ')'	// empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $1->addParamList( $4 ); }
-	| '(' typedef_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+	| '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $2->addParamList( $6 ); }
 	;
@@ -2386,8 +2387,8 @@
 array_dimension:
 		// Only the first dimension can be empty.
-	'[' push pop ']'
+	'[' ']'
 		{ $$ = DeclarationNode::newArray( 0, 0, false ); }
-	| '[' push pop ']' multi_array_dimension
-		{ $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $5 ); }
+	| '[' ']' multi_array_dimension
+		{ $$ = DeclarationNode::newArray( 0, 0, false )->addArray( $3 ); }
 	| multi_array_dimension
 	;
@@ -2465,5 +2466,5 @@
 
 array_parameter_1st_dimension:
-	'[' push pop ']'
+	'[' ']'
 		{ $$ = DeclarationNode::newArray( 0, 0, false ); }
 	// multi_array_dimension handles the '[' '*' ']' case
@@ -2558,20 +2559,20 @@
 		// 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.
-	'[' push pop ']' type_specifier
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	'[' ']' type_specifier
+		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
 	| new_array_parameter_1st_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' multi_array_dimension type_specifier
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	| '[' ']' multi_array_dimension type_specifier
+		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
 	| new_array_parameter_1st_dimension multi_array_dimension type_specifier
 		{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
 	| multi_array_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' new_identifier_parameter_ptr
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	| '[' ']' new_identifier_parameter_ptr
+		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
 	| new_array_parameter_1st_dimension new_identifier_parameter_ptr
 		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' multi_array_dimension new_identifier_parameter_ptr
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	| '[' ']' multi_array_dimension new_identifier_parameter_ptr
+		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
 	| new_array_parameter_1st_dimension multi_array_dimension new_identifier_parameter_ptr
 		{ $$ = $3->addNewArray( $2 )->addNewArray( $1 ); }
@@ -2602,6 +2603,6 @@
 // These rules need LR(3):
 //
-//		new_abstract_tuple identifier_or_typedef_name
-//		'[' new_parameter_list ']' identifier_or_typedef_name '(' new_parameter_type_list_opt ')'
+//		new_abstract_tuple identifier_or_type_name
+//		'[' new_parameter_list ']' identifier_or_type_name '(' new_parameter_type_list_opt ')'
 //
 // since a function return type can be syntactically identical to a tuple type:
@@ -2610,5 +2611,5 @@
 //		[int, int] f( int );
 //
-// Therefore, it is necessary to look at the token after identifier_or_typedef_name to know when to reduce
+// 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
@@ -2645,14 +2646,14 @@
 		// Only the first dimension can be empty. Empty dimension must be factored out due to shift/reduce conflict with
 		// empty (void) function return type.
-	'[' push pop ']' type_specifier
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| '[' push pop ']' multi_array_dimension type_specifier
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	'[' ']' type_specifier
+		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	| '[' ']' multi_array_dimension type_specifier
+		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
 	| multi_array_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
-	| '[' push pop ']' new_abstract_ptr
-		{ $$ = $5->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-	| '[' push pop ']' multi_array_dimension new_abstract_ptr
-		{ $$ = $6->addNewArray( $5 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	| '[' ']' new_abstract_ptr
+		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+	| '[' ']' multi_array_dimension new_abstract_ptr
+		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
 	| multi_array_dimension new_abstract_ptr
 		{ $$ = $2->addNewArray( $1 ); }
@@ -2665,6 +2666,6 @@
 
 new_abstract_function:									// CFA
-	'[' push pop ']' '(' new_parameter_type_list_opt ')'
-		{ $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $6, 0 ); }
+	'[' ']' '(' new_parameter_type_list_opt ')'
+		{ $$ = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), $4, 0 ); }
 	| new_abstract_tuple '(' push new_parameter_type_list_opt pop ')'
 		{ $$ = DeclarationNode::newFunction( 0, $1, $4, 0 ); }
