Changes in src/Parser/parser.yy [35718a9:3ed994e]

File:

• src/Parser/parser.yy (modified) (53 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 : Wed May 30 20:29:03 2018
-// Update Count     : 3432
+// 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
@@ -330 +332 @@
 %type<decl> c_declaration static_assert
 %type<decl> KR_function_declarator KR_function_no_ptr KR_function_ptr KR_function_array
-%type<decl> KR_parameter_list KR_parameter_list_opt
+%type<decl> KR_declaration_list KR_declaration_list_opt
 
 %type<decl> parameter_declaration parameter_list parameter_type_list_opt
@@ -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 ) ); }
         '[' ',' tuple_expression_list ']'
                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
-        | '[' push assignment_expression pop ',' tuple_expression_list ']'
-                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $6 ) ) ); }
+        | '[' 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
@@ -892 +909 @@
         '{' '}'
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
-        | '{' push
+        | '{'
+                // Two scopes are necessary because the block itself has a scope, but every declaration within the block also
+                // requires its own scope.
+          push push
           local_label_declaration_opt                                           // GCC, local labels
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
-                { $$ = new StatementNode( build_compound( $4 ) ); }
+                { $$ = new StatementNode( build_compound( $5 ) ); }
         ;
 
 statement_decl_list:                                                                    // C99
         statement_decl
-        | statement_decl_list statement_decl
-                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+        | statement_decl_list push statement_decl
+                { if ( $1 != 0 ) { $1->set_last( $3 ); $$ = $1; } }
         ;
 
@@ -920 +940 @@
                         $$ = new StatementNode( $2 );
                 }
-        | statement
+        | statement pop
         ;
 
@@ -935 +955 @@
 
 selection_statement:
-        IF '(' push if_control_expression ')' statement pop             %prec THEN
+        IF '(' push if_control_expression ')' statement         %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $4, $6, nullptr ) ); }
-        | IF '(' push if_control_expression ')' statement ELSE statement pop
+        | IF '(' push if_control_expression ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $4, $6, $8 ) ); }
         | SWITCH '(' comma_expression ')' case_clause
                 { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
-        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
                 {
                         StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
@@ -954 +974 @@
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
                 { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
-        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
+        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
                 {
                         StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
@@ -962 +982 @@
 
 if_control_expression:
-        comma_expression
+        comma_expression pop
                 { $$ = new IfCtl( nullptr, $1 ); }
-        | c_declaration                                                                         // no semi-colon
+        | c_declaration pop                                                                     // no semi-colon
                 { $$ = new IfCtl( $1, nullptr ); }
-        | cfa_declaration                                                                       // no semi-colon
+        | cfa_declaration pop                                                           // no semi-colon
                 { $$ = new IfCtl( $1, nullptr ); }
         | declaration comma_expression                                          // semi-colon separated
@@ -1027 +1047 @@
         | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_while( $5, $2, true ) ); }
-        | FOR '(' push for_control_expression ')' statement pop
+        | FOR '(' push for_control_expression ')' statement
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
         ;
 
 for_control_expression:
-        comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtl( $1, $3, $5 ); }
+        comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtl( $1, $4, $6 ); }
         | declaration comma_expression_opt ';' comma_expression_opt // C99
                 { $$ = new ForCtl( $1, $2, $4 ); }
@@ -1180 +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
         ;
@@ -1262 +1286 @@
 
 declaration_list_opt:                                                                   // used at beginning of switch statement
+        pop
+                { $$ = nullptr; }
+        | declaration_list
+        ;
+
+declaration_list:
+        declaration
+        | declaration_list push declaration
+                { $$ = $1->appendList( $3 ); }
+        ;
+
+KR_declaration_list_opt:                                                                // used to declare parameter types in K&R style functions
         // empty
                 { $$ = nullptr; }
-        | declaration_list
-        ;
-
-declaration_list:
-        declaration
-        | declaration_list declaration
-                { $$ = $1->appendList( $2 ); }
-        ;
-
-KR_parameter_list_opt:                                                          // used to declare parameter types in K&R style functions
-        // empty
-                { $$ = nullptr; }
-        | KR_parameter_list
-        ;
-
-KR_parameter_list:
+        | KR_declaration_list
+        ;
+
+KR_declaration_list:
         push c_declaration pop ';'
                 { $$ = $2; }
-        | KR_parameter_list push c_declaration pop ';'
+        | KR_declaration_list push c_declaration pop ';'
                 { $$ = $1->appendList( $3 ); }
         ;
@@ -1297 +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 {}
         ;
 
 declaration:                                                                                    // old & new style declarations
-        c_declaration ';'
-        | cfa_declaration ';'                                                           // CFA
+        c_declaration pop ';'
+        | cfa_declaration pop ';'                                                       // CFA
         | static_assert
         ;
@@ -1361 +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 );
@@ -1388 +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 ) ); }
         ;
 
@@ -1411 +1436 @@
         TYPEDEF cfa_variable_specifier
                 {
-                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "1"*/ );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
                         $$ = $2->addTypedef();
                 }
         | TYPEDEF cfa_function_specifier
                 {
-                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname /*, "2"*/ );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
                         $$ = $2->addTypedef();
                 }
         | cfa_typedef_declaration pop ',' push no_attr_identifier
                 {
-                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname /*, "3"*/ );
+                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname );
                         $$ = $1->appendList( $1->cloneType( $5 ) );
                 }
@@ -1432 +1457 @@
         TYPEDEF type_specifier declarator
                 {
-                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "4"*/ );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
                         $$ = $3->addType( $2 )->addTypedef();
                 }
         | typedef_declaration pop ',' push declarator
                 {
-                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname /*, "5"*/ );
+                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname );
                         $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
                 }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
                 {
-                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "6"*/ );
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
                         $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
                 }
         | type_specifier TYPEDEF declarator
                 {
-                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname /*, "7"*/ );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
                         $$ = $3->addType( $1 )->addTypedef();
                 }
         | type_specifier TYPEDEF type_qualifier_list declarator
                 {
-                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname /*, "8"*/ );
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
                         $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
                 }
@@ -1579 +1604 @@
 
 forall:
-        FORALL '(' type_parameter_list ')'                                      // CFA
-                { $$ = DeclarationNode::newForall( $3 ); }
+        FORALL '('
+                {
+                        typedefTable.enterScope();
+                }
+          type_parameter_list ')'                                                       // CFA
+                {
+                        typedefTable.leaveScope();
+                        $$ = DeclarationNode::newForall( $4 );
+                }
         ;
 
@@ -1948 +1980 @@
         ;
 
-cfa_parameter_ellipsis_list_opt:                                                        // CFA, abstract + real
+cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
         // empty
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
@@ -1955 +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(); }
         ;
@@ -1967 +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 ); }
         ;
 
@@ -2081 +2113 @@
                 { $$ = $2; }
         | '=' VOID
-                { $$ = nullptr; }
+                { $$ = new InitializerNode( true ); }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }
@@ -2127 +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; }
         ;
 
@@ -2172 +2204 @@
 type_parameter:                                                                                 // CFA
         type_class no_attr_identifier_or_type_name
-                { typedefTable.addToScope( *$2, TYPEDEFname /*, "9"*/ ); }
+                { typedefTable.addToEnclosingScope( *$2, TYPEDEFname ); }
           type_initializer_opt assertion_list_opt
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
@@ -2206 +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 ')'
-        //      { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
+        | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
+                { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -2241 +2273 @@
         no_attr_identifier_or_type_name
                 {
-                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname /*, "10"*/ );
+                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname );
                         $$ = DeclarationNode::newTypeDecl( $1, 0 );
                 }
-        | no_attr_identifier_or_type_name '(' type_parameter_list ')'
-                {
-                        typedefTable.addToEnclosingScope( *$1, TYPEGENname /*, "11"*/ );
-                        $$ = DeclarationNode::newTypeDecl( $1, $3 );
+        | no_attr_identifier_or_type_name '(' push type_parameter_list pop ')'
+                {
+                        typedefTable.addToEnclosingScope( *$1, TYPEGENname );
+                        $$ = DeclarationNode::newTypeDecl( $1, $4 );
                 }
         ;
 
 trait_specifier:                                                                                // CFA
-        TRAIT no_attr_identifier_or_type_name '(' type_parameter_list ')' '{' '}'
-                { $$ = DeclarationNode::newTrait( $2, $4, 0 ); }
-        | TRAIT no_attr_identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
-                { $$ = DeclarationNode::newTrait( $2, $4, $8 ); }
+        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 '}'
+                { $$ = DeclarationNode::newTrait( $2, $5, $10 ); }
         ;
 
 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 ) ); }
@@ -2293 +2329 @@
 
 external_definition_list:
-        push external_definition pop
-                { $$ = $2; }
+        external_definition
         | external_definition_list
                 { forall = xxx; }
-          push external_definition pop
+          push external_definition
                 { $$ = $1 ? $1->appendList( $4 ) : $4; }
         ;
@@ -2319 +2354 @@
                         linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
                 }
-                        // SKULLDUGGERY: Declarations in extern "X" need to be added to the current lexical scope.  However,
-                        // external_definition_list_opt creates a new scope that loses the types at the end of the extern block. The
-                        // correction is a pop/push (reverse order) to undo the push/pop from external_definition_list_opt.  This
-                        // trick works for nested extern "X"s, as each one undoes itself in the nesting.
-          '{' pop external_definition_list_opt push '}'
+          '{' external_definition_list_opt '}'
                 {
                         linkage = linkageStack.top();
                         linkageStack.pop();
-                        $$ = $6;
+                        $$ = $5;
                 }
         | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
@@ -2335 +2366 @@
                 }
         | type_qualifier_list
-                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
-          '{' external_definition_list push '}'                  // CFA, namespace
-                {
-                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+                {
+                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
+                }
+          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
                                 if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
                                         iter->addQualifiers( $1->clone() );
@@ -2345 +2378 @@
                         xxx = false;
                         delete $1;
-                        $$ = $4;
+                        $$ = $5;
                 }
         | declaration_qualifier_list
-                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
-          '{' external_definition_list '}'                                       // CFA, namespace
-                {
-                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+                {
+                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
+                }
+          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
                                 if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
                                         iter->addQualifiers( $1->clone() );
@@ -2358 +2393 @@
                         xxx = false;
                         delete $1;
-                        $$ = $4;
+                        $$ = $5;
                 }
         | declaration_qualifier_list type_qualifier_list
@@ -2365 +2400 @@
                         if ( $2->type->forall ) xxx = forall = true; // remember generic type
                 }
-          '{' external_definition_list '}'                                      // CFA, namespace
-                {
-                        for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        for ( DeclarationNode * iter = $6; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
                                 if ( isMangled( iter->linkage ) && isMangled( $2->linkage ) ) { // ignore extern "C"
                                         iter->addQualifiers( $1->clone() );
@@ -2376 +2411 @@
                         delete $1;
                         delete $2;
-                        $$ = $5;
+                        $$ = $6;
                 }
         ;
@@ -2388 +2423 @@
                 // declaration must still have a type_specifier.  OBSOLESCENT (see 1)
         | function_declarator compound_statement
-                { $$ = $1->addFunctionBody( $2 ); }
-        | KR_function_declarator KR_parameter_list_opt compound_statement
-                { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
+                {
+                        typedefTable.leaveScope();
+                        $$ = $1->addFunctionBody( $2 );
+                }
+        | KR_function_declarator KR_declaration_list_opt compound_statement
+                {
+                        typedefTable.leaveScope();
+                        $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 );
+                }
         ;
 
@@ -2403 +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; }
@@ -2411 +2453 @@
                 {
                         rebindForall( $1, $2 );
+                        typedefTable.leaveScope();
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
                 }
@@ -2416 +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)
-        | declaration_specifier KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
+        | declaration_specifier KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
                 {
                         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_parameter_list_opt with_clause_opt compound_statement
-                { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $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 );
+                }
                 // handles default int return type, OBSOLESCENT (see 1)
-        | declaration_qualifier_list KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
-                { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $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 );
+                }
                 // handles default int return type, OBSOLESCENT (see 1)
-        | declaration_qualifier_list type_qualifier_list KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
-                { $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $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 );
+                }
         ;
 
@@ -2639 +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; }
@@ -2686 +2749 @@
         typedef
                 // hide type name in enclosing scope by variable name
-                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER /*, "ID"*/ ); }
+                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER ); }
         | '(' paren_type ')'
                 { $$ = $2; }
@@ -2758 +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; }
@@ -2811 +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 ); }
         ;
 
@@ -2861 +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; }
@@ -2879 +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 ) ); }
         ;
@@ -2952 +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; }
@@ -2976 +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 ); }
         ;
 
@@ -3031 +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; }
@@ -3095 +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 ); }
         ;
 
@@ -3117 +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:
@@ -3174 +3237 @@
 
 cfa_abstract_tuple:                                                                             // CFA
-        '[' push cfa_abstract_parameter_list pop ']'
-                { $$ = DeclarationNode::newTuple( $3 ); }
-        | '[' push type_specifier_nobody ELLIPSIS pop ']'
-                { SemanticError( yylloc, "Tuple array currently unimplemented." ); $$ = nullptr; }
-        | '[' push type_specifier_nobody ELLIPSIS constant_expression pop ']'
-                { 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 ); }
         ;