Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 3ed994eca620a695aa523cf50b22b75c6761327d)
+++ src/Parser/parser.yy	(revision 054514d366b6a7a6863d673a9c760baa03661f21)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 22 08:41:57 2018
-// Update Count     : 3353
+// Last Modified On : Mon May 28 17:01:36 2018
+// Update Count     : 3383
 //
 
@@ -326,5 +326,5 @@
 %type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
 
-%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt
+%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_ellipsis_list_opt
 
 %type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
@@ -852,10 +852,10 @@
 //	'[' ']'
 //		{ $$ = new ExpressionNode( build_tuple() ); }
-//	'[' push assignment_expression pop ']'
+//	| '[' push assignment_expression pop ']'
 //		{ $$ = new ExpressionNode( build_tuple( $3 ) ); }
-	'[' ',' tuple_expression_list ']'
-		{ $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
-	| '[' assignment_expression ',' tuple_expression_list ']'
-		{ $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$2->set_last( $4 ) ) ); }
+	'[' push ',' tuple_expression_list pop ']'
+		{ $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $4 ) ) ); }
+	| '[' push assignment_expression ',' tuple_expression_list pop ']'
+		{ $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $5 ) ) ); }
 	;
 
@@ -883,5 +883,5 @@
 	labeled_statement
 	| compound_statement
-	| expression_statement						{ $$ = $1; }
+	| expression_statement
 	| selection_statement
 	| iteration_statement
@@ -1200,13 +1200,9 @@
 	type_specifier_nobody
 	| type_specifier_nobody declarator
-		{
-			$$ = $2->addType( $1 );
-		}
+		{ $$ = $2->addType( $1 ); }
 	| type_specifier_nobody variable_abstract_declarator
 		{ $$ = $2->addType( $1 ); }
 	| cfa_abstract_declarator_tuple no_attr_identifier	// CFA
-		{
-			$$ = $1->addName( $2 );
-		}
+		{ $$ = $1->addName( $2 ); }
 	| cfa_abstract_declarator_tuple						// CFA
 	;
@@ -1286,5 +1282,5 @@
 
 declaration_list_opt:									// used at beginning of switch statement
-	pop
+	pop	// empty
 		{ $$ = nullptr; }
 	| declaration_list
@@ -1321,6 +1317,6 @@
 
 local_label_list:										// GCC, local label
-	no_attr_identifier_or_type_name				{}
-	| local_label_list ',' no_attr_identifier_or_type_name {}
+	no_attr_identifier_or_type_name
+	| local_label_list ',' no_attr_identifier_or_type_name
 	;
 
@@ -1385,24 +1381,24 @@
 	| declaration_qualifier_list type_qualifier_list cfa_function_specifier
 		{ $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); }
-	| cfa_function_declaration ',' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+	| cfa_function_declaration ',' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
 		{
 			// Append the return type at the start (left-hand-side) to each identifier in the list.
 			DeclarationNode * ret = new DeclarationNode;
 			ret->type = maybeClone( $1->type->base );
-			$$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $5, nullptr ) );
+			$$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $6, nullptr ) );
 		}
 	;
 
 cfa_function_specifier:									// CFA
-//	'[' ']' identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')' // S/R conflict
+//	'[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
 //		{
 //			$$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
 //		}
-//	'[' ']' identifier '(' push cfa_parameter_type_list_opt pop ')'
+//	'[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //		{
 //			typedefTable.setNextIdentifier( *$5 );
 //			$$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
 //		}
-//	| '[' ']' TYPEDEFname '(' push cfa_parameter_type_list_opt pop ')'
+//	| '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //		{
 //			typedefTable.setNextIdentifier( *$5 );
@@ -1412,23 +1408,22 @@
 		// identifier_or_type_name must be broken apart because of the sequence:
 		//
-		//   '[' ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+		//   '[' ']' identifier_or_type_name '(' cfa_parameter_ellipsis_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.
-	cfa_abstract_tuple identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+	cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_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, $4, 0 ); }
-	| cfa_function_return identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
-		{ $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); }
+		{ $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
+	| cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
+		{ $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
 	;
 
 cfa_function_return:									// CFA
-	'[' cfa_parameter_list ']'
-		{ $$ = DeclarationNode::newTuple( $2 ); }
-	| '[' cfa_parameter_list ',' cfa_abstract_parameter_list ']'
-		// To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the
-		// ']'.
-		{ $$ = DeclarationNode::newTuple( $2->appendList( $4 ) ); }
+	'[' push cfa_parameter_list pop ']'
+		{ $$ = DeclarationNode::newTuple( $3 ); }
+	| '[' 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 ) ); }
 	;
 
@@ -1604,13 +1599,6 @@
 
 forall:
-	FORALL '('
-		{
-			typedefTable.enterScope();
-		}
-	  type_parameter_list ')'							// CFA
-		{
-			typedefTable.leaveScope();
-			$$ = DeclarationNode::newForall( $4 );
-		}
+	FORALL '(' push type_parameter_list pop ')'					// CFA
+		{ $$ = DeclarationNode::newForall( $4 ); }
 	;
 
@@ -1980,5 +1968,5 @@
 	;
 
-cfa_parameter_type_list_opt:							// CFA, abstract + real
+cfa_parameter_ellipsis_list_opt:							// CFA, abstract + real
 	// empty
 		{ $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
@@ -1987,9 +1975,9 @@
 	| cfa_abstract_parameter_list
 	| cfa_parameter_list
-	| cfa_parameter_list ',' cfa_abstract_parameter_list
-		{ $$ = $1->appendList( $3 ); }
-	| cfa_abstract_parameter_list ',' ELLIPSIS
+	| cfa_parameter_list pop ',' push cfa_abstract_parameter_list
+		{ $$ = $1->appendList( $5 ); }
+	| cfa_abstract_parameter_list pop ',' push ELLIPSIS
 		{ $$ = $1->addVarArgs(); }
-	| cfa_parameter_list ',' ELLIPSIS
+	| cfa_parameter_list pop ',' push ELLIPSIS
 		{ $$ = $1->addVarArgs(); }
 	;
@@ -1999,16 +1987,16 @@
 		// factored out from cfa_parameter_list, flattening the rules to get lookahead to the ']'.
 	cfa_parameter_declaration
-	| cfa_abstract_parameter_list ',' cfa_parameter_declaration
-		{ $$ = $1->appendList( $3 ); }
-	| cfa_parameter_list ',' cfa_parameter_declaration
-		{ $$ = $1->appendList( $3 ); }
-	| cfa_parameter_list ',' cfa_abstract_parameter_list ',' cfa_parameter_declaration
-		{ $$ = $1->appendList( $3 )->appendList( $5 ); }
+	| cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
+		{ $$ = $1->appendList( $5 ); }
+	| cfa_parameter_list pop ',' push cfa_parameter_declaration
+		{ $$ = $1->appendList( $5 ); }
+	| cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
+		{ $$ = $1->appendList( $5 )->appendList( $9 ); }
 	;
 
 cfa_abstract_parameter_list:							// CFA, new & old style abstract
 	cfa_abstract_parameter_declaration
-	| cfa_abstract_parameter_list ',' cfa_abstract_parameter_declaration
-		{ $$ = $1->appendList( $3 ); }
+	| cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration
+		{ $$ = $1->appendList( $5 ); }
 	;
 
@@ -2159,13 +2147,13 @@
 	'.' no_attr_identifier								// C99, field name
 		{ $$ = new ExpressionNode( build_varref( $2 ) ); }
-	| '[' assignment_expression ']'						// C99, single array element
+	| '[' push assignment_expression pop ']'			// C99, single array element
 		// assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
-		{ $$ = $2; }
-	| '[' subrange ']'									// CFA, multiple array elements
-		{ $$ = $2; }
-	| '[' constant_expression ELLIPSIS constant_expression ']' // GCC, multiple array elements
-		{ $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $2 ), maybeMoveBuild< Expression >( $4 ) ) ); }
-	| '.' '[' field_list ']'							// CFA, tuple field selector
 		{ $$ = $3; }
+	| '[' push subrange pop ']'							// CFA, multiple array elements
+		{ $$ = $3; }
+	| '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
+		{ $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); }
+	| '.' '[' push field_list pop ']'					// CFA, tuple field selector
+		{ $$ = $4; }
 	;
 
@@ -2238,7 +2226,7 @@
 	'|' no_attr_identifier_or_type_name '(' type_list ')'
 		{ $$ = DeclarationNode::newTraitUse( $2, $4 ); }
-	| '|' '{' push trait_declaration_list '}'
+	| '|' '{' push trait_declaration_list pop '}'
 		{ $$ = $4; }
-	| '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
+	| '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}' '(' type_list ')'
 		{ SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
 	;
@@ -2286,7 +2274,5 @@
 	TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}'
 		{ $$ = DeclarationNode::newTrait( $2, $5, 0 ); }
-	| TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{'
-		{ typedefTable.enterScope(); }
-	  trait_declaration_list '}'
+	| TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}'
 		{ $$ = DeclarationNode::newTrait( $2, $5, $10 ); }
 	;
@@ -2294,18 +2280,16 @@
 trait_declaration_list:									// CFA
 	trait_declaration
-	| trait_declaration_list push trait_declaration
-		{ $$ = $1->appendList( $3 ); }
+	| trait_declaration_list pop push trait_declaration
+		{ $$ = $1->appendList( $4 ); }
 	;
 
 trait_declaration:										// CFA
-	cfa_trait_declaring_list pop ';'
-	| trait_declaring_list pop ';'
+	cfa_trait_declaring_list ';'
+	| trait_declaring_list ';'
 	;
 
 cfa_trait_declaring_list:								// CFA
 	cfa_variable_specifier
-		{ $$ = $1; }
 	| cfa_function_specifier
-		{ $$ = $1; }
 	| cfa_trait_declaring_list pop ',' push identifier_or_type_name
 		{ $$ = $1->appendList( $1->cloneType( $5 ) ); }
@@ -2366,7 +2350,5 @@
 		}
 	| type_qualifier_list
-		{
-			if ( $1->type->forall ) xxx = forall = true; // remember generic type
-		}
+		{ if ( $1->type->forall ) xxx = forall = true; } // remember generic type
 	  push '{' external_definition_list '}'				// CFA, namespace
 		{
@@ -2381,7 +2363,5 @@
 		}
 	| declaration_qualifier_list
-		{
-			if ( $1->type->forall ) xxx = forall = true; // remember generic type
-		}
+		{ if ( $1->type->forall ) xxx = forall = true; } // remember generic type
 	  push '{' external_definition_list '}'				// CFA, namespace
 		{
@@ -2423,13 +2403,7 @@
 		// declaration must still have a type_specifier.  OBSOLESCENT (see 1)
 	| function_declarator compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $1->addFunctionBody( $2 );
-		}
+		{ $$ = $1->addFunctionBody( $2 ); }
 	| KR_function_declarator KR_declaration_list_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 );
-		}
+		{ $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
 	;
 
@@ -2444,5 +2418,4 @@
 	cfa_function_declaration with_clause_opt compound_statement	// CFA
 		{
-			typedefTable.leaveScope();
 			// Add the function body to the last identifier in the function definition list, i.e., foo3:
 			//   [const double] foo1(), foo2( int ), foo3( double ) { return 3.0; }
@@ -2453,5 +2426,4 @@
 		{
 			rebindForall( $1, $2 );
-			typedefTable.leaveScope();
 			$$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
 		}
@@ -2459,25 +2431,15 @@
 		{
 			rebindForall( $1, $2 );
-			typedefTable.leaveScope();
 			$$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
 		}
 		// handles default int return type, OBSOLESCENT (see 1)
 	| type_qualifier_list function_declarator with_clause_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
-		}
+		{ $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
 		// handles default int return type, OBSOLESCENT (see 1)
 	| declaration_qualifier_list function_declarator with_clause_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
-		}
+		{ $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
 		// handles default int return type, OBSOLESCENT (see 1)
 	| declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 );
-		}
+		{ $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 ); }
 
 		// Old-style K&R function definition, OBSOLESCENT (see 4)
@@ -2485,25 +2447,15 @@
 		{
 			rebindForall( $1, $2 );
-			typedefTable.leaveScope();
 			$$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addType( $1 );
 		}
 		// handles default int return type, OBSOLESCENT (see 1)
 	| type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
-		}
+		{ $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
 		// handles default int return type, OBSOLESCENT (see 1)
 	| declaration_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
-		}
+		{ $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
 		// handles default int return type, OBSOLESCENT (see 1)
 	| declaration_qualifier_list type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
-		{
-			typedefTable.leaveScope();
-			$$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 );
-		}
+		{ $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 ); }
 	;
 
@@ -2702,6 +2654,6 @@
 	paren_identifier '(' identifier_list ')'			// function_declarator handles empty parameter
 		{ $$ = $1->addIdList( $3 ); }
-	| '(' KR_function_ptr ')' '(' parameter_type_list_opt ')'
-		{ $$ = $2->addParamList( $5 ); }
+	| '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
+		{ $$ = $2->addParamList( $6 ); }
 	| '(' KR_function_no_ptr ')'						// redundant parenthesis
 		{ $$ = $2; }
@@ -2821,8 +2773,8 @@
 
 identifier_parameter_function:
-	paren_identifier '(' parameter_type_list_opt ')'	// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $1->addParamList( $3 ); }
-	| '(' identifier_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $5 ); }
+	paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $1->addParamList( $4 ); }
+	| '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $2->addParamList( $6 ); }
 	| '(' identifier_parameter_function ')'				// redundant parenthesis
 		{ $$ = $2; }
@@ -2874,8 +2826,8 @@
 
 type_parameter_function:
-	typedef '(' parameter_type_list_opt ')'				// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $1->addParamList( $3 ); }
-	| '(' type_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $5 ); }
+	typedef '(' push parameter_type_list_opt pop ')'	// empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $1->addParamList( $4 ); }
+	| '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $2->addParamList( $6 ); }
 	;
 
@@ -2924,8 +2876,8 @@
 
 abstract_function:
-	'(' parameter_type_list_opt ')'						// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
-	| '(' abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $5 ); }
+	'(' push parameter_type_list_opt pop ')'			// empty parameter list OBSOLESCENT (see 3)
+		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
+	| '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $2->addParamList( $6 ); }
 	| '(' abstract_function ')'							// redundant parenthesis
 		{ $$ = $2; }
@@ -2942,11 +2894,11 @@
 
 multi_array_dimension:
-	'[' assignment_expression ']'
-		{ $$ = DeclarationNode::newArray( $2, 0, false ); }
-	| '[' '*' ']'										// C99
+	'[' push assignment_expression pop ']'
+		{ $$ = DeclarationNode::newArray( $3, 0, false ); }
+	| '[' push '*' pop ']'								// C99
 		{ $$ = DeclarationNode::newVarArray( 0 ); }
-	| multi_array_dimension '[' assignment_expression ']'
-		{ $$ = $1->addArray( DeclarationNode::newArray( $3, 0, false ) ); }
-	| multi_array_dimension '[' '*' ']'					// C99
+	| multi_array_dimension '[' push assignment_expression pop ']'
+		{ $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
+	| multi_array_dimension '[' push '*' pop ']'		// C99
 		{ $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
 	;
@@ -3015,8 +2967,8 @@
 
 abstract_parameter_function:
-	'(' parameter_type_list_opt ')'						// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
-	| '(' abstract_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $5 ); }
+	'(' push parameter_type_list_opt pop ')'			// empty parameter list OBSOLESCENT (see 3)
+		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
+	| '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $2->addParamList( $6 ); }
 	| '(' abstract_parameter_function ')'				// redundant parenthesis
 		{ $$ = $2; }
@@ -3039,16 +2991,16 @@
 	'[' ']'
 		{ $$ = DeclarationNode::newArray( 0, 0, false ); }
-	// multi_array_dimension handles the '[' '*' ']' case
-	| '[' type_qualifier_list '*' ']'					// remaining C99
-		{ $$ = DeclarationNode::newVarArray( $2 ); }
-	| '[' type_qualifier_list ']'
-		{ $$ = DeclarationNode::newArray( 0, $2, false ); }
-	// multi_array_dimension handles the '[' assignment_expression ']' case
-	| '[' type_qualifier_list assignment_expression ']'
-		{ $$ = DeclarationNode::newArray( $3, $2, false ); }
-	| '[' STATIC type_qualifier_list_opt assignment_expression ']'
-		{ $$ = DeclarationNode::newArray( $4, $3, true ); }
-	| '[' type_qualifier_list STATIC assignment_expression ']'
-		{ $$ = DeclarationNode::newArray( $4, $2, true ); }
+		// multi_array_dimension handles the '[' '*' ']' case
+	| '[' push type_qualifier_list '*' pop ']'			// remaining C99
+		{ $$ = DeclarationNode::newVarArray( $3 ); }
+	| '[' push type_qualifier_list pop ']'
+		{ $$ = DeclarationNode::newArray( 0, $3, false ); }
+		// multi_array_dimension handles the '[' assignment_expression ']' case
+	| '[' push type_qualifier_list assignment_expression pop ']'
+		{ $$ = DeclarationNode::newArray( $4, $3, false ); }
+	| '[' push STATIC type_qualifier_list_opt assignment_expression pop ']'
+		{ $$ = DeclarationNode::newArray( $5, $4, true ); }
+	| '[' push type_qualifier_list STATIC assignment_expression pop ']'
+		{ $$ = DeclarationNode::newArray( $5, $3, true ); }
 	;
 
@@ -3094,6 +3046,6 @@
 
 variable_abstract_function:
-	'(' variable_abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
-		{ $$ = $2->addParamList( $5 ); }
+	'(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+		{ $$ = $2->addParamList( $6 ); }
 	| '(' variable_abstract_function ')'				// redundant parenthesis
 		{ $$ = $2; }
@@ -3158,15 +3110,15 @@
 
 cfa_array_parameter_1st_dimension:
-	'[' type_qualifier_list '*' ']'						// remaining C99
-		{ $$ = DeclarationNode::newVarArray( $2 ); }
-	| '[' type_qualifier_list assignment_expression ']'
-		{ $$ = DeclarationNode::newArray( $3, $2, false ); }
-	| '[' declaration_qualifier_list assignment_expression ']'
+	'[' push type_qualifier_list '*' pop ']'			// remaining C99
+		{ $$ = DeclarationNode::newVarArray( $3 ); }
+	| '[' push type_qualifier_list assignment_expression pop ']'
+		{ $$ = DeclarationNode::newArray( $4, $3, false ); }
+	| '[' push declaration_qualifier_list assignment_expression pop ']'
 		// declaration_qualifier_list must be used because of shift/reduce conflict with
 		// assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot
 		// appear in this context.
-		{ $$ = DeclarationNode::newArray( $3, $2, true ); }
-	| '[' declaration_qualifier_list type_qualifier_list assignment_expression ']'
-		{ $$ = DeclarationNode::newArray( $4, $3->addQualifiers( $3 ), true ); }
+		{ $$ = DeclarationNode::newArray( $4, $3, true ); }
+	| '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
+		{ $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
 	;
 
@@ -3180,5 +3132,5 @@
 //
 //		cfa_abstract_tuple identifier_or_type_name
-//		'[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+//		'[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')'
 //
 // since a function return type can be syntactically identical to a tuple type:
@@ -3237,15 +3189,19 @@
 
 cfa_abstract_tuple:										// CFA
-	'[' cfa_abstract_parameter_list ']'
-		{ $$ = DeclarationNode::newTuple( $2 ); }
+	'[' push cfa_abstract_parameter_list pop ']'
+		{ $$ = DeclarationNode::newTuple( $3 ); }
+	| '[' push type_specifier_nobody ELLIPSIS ']'
+		{ SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; }
+	| '[' push type_specifier_nobody ELLIPSIS constant_expression ']'
+		{ SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; }
 	;
 
 cfa_abstract_function:									// CFA
-//	'[' ']' '(' cfa_parameter_type_list_opt ')'
+//	'[' ']' '(' cfa_parameter_ellipsis_list_opt ')'
 //		{ $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
-	cfa_abstract_tuple '(' cfa_parameter_type_list_opt ')'
-		{ $$ = DeclarationNode::newFunction( nullptr, $1, $3, nullptr ); }
-	| cfa_function_return '(' cfa_parameter_type_list_opt ')'
-		{ $$ = DeclarationNode::newFunction( nullptr, $1, $3, nullptr ); }
+	cfa_abstract_tuple '(' push cfa_parameter_ellipsis_list_opt pop ')'
+		{ $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
+	| cfa_function_return '(' push cfa_parameter_ellipsis_list_opt pop ')'
+		{ $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
 	;
 
