Changes in src/Parser/parser.yy [d63aeba:9fa61f5]

File:

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

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 22 21:26:01 2023
-// Update Count     : 6002
+// Last Modified On : Tue Mar 14 09:37:58 2023
+// Update Count     : 5990
 //
 
@@ -270 +270 @@
         SemanticError( yylloc, ::toString( "Identifier \"", identifier, "\" cannot appear before a ", kind, ".\n"
                                    "Possible cause is misspelled storage/CV qualifier, misspelled typename, or missing generic parameter." ) );
-} // IdentifierBeforeType
-
-static bool TypedefForall( DeclarationNode * decl ) {
-        if ( decl->type->forall || (decl->type->kind == TypeData::Aggregate && decl->type->aggregate.params) ) {
-                SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." );
-                return true;
-        } // if
-        return false;
 } // IdentifierBeforeType
 
@@ -504 +496 @@
 %type<decl> typedef_name typedef_declaration typedef_expression
 
-%type<decl> variable_type_redeclarator variable_type_ptr variable_type_array variable_type_function
-%type<decl> general_function_declarator function_type_redeclarator function_type_array function_type_no_ptr function_type_ptr
+%type<decl> variable_type_redeclarator type_ptr type_array type_function
 
 %type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
@@ -1966 +1957 @@
         TYPEDEF type_specifier declarator
                 {
+                        // if type_specifier is an anon aggregate => name 
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
-                        if ( TypedefForall( $2 ) ) $$ = nullptr;
-                        else $$ = $3->addType( $2 )->addTypedef();              // watchout frees $2 and $3
+                        $$ = $3->addType( $2 )->addTypedef();           // watchout frees $2 and $3
                 }
         | typedef_declaration pop ',' push declarator
@@ -1978 +1969 @@
                 {
                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
-                        if ( TypedefForall( $1 ) ) $$ = nullptr;
-                        else $$ = $4->addQualifiers( $1 )->addType( $3 )->addTypedef();
+                        $$ = $4->addQualifiers( $1 )->addType( $3 )->addTypedef();
                 }
         | type_specifier TYPEDEF declarator
                 {
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
-                        if ( TypedefForall( $1 ) ) $$ = nullptr;
-                        else $$ = $3->addType( $1 )->addTypedef();
+                        $$ = $3->addType( $1 )->addTypedef();
                 }
         | type_specifier TYPEDEF type_qualifier_list declarator
                 {
                         typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
-                        if ( TypedefForall( $3 ) ) $$ = nullptr;
-                        else $$ = $4->addQualifiers( $1 )->addType( $1 )->addTypedef();
+                        $$ = $4->addQualifiers( $1 )->addType( $1 )->addTypedef();
                 }
         ;
@@ -2028 +2016 @@
                 // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
                 // storage-class
-        variable_declarator asm_name_opt initializer_opt
+        declarator asm_name_opt initializer_opt
                 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
-        | variable_type_redeclarator asm_name_opt initializer_opt
-                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
-
-        | general_function_declarator asm_name_opt
-                { $$ = $1->addAsmName( $2 )->addInitializer( nullptr ); }
-        | general_function_declarator asm_name_opt '=' VOID
-                { $$ = $1->addAsmName( $2 )->addInitializer( new InitializerNode( true ) ); }
-
         | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
                 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
-        ;
-
-general_function_declarator:
-        function_type_redeclarator
-        | function_declarator
         ;
 
@@ -2568 +2543 @@
                 // A semantic check is required to ensure bit_subrange only appears on integral types.
                 { $$ = $1->addBitfield( $2 ); }
-        | function_type_redeclarator bit_subrange_size_opt
-                // A semantic check is required to ensure bit_subrange only appears on integral types.
-                { $$ = $1->addBitfield( $2 ); }
         ;
 
@@ -3223 +3195 @@
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
                 }
-        | declaration_specifier function_type_redeclarator with_clause_opt compound_statement
+        | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
                 {
                         rebindForall( $1, $2 );
@@ -3259 +3231 @@
         | variable_type_redeclarator
         | function_declarator
-        | function_type_redeclarator
         ;
 
@@ -3510 +3481 @@
         ;
 
-// This pattern parses a declaration for a variable that redefines a type name, e.g.:
+// This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
 //
 //              typedef int foo;
@@ -3516 +3487 @@
 //                 int foo; // redefine typedef name in new scope
 //              }
+//
+// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
+// and functions versus pointers to arrays and functions.
 
 paren_type:
@@ -3530 +3504 @@
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
-        | variable_type_ptr
-        | variable_type_array attribute_list_opt
+        | type_ptr
+        | type_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
-        | variable_type_function attribute_list_opt
+        | type_function attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         ;
 
-variable_type_ptr:
+type_ptr:
         ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' variable_type_ptr ')' attribute_list_opt          // redundant parenthesis
+        | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
-        | '(' attribute_list variable_type_ptr ')' attribute_list_opt // redundant parenthesis
+        | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
         ;
 
-variable_type_array:
+type_array:
         paren_type array_dimension
                 { $$ = $1->addArray( $2 ); }
-        | '(' variable_type_ptr ')' array_dimension
+        | '(' type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list variable_type_ptr ')' array_dimension
+        | '(' attribute_list type_ptr ')' array_dimension
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' variable_type_array ')' multi_array_dimension     // redundant parenthesis
+        | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list variable_type_array ')' multi_array_dimension // redundant parenthesis
+        | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' variable_type_array ')'                                           // redundant parenthesis
+        | '(' type_array ')'                                                            // redundant parenthesis
                 { $$ = $2; }
-        | '(' attribute_list variable_type_array ')'            // redundant parenthesis
+        | '(' attribute_list type_array ')'                                     // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
         ;
 
-variable_type_function:
-        '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
-                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
-        | '(' variable_type_function ')'                                        // redundant parenthesis
-                { $$ = $2; }
-        | '(' attribute_list variable_type_function ')'         // redundant parenthesis
-                { $$ = $3->addQualifiers( $2 ); }
-        ;
-
-// This pattern parses a declaration for a function prototype that redefines a type name.  It precludes declaring an
-// array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
-// arrays and functions.
-
-function_type_redeclarator:
-        function_type_no_ptr attribute_list_opt
-                { $$ = $1->addQualifiers( $2 ); }
-        | function_type_ptr
-        | function_type_array attribute_list_opt
-                { $$ = $1->addQualifiers( $2 ); }
-        ;
-
-function_type_no_ptr:
+type_function:
         paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
-        | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
+        | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $2->addParamList( $6 ); }
-        | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
+        | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
-        | '(' function_type_no_ptr ')'                                          // redundant parenthesis
+        | '(' type_function ')'                                                         // redundant parenthesis
                 { $$ = $2; }
-        | '(' attribute_list function_type_no_ptr ')'           // redundant parenthesis
-                { $$ = $3->addQualifiers( $2 ); }
-        ;
-
-function_type_ptr:
-        ptrref_operator function_type_redeclarator
-                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
-        | ptrref_operator type_qualifier_list function_type_redeclarator
-                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
-        | '(' function_type_ptr ')' attribute_list_opt
-                { $$ = $2->addQualifiers( $4 ); }
-        | '(' attribute_list function_type_ptr ')' attribute_list_opt
-                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
-        ;
-
-function_type_array:
-        '(' function_type_ptr ')' array_dimension
-                { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list function_type_ptr ')' array_dimension
-                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' function_type_array ')' multi_array_dimension     // redundant parenthesis
-                { $$ = $2->addArray( $4 ); }
-        | '(' attribute_list function_type_array ')' multi_array_dimension // redundant parenthesis
-                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
-        | '(' function_type_array ')'                                           // redundant parenthesis
-                { $$ = $2; }
-        | '(' attribute_list function_type_array ')'            // redundant parenthesis
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
                 { $$ = $3->addQualifiers( $2 ); }
         ;