Changeset d964c39 for src/Parser

Timestamp:

Feb 25, 2023, 6:45:44 PM (3 years ago)

Author:

caparson <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

601bd9e

Parents:

ce44c5f (diff), 2d028003 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (4 diffs)
• TypeData.h (modified) (2 diffs)
• parser.yy (modified) (17 diffs)

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 16 14:12:03 2023
-// Update Count     : 1388
+// Last Modified On : Sat Feb 25 12:15:40 2023
+// Update Count     : 1404
 //
 
@@ -254 +254 @@
         newnode->type->enumeration.typed = typed;
         newnode->type->enumeration.hiding = hiding;
-        if ( base && base->type)  {
+        if ( base && base->type )  {
                 newnode->type->base = base->type;
         } // if
@@ -567 +567 @@
 
         checkQualifiers( type, q->type );
-        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.val != 0 && error.length() == 0 ) {
-                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, Type::QualifiersNames[ilog2( q->type->qualifiers.val )], builtinTypeNames[builtin] );
+        if ( (builtin == Zero || builtin == One) && q->type->qualifiers.any() && error.length() == 0 ) {
+                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, builtinTypeNames[builtin] );
         } // if
         addQualifiersToType( q->type, type );
@@ -984 +984 @@
 
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
-                                // handle the case where a structure declaration is contained within an object or type declaration
+                                // Handle the case where a SUE declaration is contained within an object or type declaration.
+
+                                assert( cur->type );
+                                // Replace anonymous SUE name with typedef name to prevent anonymous naming problems across translation units.
+                                if ( cur->type->kind == TypeData::Symbolic && cur->type->symbolic.isTypedef ) {
+                                        assert( extr->type );
+                                        // Handle anonymous aggregates: typedef struct { int i; } foo
+                                        extr->type->qualifiers.reset();         // clear any CVs associated with the aggregate
+                                        if ( extr->type->kind == TypeData::Aggregate && extr->type->aggregate.anon ) {
+                                                delete extr->type->aggregate.name;
+                                                extr->type->aggregate.name = new string( "__anonymous_" + *cur->name );
+                                                extr->type->aggregate.anon = false;
+                                                assert( cur->type->base );
+                                                if ( cur->type->base ) {
+                                                        delete cur->type->base->aggInst.aggregate->aggregate.name;
+                                                        cur->type->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *cur->name );
+                                                        cur->type->base->aggInst.aggregate->aggregate.anon = false;
+                                                        cur->type->base->aggInst.aggregate->qualifiers.reset();
+                                                } // if
+                                        } // if
+                                        // Handle anonymous enumeration: typedef enum { A, B, C } foo
+                                        if ( extr->type->kind == TypeData::Enum && extr->type->enumeration.anon ) {
+                                                delete extr->type->enumeration.name;
+                                                extr->type->enumeration.name = new string( "__anonymous_" + *cur->name );
+                                                extr->type->enumeration.anon = false;
+                                                assert( cur->type->base );
+                                                if ( cur->type->base ) {
+                                                        delete cur->type->base->aggInst.aggregate->enumeration.name;
+                                                        cur->type->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *cur->name );
+                                                        cur->type->base->aggInst.aggregate->enumeration.anon = false;
+                                                } // if
+                                        } // if
+                                } // if
 
                                 Declaration * decl = extr->build();

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb 19 09:09:39 2023
-// Update Count     : 204
+// Last Modified On : Fri Feb 24 14:25:02 2023
+// Update Count     : 205
 //
 
@@ -41 +41 @@
         };
 
-        struct AggInst_t {
+        struct AggInst_t {                                                                      // handles SUE
                 TypeData * aggregate = nullptr;
                 ExpressionNode * params = nullptr;

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 : Sat Feb 25 13:23:16 2023
+// Update Count     : 5989
 //
 
@@ -1173 +1173 @@
         comma_expression_opt ';'
                 { $$ = new StatementNode( build_expr( $1 ) ); }
-        | MUTEX '(' ')' comma_expression ';'
-                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
         ;
 
@@ -1282 +1280 @@
                 {
                         $$ = new StatementNode( build_while( new CondCtl( nullptr, NEW_ONE ), maybe_build_compound( $4 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
@@ -1293 +1291 @@
                 {
                         $$ = new StatementNode( build_do_while( NEW_ONE, maybe_build_compound( $2 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
         | DO statement WHILE '(' comma_expression ')' ';'
@@ -1304 +1302 @@
                 {
                         $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
-                        SemanticWarning( yylloc, Warning::SuperfluousElse, "" );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
                 }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
@@ -1584 +1582 @@
         ;
 
-// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so possibly change syntax to "with mutex".
 mutex_statement:
-        MUTEX '(' argument_expression_list ')' statement
-                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        MUTEX '(' argument_expression_list_opt ')' statement
+                {
+                        if ( ! $3 ) { SemanticError( yylloc, "mutex argument list cannot be empty." ); $$ = nullptr; }
+                        $$ = new StatementNode( build_mutex( $3, $5 ) );
+                }
         ;
 
@@ -1941 +1942 @@
                         // 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 +1986 @@
                 {
                         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 +2011 @@
         | 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 +2592 @@
         | 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 +2603 @@
         | 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 );
                 }
@@ -2986 +2990 @@
         TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' '}'
                 {
-                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax, "" );
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
                         $$ = DeclarationNode::newTrait( $2, $4, nullptr );
                 }
@@ -2993 +2997 @@
         | TRAIT identifier_or_type_name '(' type_parameter_list ')' '{' push trait_declaration_list pop '}'
                 {
-                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax, "" );
+                        SemanticWarning( yylloc, Warning::DeprecTraitSyntax );
                         $$ = DeclarationNode::newTrait( $2, $4, $8 );
                 }
@@ -3058 +3062 @@
                 { $$ = 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 +3119 @@
         | 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 +3130 @@
         | 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 +3141 @@
         | 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
                 }