Changeset 74ec742 for src/Parser/parser.yy

Timestamp:

May 20, 2022, 10:36:45 AM (4 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

25fa20a

Parents:

29d8c02 (diff), 7831e8fb (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

File:

• src/Parser/parser.yy (modified) (21 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 Mar 14 16:35:29 2022
-// Update Count     : 5276
+// Last Modified On : Sat May 14 09:16:22 2022
+// Update Count     : 5401
 //
 
@@ -54 +54 @@
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
+
+#include "SynTree/Attribute.h"     // for Attribute
 
 extern DeclarationNode * parseTree;
@@ -93 +95 @@
 } // appendStr
 
-DeclarationNode * distAttr( DeclarationNode * specifier, DeclarationNode * declList ) {
-        // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
-        DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
+DeclarationNode * distAttr( DeclarationNode * typeSpec, DeclarationNode * declList ) {
+        // distribute declaration_specifier across all declared variables, e.g., static, const, but not __attribute__.
+        assert( declList );
+//      printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout );
+        DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( typeSpec );
+//      printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout );
+//      cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name;
+
         for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
         declList->addType( cl );
+//      printf( "distAttr3 declList %p\n", declList ); declList->print( std::cout, 0 );
         return declList;
 } // distAttr
@@ -111 +119 @@
 
 void distInl( DeclarationNode * declaration ) {
-        // distribute EXTENSION across all declarations
+        // distribute INLINE across all declarations
         for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
                 iter->set_inLine( true );
@@ -171 +179 @@
                 if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) {
                         stringstream ss;
-                        typeSpec->type->print( ss );
+                        // printf( "fieldDecl1 typeSpec %p\n", typeSpec ); typeSpec->type->print( std::cout );
                         SemanticWarning( yylloc, Warning::SuperfluousDecl, ss.str().c_str() );
                         return nullptr;
                 } // if
+                // printf( "fieldDecl2 typeSpec %p\n", typeSpec ); typeSpec->type->print( std::cout );
                 fieldList = DeclarationNode::newName( nullptr );
         } // if
-        return distAttr( typeSpec, fieldList );                         // mark all fields in list
+//      return distAttr( typeSpec, fieldList );                         // mark all fields in list
+
+        // printf( "fieldDecl3 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout, 0 );
+        DeclarationNode * temp = distAttr( typeSpec, fieldList );                               // mark all fields in list
+        // printf( "fieldDecl4 temp %p\n", temp ); temp->print( std::cout, 0 );
+        return temp;
 } // fieldDecl
 
@@ -1221 +1235 @@
 
 iteration_statement:
-        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
+        WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | WHILE '(' ')' statement ELSE statement                        // CFA
+                {
+                        $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
@@ -1229 +1248 @@
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
-        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
+        | DO statement WHILE '(' ')' ELSE statement                     // CFA
+                {
+                        $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
+        | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
-        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
+        | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        | FOR '(' ')' statement ELSE statement                          // CFA
+                {
+                        $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
@@ -1605 +1634 @@
 declaration:                                                                                    // old & new style declarations
         c_declaration ';'
+                {
+                        // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | cfa_declaration ';'                                                           // CFA
         | static_assert                                                                         // C11
@@ -1810 +1845 @@
         basic_type_specifier
         | sue_type_specifier
+                {
+                        // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | type_type_specifier
         ;
@@ -2026 +2067 @@
 sue_declaration_specifier:                                                              // struct, union, enum + storage class + type specifier
         sue_type_specifier
+                {
+                        // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | declaration_qualifier_list sue_type_specifier
                 { $$ = $2->addQualifiers( $1 ); }
@@ -2036 +2083 @@
 sue_type_specifier:                                                                             // struct, union, enum + type specifier
         elaborated_type
+                {
+                        // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | type_qualifier_list
                 { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type
@@ -2108 +2161 @@
 elaborated_type:                                                                                // struct, union, enum
         aggregate_type
+                {
+                        // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | enum_type
         ;
@@ -2127 +2186 @@
                 }
           '{' field_declaration_list_opt '}' type_parameters_opt
-                { $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); }
+                {
+                        // printf( "aggregate_type1 %s\n", $3.str->c_str() );
+                        // if ( $2 )
+                        //      for ( Attribute * attr: reverseIterate( $2->attributes ) ) {
+                        //              printf( "copySpecifiers12 %s\n", attr->name.c_str() );
+                        //      } // for
+                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                        // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //      printf( "aggregate_type3 %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
                 {
@@ -2135 +2205 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2145 +2216 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2221 +2293 @@
 field_declaration:
         type_specifier field_declaring_list_opt ';'
-                { $$ = fieldDecl( $1, $2 ); }
+                {
+                        // printf( "type_specifier1 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        $$ = fieldDecl( $1, $2 );
+                        // printf( "type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
@@ -2303 +2382 @@
         ;
 
-enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );                                                                                         // enum
+enum_type:
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
@@ -2318 +2397 @@
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
-                        $$ = DeclarationNode::newEnum( nullptr, $7, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
-                }
-        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 )->addQualifiers( $5 );
+                }
+        | 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." ); }
@@ -2327 +2406 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        $$ = DeclarationNode::newEnum( $6, $10, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2333 +2412 @@
                         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." ); }
                         typedefTable.makeTypedef( *$6->name );
-                        $$ = DeclarationNode::newEnum( $6->name, $9, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | enum_type_nobody
@@ -2830 +2909 @@
         // empty
                 { $$ = nullptr; forall = false; }
-        | WITH '(' tuple_expression_list ')'
-                { $$ = $3; forall = false; }
+        | WITH '(' tuple_expression_list ')' attribute_list_opt
+                {
+                        $$ = $3; forall = false;
+                        if ( $5 ) {
+                                SemanticError( yylloc, "Attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." );
+                                $$ = nullptr;
+                        } // if
+                }
         ;