Changes in src/Parser/parser.yy [3d56d15b:b048dc3]

File:

• src/Parser/parser.yy (modified) (54 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 : Fri Jun 22 13:59:11 2018
-// Update Count     : 3586
+// Last Modified On : Thu May 24 18:11:59 2018
+// Update Count     : 3369
 //
 
@@ -136 +136 @@
 } // build_postfix_name
 
-bool forall = false, xxx = false, yyy = false;                  // aggregate have one or more forall qualifiers ?
+bool forall = false, xxx = false;                                               // aggregate have one or more forall qualifiers ?
 
 // https://www.gnu.org/software/bison/manual/bison.html#Location-Type
@@ -175 +175 @@
         bool flag;
         CatchStmt::Kind catch_kind;
-        GenericExpr * genexpr;
 }
 
@@ -260 +259 @@
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
-%type<genexpr> generic_association generic_assoc_list
 
 // statements
 %type<sn> statement                                             labeled_statement                       compound_statement
 %type<sn> statement_decl                                statement_decl_list                     statement_list_nodecl
-%type<sn> selection_statement                   if_statement
+%type<sn> selection_statement
 %type<sn> switch_clause_list_opt                switch_clause_list
 %type<en> case_value
@@ -304 +302 @@
 %type<en> enumerator_value_opt
 
-%type<decl> external_definition external_definition_list external_definition_list_opt
-
-%type<decl> exception_declaration
+%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
 
 %type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
@@ -328 +324 @@
 %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
@@ -334 +330 @@
 %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
@@ -406 +402 @@
 //************************* Namespace Management ********************************
 
-// The C grammar is not context free because it relies on the distinct terminal symbols "identifier" and "TYPEDEFname",
-// which are lexically identical.
-//
-//   typedef int foo; // identifier foo must now be scanned as TYPEDEFname
-//   foo f;           // to allow it to appear in this context
-//
-// While it may be possible to write a purely context-free grammar, such a grammar would obscure the relationship
-// between syntactic and semantic constructs.  Cforall compounds this problem by introducing type names local to the
-// scope of a declaration (for instance, those introduced through "forall" qualifiers), and by introducing "type
-// generators" -- parameterized types.  This latter type name creates a third class of identifiers, "TYPEGENname", which
-// must be distinguished by the lexical scanner.
-//
-// Since the scanner cannot distinguish among the different classes of identifiers without some context information,
-// there is a type table (typedefTable), which holds type names and identifiers that override type names, for each named
-// scope. During parsing, semantic actions update the type table by adding new identifiers in the current scope. For
-// each context that introduces a name scope, a new level is created in the type table and that level is popped on
-// exiting the scope.  Since type names can be local to a particular declaration, each declaration is itself a scope.
-// This requires distinguishing between type names that are local to the current declaration scope and those that
-// persist past the end of the declaration (i.e., names defined in "typedef" or "otype" declarations).
-//
-// The non-terminals "push" and "pop" denote the opening and closing of named scopes. Every push has a matching pop in
-// the production rule. There are multiple lists of declarations, where each declaration is a named scope, so pop/push
-// around the list separator.
-//
-//  int f( forall(T) T (*f1) T , forall( S ) S (*f2)( S ) );
-//      push               pop   push                   pop
+// The grammar in the ANSI C standard is not strictly context-free, since it relies upon the distinct terminal symbols
+// "identifier", "TYPEDEFname", and "TYPEGENname" that are lexically identical.  While it is possible to write a purely
+// context-free grammar, such a grammar would obscure the relationship between syntactic and semantic constructs.
+// Hence, this grammar uses the ANSI style.
+//
+// Cforall compounds this problem by introducing type names local to the scope of a declaration (for instance, those
+// introduced through "forall" qualifiers), and by introducing "type generators" -- parameterized types.  This latter
+// type name creates a third class of identifiers that must be distinguished by the scanner.
+//
+// Since the scanner cannot distinguish among the different classes of identifiers without some context information, it
+// accesses a data structure (TypedefTable) to allow classification of an identifier that it has just read.  Semantic
+// actions during the parser update this data structure when the class of identifiers change.
+//
+// Because the Cforall language is block-scoped, an identifier can change its class in a local scope; it must revert to
+// its original class at the end of the block.  Since type names can be local to a particular declaration, each
+// declaration is itself a scope.  This requires distinguishing between type names that are local to the current
+// declaration scope and those that persist past the end of the declaration (i.e., names defined in "typedef" or "otype"
+// declarations).
+//
+// The non-terminals "push" and "pop" denote the opening and closing of scopes.  Every push must have a matching pop,
+// although it is regrettable the matching pairs do not always occur within the same rule.  These non-terminals may
+// appear in more contexts than strictly necessary from a semantic point of view.
 
 push:
@@ -505 +497 @@
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
-                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
-                { $$ = nullptr; }
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
-                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
-                { $$ = nullptr; }
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
-                {
-                        // add the missing control expression to the GenericExpr and return it
-                        $5->control = maybeMoveBuild<Expression>( $3 );
-                        $$ = new ExpressionNode( $5 );
-                }
+                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
         ;
 
 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) } } ); }
         ;
 
@@ -648 +623 @@
                 // semantics checks, e.g., ++3, 3--, *3, &&3
         | constant
+                { $$ = $1; }
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
@@ -859 +835 @@
 //      '[' ']'
 //              { $$ = 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 ) ) ); }
+        '[' 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 ) ) ); }
         ;
 
@@ -916 +892 @@
         '{' '}'
                 { $$ = 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; } }
         ;
 
@@ -944 +923 @@
                         $$ = new StatementNode( $2 );
                 }
-        | statement
+        | statement pop
         ;
 
@@ -959 +938 @@
 
 selection_statement:
-                        // pop causes a S/R conflict without separating the IF statement into a non-terminal even after resolving
-                        // the inherent S/R conflict with THEN/ELSE.
-        push if_statement pop
-                { $$ = $2; }
+        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
+                { $$ = 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 ) );
@@ -977 +957 @@
         | 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 ) );
@@ -984 +964 @@
         ;
 
-if_statement:
-        IF '(' if_control_expression ')' statement                      %prec THEN
-                // explicitly deal with the shift/reduce conflict on if/else
-                { $$ = new StatementNode( build_if( $3, $5, nullptr ) ); }
-        | IF '(' if_control_expression ')' statement ELSE statement
-                { $$ = new StatementNode( build_if( $3, $5, $7 ) ); }
-        ;
-
 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
@@ -1054 +1026 @@
 
 iteration_statement:
-        WHILE '(' push if_control_expression ')' statement pop
-                { $$ = new StatementNode( build_while( $4, $6 ) ); }
+        WHILE '(' comma_expression ')' statement
+                { $$ = new StatementNode( build_while( $3, $5 ) ); }
         | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_do_while( $5, $2 ) ); }
-        | FOR '(' push for_control_expression ')' statement pop
+                { $$ = new StatementNode( build_while( $5, $2, true ) ); }
+        | 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 ); }
@@ -1186 +1158 @@
 
 handler_clause:
-        handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
-                { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
-        | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
-                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
+        handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = new StatementNode( build_catch( $1, $5, $7, $9 ) ); }
+        | handler_clause handler_key '(' push push exception_declaration pop handler_predicate_opt ')' compound_statement pop
+                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $6, $8, $10 ) ) ); }
         ;
 
@@ -1293 +1265 @@
 
 declaration_list_opt:                                                                   // used at beginning of switch statement
+        pop     // empty
+                { $$ = 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 ); }
         ;
@@ -1333 +1305 @@
 
 declaration:                                                                                    // old & new style declarations
-        c_declaration ';'
-        | cfa_declaration ';'                                                           // CFA
-        | static_assert                                                                         // C11
+        c_declaration pop ';'
+        | cfa_declaration pop ';'                                                       // CFA
+        | static_assert
         ;
 
@@ -1341 +1313 @@
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
                 { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
-        | STATICASSERT '(' constant_expression ')' ';'          // CFA
-                { $$ = DeclarationNode::newStaticAssert( $3, build_constantStr( *new string( "\"\"" ) ) ); }
 
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
@@ -1387 +1357 @@
 cfa_function_declaration:                                                               // CFA
         cfa_function_specifier
+                { $$ = $1; }
         | type_qualifier_list cfa_function_specifier
                 { $$ = $2->addQualifiers( $1 ); }
@@ -1393 +1364 @@
         | 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 );
@@ -1420 +1391 @@
                 // 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 '(' push cfa_parameter_type_list_opt pop ')'
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
-        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
+        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
         ;
@@ -1443 +1414 @@
         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 ) );
                 }
@@ -1464 +1435 @@
         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 );
                 }
@@ -1611 +1582 @@
 
 forall:
-        FORALL '(' type_parameter_list ')'                                      // CFA
-                { $$ = DeclarationNode::newForall( $3 ); }
+        FORALL '(' push type_parameter_list pop ')'                                     // CFA
+                { $$ = DeclarationNode::newForall( $4 ); }
         ;
 
@@ -1794 +1765 @@
                 { $$ = DeclarationNode::newFromTypedef( $1 ); }
         | '.' TYPEDEFname
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newFromTypedef( $2 ); } // FIX ME
         | type_name '.' TYPEDEFname
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newFromTypedef( $3 ); } // FIX ME
         | typegen_name
         | '.' typegen_name
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = $2; }                                                                    // FIX ME
         | type_name '.' typegen_name
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = $3; }                                                                    // FIX ME
         ;
 
@@ -1823 +1794 @@
         ;
 
-fred:
-        // empty
-                { yyy = false; }
-        ;
-
 aggregate_type:                                                                                 // struct, union
         aggregate_key attribute_list_opt '{' field_declaration_list_opt '}'
                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
-        | aggregate_key attribute_list_opt no_attr_identifier fred
-                {
-                        typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname ); // create typedef
-                        //if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
+        | aggregate_key attribute_list_opt no_attr_identifier_or_type_name
+                {
+                        typedefTable.makeTypedef( *$3 );                        // create typedef
+                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
                 }
           '{' field_declaration_list_opt '}'
-                { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $7, true )->addQualifiers( $2 ); }
-        | aggregate_key attribute_list_opt type_name fred
-                {
-                        typedefTable.makeTypedef( *$3->type->symbolic.name, forall ? TYPEGENname : TYPEDEFname ); // create typedef
-                        //if ( forall ) typedefTable.changeKind( *$3->type->symbolic.name, TYPEGENname ); // possibly update
-                        forall = false;                                                         // reset
-                }
-          '{' field_declaration_list_opt '}'
-                { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, nullptr, $7, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list_opt '}' // CFA
                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
@@ -1853 +1811 @@
 
 aggregate_type_nobody:                                                                  // struct, union - {...}
-        aggregate_key attribute_list_opt no_attr_identifier fred
-                {
-                        typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname );
-                        //if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
+        aggregate_key attribute_list_opt no_attr_identifier
+                {
+                        typedefTable.makeTypedef( *$3 );
+                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
                 }
-        | aggregate_key attribute_list_opt type_name fred
+        | aggregate_key attribute_list_opt TYPEDEFname
+                {
+                        typedefTable.makeTypedef( *$3 );
+                        $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
+                }
+        | aggregate_key attribute_list_opt typegen_name         // CFA
                 {
                         // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
@@ -1874 +1837 @@
 aggregate_key:
         STRUCT
-                { yyy = true; $$ = DeclarationNode::Struct; }
+                { $$ = DeclarationNode::Struct; }
         | UNION
-                { yyy = true; $$ = DeclarationNode::Union; }
+                { $$ = DeclarationNode::Union; }
         | EXCEPTION
-                { yyy = true; $$ = DeclarationNode::Exception; }
+                { $$ = DeclarationNode::Exception; }
         | COROUTINE
-                { yyy = true; $$ = DeclarationNode::Coroutine; }
+                { $$ = DeclarationNode::Coroutine; }
         | MONITOR
-                { yyy = true; $$ = DeclarationNode::Monitor; }
+                { $$ = DeclarationNode::Monitor; }
         | THREAD
-                { yyy = true; $$ = DeclarationNode::Thread; }
+                { $$ = DeclarationNode::Thread; }
         ;
 
@@ -1895 +1858 @@
 
 field_declaration:
-        type_specifier field_declaring_list ';'
-                { $$ = distAttr( $1, $2 ); }
+        cfa_field_declaring_list ';'                                            // CFA, new style field declaration
+        | EXTENSION cfa_field_declaring_list ';'                        // GCC
+                {
+                        distExt( $2 );                                                          // mark all fields in list
+                        $$ = $2;
+                }
+        | type_specifier field_declaring_list ';'
+                {
+                        $$ = distAttr( $1, $2 ); }
         | EXTENSION type_specifier field_declaring_list ';'     // GCC
-                { distExt( $3 ); $$ = distAttr( $2, $3 ); }             // mark all fields in list
-        | typedef_declaration ';'                                                       // CFA
-                { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
-        | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
-        | EXTENSION cfa_field_declaring_list ';'                        // GCC
-                { distExt( $2 ); $$ = $2; }                                             // mark all fields in list
-        | cfa_typedef_declaration ';'                                           // CFA
-                { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
-        | static_assert                                                                         // C11
+                {
+                        distExt( $3 );                                                          // mark all fields in list
+                        $$ = distAttr( $2, $3 );
+                }
+        | static_assert
         ;
 
@@ -1945 +1911 @@
                 { $$ = nullptr; }
         | bit_subrange_size
+                { $$ = $1; }
         ;
 
@@ -1955 +1922 @@
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
-        | ENUM attribute_list_opt no_attr_identifier
+        | ENUM attribute_list_opt no_attr_identifier_or_type_name
                 { typedefTable.makeTypedef( *$3 ); }
           '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
-        | ENUM attribute_list_opt type_name
-          '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3->type->symbolic.name, $5, true )->addQualifiers( $2 ); }
         | enum_type_nobody
         ;
 
 enum_type_nobody:                                                                               // enum - {...}
-        ENUM attribute_list_opt no_attr_identifier
+        ENUM attribute_list_opt no_attr_identifier_or_type_name
                 {
                         typedefTable.makeTypedef( *$3 );
                         $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 );
-                }
-        | ENUM attribute_list_opt type_name
-                {
-                        typedefTable.makeTypedef( *$3->type->symbolic.name );
-                        $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 );
                 }
         ;
@@ -1992 +1951 @@
         ;
 
-cfa_parameter_ellipsis_list_opt:                                                        // CFA, abstract + real
+cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
         // empty
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
@@ -2125 +2084 @@
                 { $$ = $2; }
         | '=' VOID
-                { $$ = new InitializerNode( true ); }
+                { $$ = nullptr; }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }
@@ -2202 +2161 @@
 type_parameter_list:                                                                    // CFA
         type_parameter
+                { $$ = $1; }
         | type_parameter_list ',' type_parameter
                 { $$ = $1->appendList( $3 ); }
@@ -2215 +2175 @@
 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 ); }
@@ -2249 +2209 @@
         '|' 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; }
         ;
 
@@ -2284 +2244 @@
         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 ')' '{' push 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 ';'
         ;
 
@@ -2329 +2289 @@
 
 translation_unit:
-        // empty, input file
+        // empty
+                {}                                                                                              // empty input file
         | external_definition_list
                 { parseTree = parseTree ? parseTree->appendList( $1 ) : $1;     }
@@ -2335 +2296 @@
 
 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; }
         ;
@@ -2349 +2309 @@
         ;
 
-up:
-                { typedefTable.up(); }
-        ;
-
-down:
-                { typedefTable.down(); }
-        ;
-
 external_definition:
         declaration
         | external_function_definition
+        | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
+                {
+                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
+                }
+        | EXTERN STRINGliteral                                                          // C++-style linkage specifier
+                {
+                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
+                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
+                }
+          '{' external_definition_list_opt '}'
+                {
+                        linkage = linkageStack.top();
+                        linkageStack.pop();
+                        $$ = $5;
+                }
         | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
                 {
@@ -2365 +2332 @@
                         $$ = $2;
                 }
-        | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
-                {
-                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
-                }
-        | EXTERN STRINGliteral                                                          // C++-style linkage specifier
-                {
-                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
-                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
-                }
-          '{' up external_definition_list_opt down '}'
-                {
-                        linkage = linkageStack.top();
-                        linkageStack.pop();
-                        $$ = $6;
-                }
         | type_qualifier_list
-                {
-                        if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
-                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
-                }
-          '{' up external_definition_list_opt down '}'          // CFA, namespace
+                { 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() ) {
@@ -2397 +2346 @@
                 }
         | declaration_qualifier_list
-                {
-                        if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
-                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
-                }
-          '{' up external_definition_list_opt down '}'          // CFA, namespace
+                { 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() ) {
@@ -2414 +2360 @@
         | declaration_qualifier_list type_qualifier_list
                 {
-                        if ( ($1->type && $1->type->qualifiers.val) || $2->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
-                        if ( ($1->type && $1->type->forall) || $2->type->forall ) xxx = forall = true; // remember generic type
-                }
-          '{' up external_definition_list_opt down '}'          // CFA, namespace
+                        // forall must be in the type_qualifier_list
+                        if ( $2->type->forall ) xxx = forall = true; // remember generic type
+                }
+          push '{' external_definition_list '}'                         // CFA, namespace
                 {
                         for ( DeclarationNode * iter = $6; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
@@ -2441 +2387 @@
         | function_declarator compound_statement
                 { $$ = $1->addFunctionBody( $2 ); }
-        | KR_function_declarator KR_parameter_list_opt compound_statement
+        | KR_function_declarator KR_declaration_list_opt compound_statement
                 { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
         ;
@@ -2481 +2427 @@
 
                 // 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 );
@@ -2487 +2433 @@
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
-        | type_qualifier_list KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
+        | type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
                 { $$ = $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
+        | declaration_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
                 { $$ = $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
+        | 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 ); }
         ;
@@ -2738 +2684 @@
         typedef
                 // hide type name in enclosing scope by variable name
-                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" ); }
+                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER ); }
         | '(' paren_type ')'
                 { $$ = $2; }
@@ -3028 +2974 @@
         '[' ']'
                 { $$ = DeclarationNode::newArray( 0, 0, false ); }
-                // multi_array_dimension handles the '[' '*' ']' case
+        // 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
+        // multi_array_dimension handles the '[' assignment_expression ']' case
         | '[' push type_qualifier_list assignment_expression pop ']'
                 { $$ = DeclarationNode::newArray( $4, $3, false ); }
@@ -3169 +3115 @@
 //
 //              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:
@@ -3228 +3174 @@
         '[' 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_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 ')'
+        cfa_abstract_tuple '(' push cfa_parameter_type_list_opt pop ')'
                 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
-        | cfa_function_return '(' push cfa_parameter_ellipsis_list_opt pop ')'
+        | cfa_function_return '(' push cfa_parameter_type_list_opt pop ')'
                 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
         ;
@@ -3270 +3212 @@
 
 %%
-
 // ----end of grammar----