Changeset c653b37 for src/Parser/parser.yy

Timestamp:

Jun 28, 2018, 4:04:11 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

e3b2474

Parents:

a12c81f3 (diff), 944ce47 (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:/u/cforall/software/cfa/cfa-cc

File:

• src/Parser/parser.yy (modified) (13 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 Jun  7 10:07:12 2018
-// Update Count     : 3527
+// Last Modified On : Sun Jun 24 10:41:10 2018
+// Update Count     : 3587
 //
 
@@ -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
@@ -304 +304 @@
 %type<en> enumerator_value_opt
 
-%type<decl> exception_declaration external_definition external_definition_list external_definition_list_no_pop_push 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
@@ -503 +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; }
-                { $$ = nullptr; }
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
-                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
-                { $$ = nullptr; }
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
                 {
@@ -1821 +1821 @@
         ;
 
+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
+        | 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 ); }
-        | aggregate_key attribute_list_opt type_name
+                { $$ = 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, $6, true )->addQualifiers( $2 ); }
+                { $$ = 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 ); }
@@ -1846 +1849 @@
 
 aggregate_type_nobody:                                                                  // struct, union - {...}
-        aggregate_key attribute_list_opt no_attr_identifier
+        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 type_name
+        | aggregate_key attribute_list_opt type_name fred
                 {
                         // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
@@ -1867 +1869 @@
 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; }
         ;
 
@@ -2320 +2322 @@
 
 translation_unit:
-        // empty
-                {}                                                                                              // empty input file
+        // empty, input file
         | external_definition_list
                 { parseTree = parseTree ? parseTree->appendList( $1 ) : $1;     }
@@ -2335 +2336 @@
         ;
 
-        // SKULLDUGGERY: Declarations in extern "X" and distribution need to be added to the current lexical scope.
-        // However, external_definition_list creates a new scope around each external_definition, but the pop loses all the
-        // types in the extern "X" and distribution at the end of the block. This version of external_definition_list does
-
-        // not do push/pop for declarations at the level of the extern "X" and distribution block. Any recursive uses of
-        // external_definition_list within the extern "X" and distribution block correctly pushes/pops for that scope level.
-external_definition_list_no_pop_push:
-        external_definition
-        | external_definition_list_no_pop_push
-                { forall = xxx; }
-          external_definition
-                { $$ = $1 ? $1->appendList( $3 ) : $3; }
-        ;
-
 external_definition_list_opt:
         // empty
                 { $$ = nullptr; }
-        | external_definition_list_no_pop_push
+        | external_definition_list
+        ;
+
+up:
+                { typedefTable.up(); }
+        ;
+
+down:
+                { typedefTable.down(); }
         ;
 
@@ -2372 +2367 @@
                         linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
                 }
-          '{' external_definition_list_opt '}'
+          '{' up external_definition_list_opt down '}'
                 {
                         linkage = linkageStack.top();
                         linkageStack.pop();
-                        $$ = $5;
+                        $$ = $6;
                 }
         | type_qualifier_list
-                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
-          '{' external_definition_list_opt '}'                          // CFA, namespace
-                {
-                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+                {
+                        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() ) {
                                 if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
                                         iter->addQualifiers( $1->clone() );
@@ -2389 +2387 @@
                         xxx = false;
                         delete $1;
-                        $$ = $4;
+                        $$ = $5;
                 }
         | declaration_qualifier_list
-                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
-          '{' external_definition_list_opt '}'                          // CFA, namespace
-                {
-                        for ( DeclarationNode * iter = $4; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+                {
+                        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() ) {
                                 if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
                                         iter->addQualifiers( $1->clone() );
@@ -2402 +2403 @@
                         xxx = false;
                         delete $1;
-                        $$ = $4;
+                        $$ = $5;
                 }
         | declaration_qualifier_list type_qualifier_list
                 {
-                        // forall must be in the type_qualifier_list
-                        if ( $2->type->forall ) xxx = forall = true; // remember generic type
-                }
-          '{' external_definition_list_opt '}'                          // CFA, namespace
-                {
-                        for ( DeclarationNode * iter = $5; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
+                        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() ) {
                                 if ( isMangled( iter->linkage ) && isMangled( $2->linkage ) ) { // ignore extern "C"
                                         iter->addQualifiers( $1->clone() );
@@ -2420 +2421 @@
                         delete $1;
                         delete $2;
-                        $$ = $5;
+                        $$ = $6;
                 }
         ;