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

File:

• src/Parser/parser.yy (modified) (55 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 : Thu May 24 18:11:59 2018
-// Update Count     : 3369
+// Last Modified On : Fri Jun 22 13:59:11 2018
+// Update Count     : 3586
 //
 
@@ -136 +136 @@
 } // build_postfix_name
 
-bool forall = false, xxx = false;                                               // aggregate have one or more forall qualifiers ?
+bool forall = false, xxx = false, yyy = 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;
 }
 
@@ -259 +260 @@
 %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
+%type<sn> selection_statement                   if_statement
 %type<sn> switch_clause_list_opt                switch_clause_list
 %type<en> case_value
@@ -302 +304 @@
 %type<en> enumerator_value_opt
 
-%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
+%type<decl> external_definition external_definition_list external_definition_list_opt
+
+%type<decl> exception_declaration
 
 %type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
@@ -324 +328 @@
 %type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
 
-%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt
+%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_ellipsis_list_opt
 
 %type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
@@ -330 +334 @@
 %type<decl> c_declaration static_assert
 %type<decl> KR_function_declarator KR_function_no_ptr KR_function_ptr KR_function_array
-%type<decl> KR_declaration_list KR_declaration_list_opt
+%type<decl> KR_parameter_list KR_parameter_list_opt
 
 %type<decl> parameter_declaration parameter_list parameter_type_list_opt
@@ -402 +406 @@
 //************************* Namespace Management ********************************
 
-// 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.
+// 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
 
 push:
@@ -497 +505 @@
                 { $$ = 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; }
+                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = nullptr; }
         | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = 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) } } ); }
         ;
 
@@ -623 +648 @@
                 // semantics checks, e.g., ++3, 3--, *3, &&3
         | constant
-                { $$ = $1; }
         | string_literal
                 { $$ = new ExpressionNode( $1 ); }
@@ -835 +859 @@
 //      '[' ']'
 //              { $$ = new ExpressionNode( build_tuple() ); }
-//      '[' push assignment_expression pop ']'
+//      | '[' push assignment_expression pop ']'
 //              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
-        '[' push ',' tuple_expression_list pop ']'
-                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $4 ) ) ); }
-        | '[' push assignment_expression ',' tuple_expression_list pop ']'
-                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $5 ) ) ); }
+        '[' ',' tuple_expression_list ']'
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
+        | '[' push assignment_expression pop ',' tuple_expression_list ']'
+                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $6 ) ) ); }
         ;
 
@@ -892 +916 @@
         '{' '}'
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
-        | '{'
-                // Two scopes are necessary because the block itself has a scope, but every declaration within the block also
-                // requires its own scope.
-          push push
+        | '{' push
           local_label_declaration_opt                                           // GCC, local labels
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
-                { $$ = new StatementNode( build_compound( $5 ) ); }
+                { $$ = new StatementNode( build_compound( $4 ) ); }
         ;
 
 statement_decl_list:                                                                    // C99
         statement_decl
-        | statement_decl_list push statement_decl
-                { if ( $1 != 0 ) { $1->set_last( $3 ); $$ = $1; } }
+        | statement_decl_list statement_decl
+                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
         ;
 
@@ -923 +944 @@
                         $$ = new StatementNode( $2 );
                 }
-        | statement pop
+        | statement
         ;
 
@@ -938 +959 @@
 
 selection_statement:
-        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 ) ); }
+                        // 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; }
         | SWITCH '(' comma_expression ')' case_clause
                 { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
-        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
+        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
                 {
                         StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
@@ -957 +977 @@
         | CHOOSE '(' comma_expression ')' case_clause           // CFA
                 { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
-        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
+        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt pop '}' // CFA
                 {
                         StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
@@ -964 +984 @@
         ;
 
+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 pop
+        comma_expression
                 { $$ = new IfCtl( nullptr, $1 ); }
-        | c_declaration pop                                                                     // no semi-colon
+        | c_declaration                                                                         // no semi-colon
                 { $$ = new IfCtl( $1, nullptr ); }
-        | cfa_declaration pop                                                           // no semi-colon
+        | cfa_declaration                                                                       // no semi-colon
                 { $$ = new IfCtl( $1, nullptr ); }
         | declaration comma_expression                                          // semi-colon separated
@@ -1026 +1054 @@
 
 iteration_statement:
-        WHILE '(' comma_expression ')' statement
-                { $$ = new StatementNode( build_while( $3, $5 ) ); }
+        WHILE '(' push if_control_expression ')' statement pop
+                { $$ = new StatementNode( build_while( $4, $6 ) ); }
         | DO statement WHILE '(' comma_expression ')' ';'
-                { $$ = new StatementNode( build_while( $5, $2, true ) ); }
-        | FOR '(' push for_control_expression ')' statement
+                { $$ = new StatementNode( build_do_while( $5, $2 ) ); }
+        | FOR '(' push for_control_expression ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
         ;
 
 for_control_expression:
-        comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtl( $1, $4, $6 ); }
+        comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtl( $1, $3, $5 ); }
         | declaration comma_expression_opt ';' comma_expression_opt // C99
                 { $$ = new ForCtl( $1, $2, $4 ); }
@@ -1158 +1186 @@
 
 handler_clause:
-        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 ) ) ); }
+        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 ) ) ); }
         ;
 
@@ -1265 +1293 @@
 
 declaration_list_opt:                                                                   // used at beginning of switch statement
-        pop     // empty
+        // empty
                 { $$ = nullptr; }
         | declaration_list
@@ -1272 +1300 @@
 declaration_list:
         declaration
-        | declaration_list push declaration
-                { $$ = $1->appendList( $3 ); }
-        ;
-
-KR_declaration_list_opt:                                                                // used to declare parameter types in K&R style functions
+        | declaration_list declaration
+                { $$ = $1->appendList( $2 ); }
+        ;
+
+KR_parameter_list_opt:                                                                  // used to declare parameter types in K&R style functions
         // empty
                 { $$ = nullptr; }
-        | KR_declaration_list
-        ;
-
-KR_declaration_list:
+        | KR_parameter_list
+        ;
+
+KR_parameter_list:
         push c_declaration pop ';'
                 { $$ = $2; }
-        | KR_declaration_list push c_declaration pop ';'
+        | KR_parameter_list push c_declaration pop ';'
                 { $$ = $1->appendList( $3 ); }
         ;
@@ -1305 +1333 @@
 
 declaration:                                                                                    // old & new style declarations
-        c_declaration pop ';'
-        | cfa_declaration pop ';'                                                       // CFA
-        | static_assert
+        c_declaration ';'
+        | cfa_declaration ';'                                                           // CFA
+        | static_assert                                                                         // C11
         ;
 
@@ -1313 +1341 @@
         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
@@ -1357 +1387 @@
 cfa_function_declaration:                                                               // CFA
         cfa_function_specifier
-                { $$ = $1; }
         | type_qualifier_list cfa_function_specifier
                 { $$ = $2->addQualifiers( $1 ); }
@@ -1364 +1393 @@
         | declaration_qualifier_list type_qualifier_list cfa_function_specifier
                 { $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); }
-        | cfa_function_declaration ',' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+        | cfa_function_declaration ',' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
                 {
                         // Append the return type at the start (left-hand-side) to each identifier in the list.
                         DeclarationNode * ret = new DeclarationNode;
                         ret->type = maybeClone( $1->type->base );
-                        $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $5, nullptr ) );
+                        $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $6, nullptr ) );
                 }
         ;
 
 cfa_function_specifier:                                                                 // CFA
-//      '[' ']' identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')' // S/R conflict
+//      '[' ']' identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')' // S/R conflict
 //              {
 //                      $$ = DeclarationNode::newFunction( $3, DeclarationNode::newTuple( 0 ), $6, 0, true );
 //              }
-//      '[' ']' identifier '(' push cfa_parameter_type_list_opt pop ')'
+//      '[' ']' identifier '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
 //                      $$ = DeclarationNode::newFunction( $5, DeclarationNode::newTuple( 0 ), $8, 0, true );
 //              }
-//      | '[' ']' TYPEDEFname '(' push cfa_parameter_type_list_opt pop ')'
+//      | '[' ']' TYPEDEFname '(' push cfa_parameter_ellipsis_list_opt pop ')'
 //              {
 //                      typedefTable.setNextIdentifier( *$5 );
@@ -1391 +1420 @@
                 // identifier_or_type_name must be broken apart because of the sequence:
                 //
-                //   '[' ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+                //   '[' ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')'
                 //   '[' ']' type_specifier
                 //
                 // type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be
                 // flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name.
-        cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
+        cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
-        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
+        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_ellipsis_list_opt pop ')'
                 { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
         ;
@@ -1414 +1443 @@
         TYPEDEF cfa_variable_specifier
                 {
-                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "1" );
                         $$ = $2->addTypedef();
                 }
         | TYPEDEF cfa_function_specifier
                 {
-                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname, "2" );
                         $$ = $2->addTypedef();
                 }
         | cfa_typedef_declaration pop ',' push no_attr_identifier
                 {
-                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "3" );
                         $$ = $1->appendList( $1->cloneType( $5 ) );
                 }
@@ -1435 +1464 @@
         TYPEDEF type_specifier declarator
                 {
-                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
                         $$ = $3->addType( $2 )->addTypedef();
                 }
         | typedef_declaration pop ',' push declarator
                 {
-                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "5" );
                         $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
                 }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
                 {
-                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
                         $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
                 }
         | type_specifier TYPEDEF declarator
                 {
-                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
                         $$ = $3->addType( $1 )->addTypedef();
                 }
         | type_specifier TYPEDEF type_qualifier_list declarator
                 {
-                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
                         $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
                 }
@@ -1582 +1611 @@
 
 forall:
-        FORALL '(' push type_parameter_list pop ')'                                     // CFA
-                { $$ = DeclarationNode::newForall( $4 ); }
+        FORALL '(' type_parameter_list ')'                                      // CFA
+                { $$ = DeclarationNode::newForall( $3 ); }
         ;
 
@@ -1765 +1794 @@
                 { $$ = DeclarationNode::newFromTypedef( $1 ); }
         | '.' TYPEDEFname
-                { $$ = DeclarationNode::newFromTypedef( $2 ); } // FIX ME
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | type_name '.' TYPEDEFname
-                { $$ = DeclarationNode::newFromTypedef( $3 ); } // FIX ME
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | typegen_name
         | '.' typegen_name
-                { $$ = $2; }                                                                    // FIX ME
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | type_name '.' typegen_name
-                { $$ = $3; }                                                                    // FIX ME
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -1794 +1823 @@
         ;
 
+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_or_type_name
-                {
-                        typedefTable.makeTypedef( *$3 );                        // create typedef
-                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
+        | 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
                         forall = false;                                                         // reset
                 }
           '{' field_declaration_list_opt '}'
-                { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
+                { $$ = 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 ); }
         | 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 ); }
@@ -1811 +1853 @@
 
 aggregate_type_nobody:                                                                  // struct, union - {...}
-        aggregate_key attribute_list_opt no_attr_identifier
-                {
-                        typedefTable.makeTypedef( *$3 );
-                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
+        aggregate_key attribute_list_opt no_attr_identifier fred
+                {
+                        typedefTable.makeTypedef( *$3, forall ? TYPEGENname : TYPEDEFname );
+                        //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 TYPEDEFname
-                {
-                        typedefTable.makeTypedef( *$3 );
-                        $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
-                }
-        | aggregate_key attribute_list_opt typegen_name         // CFA
+        | aggregate_key attribute_list_opt type_name fred
                 {
                         // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
@@ -1837 +1874 @@
 aggregate_key:
         STRUCT
-                { $$ = DeclarationNode::Struct; }
+                { yyy = true; $$ = DeclarationNode::Struct; }
         | UNION
-                { $$ = DeclarationNode::Union; }
+                { yyy = true; $$ = DeclarationNode::Union; }
         | EXCEPTION
-                { $$ = DeclarationNode::Exception; }
+                { yyy = true; $$ = DeclarationNode::Exception; }
         | COROUTINE
-                { $$ = DeclarationNode::Coroutine; }
+                { yyy = true; $$ = DeclarationNode::Coroutine; }
         | MONITOR
-                { $$ = DeclarationNode::Monitor; }
+                { yyy = true; $$ = DeclarationNode::Monitor; }
         | THREAD
-                { $$ = DeclarationNode::Thread; }
+                { yyy = true; $$ = DeclarationNode::Thread; }
         ;
 
@@ -1858 +1895 @@
 
 field_declaration:
-        cfa_field_declaring_list ';'                                            // CFA, new style field declaration
+        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 );                                                          // mark all fields in list
-                        $$ = $2;
-                }
-        | type_specifier field_declaring_list ';'
-                {
-                        $$ = distAttr( $1, $2 ); }
-        | EXTENSION type_specifier field_declaring_list ';'     // GCC
-                {
-                        distExt( $3 );                                                          // mark all fields in list
-                        $$ = distAttr( $2, $3 );
-                }
-        | static_assert
+                { distExt( $2 ); $$ = $2; }                                             // mark all fields in list
+        | cfa_typedef_declaration ';'                                           // CFA
+                { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
+        | static_assert                                                                         // C11
         ;
 
@@ -1911 +1945 @@
                 { $$ = nullptr; }
         | bit_subrange_size
-                { $$ = $1; }
         ;
 
@@ -1922 +1955 @@
         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_or_type_name
+        | ENUM attribute_list_opt no_attr_identifier
                 { 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_or_type_name
+        ENUM attribute_list_opt no_attr_identifier
                 {
                         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 );
                 }
         ;
@@ -1951 +1992 @@
         ;
 
-cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
+cfa_parameter_ellipsis_list_opt:                                                        // CFA, abstract + real
         // empty
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
@@ -2084 +2125 @@
                 { $$ = $2; }
         | '=' VOID
-                { $$ = nullptr; }
+                { $$ = new InitializerNode( true ); }
         | ATassign initializer
                 { $$ = $2->set_maybeConstructed( false ); }
@@ -2161 +2202 @@
 type_parameter_list:                                                                    // CFA
         type_parameter
-                { $$ = $1; }
         | type_parameter_list ',' type_parameter
                 { $$ = $1->appendList( $3 ); }
@@ -2175 +2215 @@
 type_parameter:                                                                                 // CFA
         type_class no_attr_identifier_or_type_name
-                { typedefTable.addToEnclosingScope( *$2, TYPEDEFname ); }
+                { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); }
           type_initializer_opt assertion_list_opt
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
@@ -2209 +2249 @@
         '|' no_attr_identifier_or_type_name '(' type_list ')'
                 { $$ = DeclarationNode::newTraitUse( $2, $4 ); }
-        | '|' '{' push trait_declaration_list '}'
+        | '|' '{' push trait_declaration_list pop '}'
                 { $$ = $4; }
-        | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
-                { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
+        // | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list pop '}' '(' type_list ')'
+        //      { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
         ;
 
@@ -2244 +2284 @@
         no_attr_identifier_or_type_name
                 {
-                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname );
+                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname, "10" );
                         $$ = DeclarationNode::newTypeDecl( $1, 0 );
                 }
-        | no_attr_identifier_or_type_name '(' push type_parameter_list pop ')'
-                {
-                        typedefTable.addToEnclosingScope( *$1, TYPEGENname );
-                        $$ = DeclarationNode::newTypeDecl( $1, $4 );
+        | no_attr_identifier_or_type_name '(' type_parameter_list ')'
+                {
+                        typedefTable.addToEnclosingScope( *$1, TYPEGENname, "11" );
+                        $$ = DeclarationNode::newTypeDecl( $1, $3 );
                 }
         ;
 
 trait_specifier:                                                                                // CFA
-        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 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_declaration_list:                                                                 // CFA
         trait_declaration
-        | trait_declaration_list push trait_declaration
-                { $$ = $1->appendList( $3 ); }
+        | trait_declaration_list pop push trait_declaration
+                { $$ = $1->appendList( $4 ); }
         ;
 
 trait_declaration:                                                                              // CFA
-        cfa_trait_declaring_list pop ';'
-        | trait_declaring_list pop ';'
+        cfa_trait_declaring_list ';'
+        | trait_declaring_list ';'
         ;
 
@@ -2289 +2329 @@
 
 translation_unit:
-        // empty
-                {}                                                                                              // empty input file
+        // empty, input file
         | external_definition_list
                 { parseTree = parseTree ? parseTree->appendList( $1 ) : $1;     }
@@ -2296 +2335 @@
 
 external_definition_list:
-        external_definition
+        push external_definition pop
+                { $$ = $2; }
         | external_definition_list
                 { forall = xxx; }
-          push external_definition
+          push external_definition pop
                 { $$ = $1 ? $1->appendList( $4 ) : $4; }
         ;
@@ -2309 +2349 @@
         ;
 
+up:
+                { typedefTable.up(); }
+        ;
+
+down:
+                { typedefTable.down(); }
+        ;
+
 external_definition:
         declaration
         | external_function_definition
+        | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
+                {
+                        distExt( $2 );                                                          // mark all fields in list
+                        $$ = $2;
+                }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
                 {
@@ -2321 +2374 @@
                         linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
                 }
-          '{' external_definition_list_opt '}'
+          '{' up external_definition_list_opt down '}'
                 {
                         linkage = linkageStack.top();
                         linkageStack.pop();
-                        $$ = $5;
-                }
-        | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
-                {
-                        distExt( $2 );                                                          // mark all fields in list
-                        $$ = $2;
+                        $$ = $6;
                 }
         | type_qualifier_list
-                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
-          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        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
                 {
                         for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
@@ -2346 +2397 @@
                 }
         | declaration_qualifier_list
-                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
-          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        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
                 {
                         for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
@@ -2360 +2414 @@
         | declaration_qualifier_list type_qualifier_list
                 {
-                        // forall must be in the type_qualifier_list
-                        if ( $2->type->forall ) xxx = forall = true; // remember generic type
-                }
-          push '{' external_definition_list '}'                         // CFA, namespace
+                        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
                 {
                         for ( DeclarationNode * iter = $6; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
@@ -2387 +2441 @@
         | function_declarator compound_statement
                 { $$ = $1->addFunctionBody( $2 ); }
-        | KR_function_declarator KR_declaration_list_opt compound_statement
+        | KR_function_declarator KR_parameter_list_opt compound_statement
                 { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
         ;
@@ -2427 +2481 @@
 
                 // Old-style K&R function definition, OBSOLESCENT (see 4)
-        | declaration_specifier KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
+        | declaration_specifier KR_function_declarator KR_parameter_list_opt with_clause_opt compound_statement
                 {
                         rebindForall( $1, $2 );
@@ -2433 +2487 @@
                 }
                 // handles default int return type, OBSOLESCENT (see 1)
-        | type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
+        | type_qualifier_list KR_function_declarator KR_parameter_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_declaration_list_opt with_clause_opt compound_statement
+        | declaration_qualifier_list KR_function_declarator KR_parameter_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_declaration_list_opt with_clause_opt compound_statement
+        | 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 ); }
         ;
@@ -2684 +2738 @@
         typedef
                 // hide type name in enclosing scope by variable name
-                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER ); }
+                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" ); }
         | '(' paren_type ')'
                 { $$ = $2; }
@@ -2974 +3028 @@
         '[' ']'
                 { $$ = 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 ); }
@@ -3115 +3169 @@
 //
 //              cfa_abstract_tuple identifier_or_type_name
-//              '[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+//              '[' cfa_parameter_list ']' identifier_or_type_name '(' cfa_parameter_ellipsis_list_opt ')'
 //
 // since a function return type can be syntactically identical to a tuple type:
@@ -3174 +3228 @@
         '[' 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_type_list_opt ')'
+//      '[' ']' '(' cfa_parameter_ellipsis_list_opt ')'
 //              { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
-        cfa_abstract_tuple '(' push cfa_parameter_type_list_opt pop ')'
+        cfa_abstract_tuple '(' push cfa_parameter_ellipsis_list_opt pop ')'
                 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
-        | cfa_function_return '(' push cfa_parameter_type_list_opt pop ')'
+        | cfa_function_return '(' push cfa_parameter_ellipsis_list_opt pop ')'
                 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
         ;
@@ -3212 +3270 @@
 
 %%
+
 // ----end of grammar----