Changeset 1a73dbb

Timestamp:

Feb 24, 2023, 3:26:01 PM (14 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

f2a1cd2

Parents:

dc3c9b1

Message:

parser rejects useless type qualifier in empty declaration, and extern anonymous SUE declarations, switch from bitset val to any(), reset()

File:

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

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb 20 11:31:26 2023
-// Update Count     : 5896
+// Last Modified On : Fri Feb 24 14:46:55 2023
+// Update Count     : 5983
 //
 
@@ -1941 +1941 @@
                         // if type_specifier is an anon aggregate => name 
                         typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
-                        $$ = $3->addType( $2 )->addTypedef();
+                        $$ = $3->addType( $2 )->addTypedef();           // watchout frees $2 and $3
                 }
         | typedef_declaration pop ',' push declarator
@@ -1985 +1985 @@
                 {
                         assert( $1->type );
-                        if ( $1->type->qualifiers.val != 0 ) {
-                                SemanticError( yylloc, "Useless type qualifier in empty declaration." ); $$ = nullptr;
+                        if ( $1->type->qualifiers.any() ) {                     // CV qualifiers ?
+                                SemanticError( yylloc, "Useless type qualifier(s) in empty declaration." ); $$ = nullptr;
+                        }
+                        // enums are never empty declarations because there must have at least one enumeration.
+                        if ( $1->type->kind == TypeData::AggregateInst && $1->storageClasses.any() ) { // storage class ?
+                                SemanticError( yylloc, "Useless storage qualifier(s) in empty aggregate declaration." ); $$ = nullptr;
                         }
                 }
@@ -2006 +2010 @@
         | sue_declaration_specifier invalid_types
                 {
-                        SemanticError( yylloc,
-                                                  ::toString( "Missing ';' after end of ",
-                                                                          $1->type->enumeration.name ? "enum" : AggregateDecl::aggrString( $1->type->aggregate.kind ),
-                                                                          " declaration" ) );
+                        SemanticError( yylloc, ::toString( "Missing ';' after end of ",
+                                $1->type->enumeration.name ? "enum" : AggregateDecl::aggrString( $1->type->aggregate.kind ),
+                                " declaration" ) );
                         $$ = nullptr;
                 }
@@ -2588 +2591 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 )
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.any() )
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
@@ -2599 +2602 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6 );
                 }
@@ -3058 +3061 @@
                 { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
         | declaration
+                {
+                        // Variable declarations of anonymous types requires creating a unique type-name across multiple translation
+                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
+                        // disallowed at the moment.
+                        if ( $1->linkage == LinkageSpec::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
+                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
+                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
+                                } else if ( $1->type->aggInst.aggregate->aggregate.anon ) { // handles struct or union
+                                        SemanticError( yylloc, "extern anonymous struct/union is currently unimplemented." ); $$ = nullptr;
+                                }
+                        }
+                }
         | IDENTIFIER IDENTIFIER
                 { IdentifierBeforeIdentifier( *$1.str, *$2.str, " declaration" ); $$ = nullptr; }
@@ -3103 +3118 @@
         | type_qualifier_list
                 {
-                        if ( $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type->forall ) forall = true;          // remember generic type
                 }
@@ -3114 +3129 @@
         | declaration_qualifier_list
                 {
-                        if ( $1->type && $1->type->qualifiers.val ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( $1->type && $1->type->qualifiers.any() ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( $1->type && $1->type->forall ) forall = true; // remember generic type
                 }
@@ -3125 +3140 @@
         | declaration_qualifier_list type_qualifier_list
                 {
-                        if ( ($1->type && $1->type->qualifiers.val) || ($2->type && $2->type->qualifiers.val) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
+                        if ( ($1->type && $1->type->qualifiers.any()) || ($2->type && $2->type->qualifiers.any()) ) { SemanticError( yylloc, "CV qualifiers cannot be distributed; only storage-class and forall qualifiers." ); }
                         if ( ($1->type && $1->type->forall) || ($2->type && $2->type->forall) ) forall = true; // remember generic type
                 }