Changes in src/Parser/parser.yy [13e8427:3ed994e]

File:

• src/Parser/parser.yy (modified) (39 diffs)

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 28 17:01:36 2018
-// Update Count     : 3383
+// Last Modified On : Tue May 22 08:41:57 2018
+// Update Count     : 3353
 //
 
@@ -175 +175 @@
         bool flag;
         CatchStmt::Kind catch_kind;
+        GenericExpr * genexpr;
 }
 
@@ -259 +260 @@
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
+%type<genexpr> generic_association generic_assoc_list
 
 // statements
@@ -324 +326 @@
 %type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
 
-%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_ellipsis_list_opt
+%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt
 
 %type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
@@ -501 +503 @@
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
-                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
+                {
+                        // add the missing control expression to the GenericExpr and return it
+                        $5->control = maybeMoveBuild<Expression>( $3 );
+                        $$ = new ExpressionNode( $5 );
+                }
         ;
 
 generic_assoc_list:                                                                             // C11
-        | generic_association
+        generic_association
         | generic_assoc_list ',' generic_association
+                {
+                        // steal the association node from the singleton and delete the wrapper
+                        $1->associations.splice($1->associations.end(), $3->associations);
+                        delete $3;
+                        $$ = $1;
+                }
         ;
 
 generic_association:                                                                    // C11
         type_no_function ':' assignment_expression
+                {
+                        // create a GenericExpr wrapper with one association pair
+                        $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>($3) } } );
+                }
         | DEFAULT ':' assignment_expression
+                { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>($3) } } ); }
         ;
 
@@ -835 +852 @@
 //      '[' ']'
 //              { $$ = new ExpressionNode( build_tuple() ); }
-//      | '[' push assignment_expression pop ']'
+//      '[' push assignment_expression pop ']'
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
-        '[' 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 ) ) ); }
+        '[' ',' 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 ) ) ); }
         ;
 
@@ -866 +883 @@
         labeled_statement
         | compound_statement
-        | expression_statement
+        | expression_statement                                          { $$ = $1; }
         | selection_statement
         | iteration_statement
@@ -1183 +1200 @@
         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
         ;
@@ -1265 +1286 @@
 
 declaration_list_opt:                                                                   // used at beginning of switch statement
-        pop     // empty
+        pop
                 { $$ = nullptr; }
         | declaration_list
@@ -1300 +1321 @@
 
 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 {}
         ;
 
@@ -1364 +1385 @@
         | declaration_qualifier_list type_qualifier_list cfa_function_specifier
                 { $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); }
-        | cfa_function_declaration ',' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
+        | cfa_function_declaration ',' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
                 {
                         // 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, $6, nullptr ) );
+                        $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $5, nullptr ) );
                 }
         ;
 
 cfa_function_specifier:                                                                 // CFA
-//      '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
+//      '[' ']' 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 cfa_parameter_ellipsis_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 cfa_parameter_ellipsis_list_opt pop ')'
+//      | '[' ']' TYPEDEFname '(' push cfa_parameter_type_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
@@ -1391 +1412 @@
                 // identifier_or_type_name must be broken apart because of the sequence:
                 //
-                //   '[' ']' identifier_or_type_name '(' cfa_parameter_ellipsis_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.
-        cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
+        cfa_abstract_tuple identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
-                { $$ = 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 ); }
+                { $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); }
+        | cfa_function_return identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+                { $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); }
         ;
 
 cfa_function_return:                                                                    // CFA
-        '[' 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 ) ); }
+        '[' 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 ) ); }
         ;
 
@@ -1582 +1604 @@
 
 forall:
-        FORALL '(' push type_parameter_list pop ')'                                     // CFA
-                { $$ = DeclarationNode::newForall( $4 ); }
+        FORALL '('
+                {
+                        typedefTable.enterScope();
+                }
+          type_parameter_list ')'                                                       // CFA
+                {
+                        typedefTable.leaveScope();
+                        $$ = DeclarationNode::newForall( $4 );
+                }
         ;
 
@@ -1951 +1980 @@
         ;
 
-cfa_parameter_ellipsis_list_opt:                                                        // CFA, abstract + real
+cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
         // empty
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
@@ -1958 +1987 @@
         | cfa_abstract_parameter_list
         | cfa_parameter_list
-        | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
-                { $$ = $1->appendList( $5 ); }
-        | cfa_abstract_parameter_list pop ',' push ELLIPSIS
+        | cfa_parameter_list ',' cfa_abstract_parameter_list
+                { $$ = $1->appendList( $3 ); }
+        | cfa_abstract_parameter_list ',' ELLIPSIS
                 { $$ = $1->addVarArgs(); }
-        | cfa_parameter_list pop ',' push ELLIPSIS
+        | cfa_parameter_list ',' ELLIPSIS
                 { $$ = $1->addVarArgs(); }
         ;
@@ -1970 +1999 @@
                 // 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 ); }
-        | 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_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:                                                    // CFA, new & old style abstract
         cfa_abstract_parameter_declaration
-        | cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration
-                { $$ = $1->appendList( $5 ); }
+        | cfa_abstract_parameter_list ',' cfa_abstract_parameter_declaration
+                { $$ = $1->appendList( $3 ); }
         ;
 
@@ -2084 +2113 @@
                 { $$ = $2; }
         | '=' VOID
-                { $$ = nullptr; }
+                { $$ = new InitializerNode( true ); }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }
@@ -2130 +2159 @@
         '.' no_attr_identifier                                                          // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
-        | '[' push assignment_expression pop ']'                        // C99, single array element
+        | '[' assignment_expression ']'                                         // 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; }
         ;
 
@@ -2209 +2238 @@
         '|' no_attr_identifier_or_type_name '(' type_list ')'
                 { $$ = DeclarationNode::newTraitUse( $2, $4 ); }
-        | '|' '{' push trait_declaration_list pop '}'
+        | '|' '{' push trait_declaration_list '}'
                 { $$ = $4; }
-        | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}' '(' type_list ')'
+        | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
                 { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
         ;
@@ -2257 +2286 @@
         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 ')' '{' push trait_declaration_list pop '}'
+        | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{'
+                { typedefTable.enterScope(); }
+          trait_declaration_list '}'
                 { $$ = DeclarationNode::newTrait( $2, $5, $10 ); }
         ;
@@ -2263 +2294 @@
 trait_declaration_list:                                                                 // CFA
         trait_declaration
-        | trait_declaration_list pop push trait_declaration
-                { $$ = $1->appendList( $4 ); }
+        | trait_declaration_list push trait_declaration
+                { $$ = $1->appendList( $3 ); }
         ;
 
 trait_declaration:                                                                              // CFA
-        cfa_trait_declaring_list ';'
-        | trait_declaring_list ';'
+        cfa_trait_declaring_list pop ';'
+        | trait_declaring_list pop ';'
         ;
 
 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 ) ); }
@@ -2333 +2366 @@
                 }
         | 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
                 {
@@ -2346 +2381 @@
                 }
         | 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
                 {
@@ -2386 +2423 @@
                 // declaration must still have a type_specifier.  OBSOLESCENT (see 1)
         | function_declarator compound_statement
-                { $$ = $1->addFunctionBody( $2 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $1->addFunctionBody( $2 );
+                }
         | KR_function_declarator KR_declaration_list_opt compound_statement
-                { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 );
+                }
         ;
 
@@ -2401 +2444 @@
         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; }
@@ -2409 +2453 @@
                 {
                         rebindForall( $1, $2 );
+                        typedefTable.leaveScope();
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
                 }
@@ -2414 +2459 @@
                 {
                         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
-                { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
+                }
                 // handles default int return type, OBSOLESCENT (see 1)
         | declaration_qualifier_list function_declarator with_clause_opt compound_statement
-                { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $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
-                { $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 );
+                }
 
                 // Old-style K&R function definition, OBSOLESCENT (see 4)
@@ -2430 +2485 @@
                 {
                         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
-                { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $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
-                { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $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
-                { $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 );
+                }
         ;
 
@@ -2637 +2702 @@
         paren_identifier '(' identifier_list ')'                        // function_declarator handles empty parameter
                 { $$ = $1->addIdList( $3 ); }
-        | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
-                { $$ = $2->addParamList( $6 ); }
+        | '(' KR_function_ptr ')' '(' parameter_type_list_opt ')'
+                { $$ = $2->addParamList( $5 ); }
         | '(' KR_function_no_ptr ')'                                            // redundant parenthesis
                 { $$ = $2; }
@@ -2756 +2821 @@
 
 identifier_parameter_function:
-        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 ); }
+        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 ); }
         | '(' identifier_parameter_function ')'                         // redundant parenthesis
                 { $$ = $2; }
@@ -2809 +2874 @@
 
 type_parameter_function:
-        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 ); }
+        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 ); }
         ;
 
@@ -2859 +2924 @@
 
 abstract_function:
-        '(' 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 ); }
+        '(' 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 ); }
         | '(' abstract_function ')'                                                     // redundant parenthesis
                 { $$ = $2; }
@@ -2877 +2942 @@
 
 multi_array_dimension:
-        '[' push assignment_expression pop ']'
-                { $$ = DeclarationNode::newArray( $3, 0, false ); }
-        | '[' push '*' pop ']'                                                          // C99
+        '[' assignment_expression ']'
+                { $$ = DeclarationNode::newArray( $2, 0, false ); }
+        | '[' '*' ']'                                                                           // C99
                 { $$ = DeclarationNode::newVarArray( 0 ); }
-        | multi_array_dimension '[' push assignment_expression pop ']'
-                { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
-        | multi_array_dimension '[' push '*' pop ']'            // C99
+        | multi_array_dimension '[' assignment_expression ']'
+                { $$ = $1->addArray( DeclarationNode::newArray( $3, 0, false ) ); }
+        | multi_array_dimension '[' '*' ']'                                     // C99
                 { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
         ;
@@ -2950 +3015 @@
 
 abstract_parameter_function:
-        '(' 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 ); }
+        '(' 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 ); }
         | '(' abstract_parameter_function ')'                           // redundant parenthesis
                 { $$ = $2; }
@@ -2974 +3039 @@
         '[' ']'
                 { $$ = DeclarationNode::newArray( 0, 0, false ); }
-                // 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 ); }
+        // 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 ); }
         ;
 
@@ -3029 +3094 @@
 
 variable_abstract_function:
-        '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
+        '(' variable_abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $2->addParamList( $5 ); }
         | '(' variable_abstract_function ')'                            // redundant parenthesis
                 { $$ = $2; }
@@ -3093 +3158 @@
 
 cfa_array_parameter_1st_dimension:
-        '[' 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 ']'
+        '[' type_qualifier_list '*' ']'                                         // remaining C99
+                { $$ = DeclarationNode::newVarArray( $2 ); }
+        | '[' type_qualifier_list assignment_expression ']'
+                { $$ = DeclarationNode::newArray( $3, $2, false ); }
+        | '[' declaration_qualifier_list assignment_expression ']'
                 // 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( $4, $3, true ); }
-        | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
-                { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
+                { $$ = DeclarationNode::newArray( $3, $2, true ); }
+        | '[' declaration_qualifier_list type_qualifier_list assignment_expression ']'
+                { $$ = DeclarationNode::newArray( $4, $3->addQualifiers( $3 ), true ); }
         ;
 
@@ -3115 +3180 @@
 //
 //              cfa_abstract_tuple identifier_or_type_name
-//              '[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')'
+//              '[' 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:
@@ -3172 +3237 @@
 
 cfa_abstract_tuple:                                                                             // CFA
-        '[' 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_parameter_list ']'
+                { $$ = DeclarationNode::newTuple( $2 ); }
         ;
 
 cfa_abstract_function:                                                                  // CFA
-//      '[' ']' '(' cfa_parameter_ellipsis_list_opt ')'
+//      '[' ']' '(' cfa_parameter_type_list_opt ')'
 //              { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, 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 ); }
+        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 ); }
         ;