Changes in src/Parser/parser.yy [4c3ee8d:3fd8b0e]

File:

• src/Parser/parser.yy (modified) (15 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 Jul  2 20:23:14 2018
-// Update Count     : 3607
+// Last Modified On : Thu Jun  7 10:07:12 2018
+// Update Count     : 3527
 //
 
@@ -115 +115 @@
 } // distExt
 
-void distQual( DeclarationNode * declaration, DeclarationNode * qualifiers ) {
-        // distribute qualifiers across all declarations in a distribution statemement
-        for ( DeclarationNode * iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
-                if ( isMangled( iter->linkage ) ) {             // ignore extern "C"
-                        iter->addQualifiers( qualifiers->clone() );
-                } // if
-        } // for
-} // distExt
-
 // There is an ambiguity for inline generic-routine return-types and generic routines.
 //   forall( otype T ) struct S { int i; } bar( T ) {}
@@ -145 +136 @@
 } // build_postfix_name
 
-bool forall = false, xxx = false, yyy = false;                  // aggregate have one or more forall qualifiers ?
+bool forall = false, xxx = false;                                               // aggregate have one or more forall qualifiers ?
 
 // https://www.gnu.org/software/bison/manual/bison.html#Location-Type
@@ -313 +304 @@
 %type<en> enumerator_value_opt
 
-%type<decl> external_definition external_definition_list external_definition_list_opt
-
-%type<decl> exception_declaration
+%type<decl> exception_declaration external_definition external_definition_list external_definition_list_no_pop_push external_definition_list_opt
 
 %type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
@@ -514 +503 @@
                 { $$ = 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; }
+                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = nullptr; }
         | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                // { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
                 {
@@ -1145 +1136 @@
 
 waitfor:
-        WAITFOR '(' cast_expression ')'
-                { $$ = $3; }
-        | WAITFOR '(' cast_expression ',' argument_expression_list ')'
-                { $$ = (ExpressionNode *)$3->set_last( $5 ); }
+        WAITFOR '(' identifier ')'
+                {
+                        $$ = new ExpressionNode( new NameExpr( *$3 ) );
+                        delete $3;
+                }
+        | WAITFOR '(' identifier ',' argument_expression_list ')'
+                {
+                        $$ = new ExpressionNode( new NameExpr( *$3 ) );
+                        $$->set_last( $5 );
+                        delete $3;
+                }
         ;
 
@@ -1165 +1163 @@
                 { $$ = build_waitfor_timeout( nullptr, $3, $1 ); }
                 // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
-        | when_clause_opt timeout statement WOR ELSE statement
-                { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | when_clause_opt timeout statement WOR when_clause ELSE statement
                 { $$ = build_waitfor_timeout( $2, $3, $1, $7, $5 ); }
@@ -1796 +1792 @@
                 { $$ = DeclarationNode::newFromTypedef( $1 ); }
         | '.' TYPEDEFname
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), DeclarationNode::newFromTypedef( $2 ) ); }
         | type_name '.' TYPEDEFname
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newQualifiedType( $1, DeclarationNode::newFromTypedef( $3 ) ); }
         | typegen_name
         | '.' typegen_name
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newQualifiedType( DeclarationNode::newFromGlobalScope(), $2 ); }
         | type_name '.' typegen_name
-                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+                { $$ = DeclarationNode::newQualifiedType( $1, $3 ); }
         ;
 
@@ -1825 +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 fred
+        | aggregate_key attribute_list_opt no_attr_identifier
                 {
                         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, $7, true )->addQualifiers( $2 ); }
-        | aggregate_key attribute_list_opt type_name fred
+                { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
+        | aggregate_key attribute_list_opt type_name
                 {
                         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, $7, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, nullptr, $6, 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 ); }
@@ -1853 +1846 @@
 
 aggregate_type_nobody:                                                                  // struct, union - {...}
-        aggregate_key attribute_list_opt no_attr_identifier fred
+        aggregate_key attribute_list_opt no_attr_identifier
                 {
                         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 fred
+        | aggregate_key attribute_list_opt type_name
                 {
                         // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
@@ -1873 +1867 @@
 aggregate_key:
         STRUCT
-                { yyy = true; $$ = DeclarationNode::Struct; }
+                { $$ = DeclarationNode::Struct; }
         | UNION
-                { yyy = true; $$ = DeclarationNode::Union; }
+                { $$ = DeclarationNode::Union; }
         | EXCEPTION
-                { yyy = true; $$ = DeclarationNode::Exception; }
+                { $$ = DeclarationNode::Exception; }
         | COROUTINE
-                { yyy = true; $$ = DeclarationNode::Coroutine; }
+                { $$ = DeclarationNode::Coroutine; }
         | MONITOR
-                { yyy = true; $$ = DeclarationNode::Monitor; }
+                { $$ = DeclarationNode::Monitor; }
         | THREAD
-                { yyy = true; $$ = DeclarationNode::Thread; }
+                { $$ = DeclarationNode::Thread; }
         ;
 
@@ -1899 +1893 @@
                 { distExt( $3 ); $$ = distAttr( $2, $3 ); }             // mark all fields in list
         | typedef_declaration ';'                                                       // CFA
-                { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
         | cfa_field_declaring_list ';'                                          // CFA, new style field declaration
         | EXTENSION cfa_field_declaring_list ';'                        // GCC
                 { distExt( $2 ); $$ = $2; }                                             // mark all fields in list
         | cfa_typedef_declaration ';'                                           // CFA
-                { SemanticError( yylloc, "Typedef in aggregate is currently unimplemented." ); $$ = nullptr; }
         | static_assert                                                                         // C11
         ;
@@ -2328 +2320 @@
 
 translation_unit:
-        // empty, input file
+        // empty
+                {}                                                                                              // empty input file
         | external_definition_list
                 { parseTree = parseTree ? parseTree->appendList( $1 ) : $1;     }
@@ -2342 +2335 @@
         ;
 
+        // 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
-        ;
-
-up:
-                { typedefTable.up(); }
-        ;
-
-down:
-                { typedefTable.down(); }
+        | external_definition_list_no_pop_push
         ;
 
@@ -2373 +2372 @@
                         linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
                 }
-          '{' up external_definition_list_opt down '}'
+          '{' external_definition_list_opt '}'
                 {
                         linkage = linkageStack.top();
                         linkageStack.pop();
-                        $$ = $6;
+                        $$ = $5;
                 }
         | type_qualifier_list
-                {
-                        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
-                {
-                        distQual( $5, $1 );
+                { 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 ( isMangled( iter->linkage ) ) {             // ignore extern "C"
+                                        iter->addQualifiers( $1->clone() );
+                                } // if
+                        } // for
                         xxx = false;
                         delete $1;
-                        $$ = $5;
+                        $$ = $4;
                 }
         | 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->forall ) xxx = forall = true; // remember generic type
-                }
-          '{' up external_definition_list_opt down '}'          // CFA, namespace
-                {
-                        distQual( $5, $1 );
+                { 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 ( isMangled( iter->linkage ) ) {             // ignore extern "C"
+                                        iter->addQualifiers( $1->clone() );
+                                } // if
+                        } // for
                         xxx = false;
                         delete $1;
-                        $$ = $5;
+                        $$ = $4;
                 }
         | declaration_qualifier_list type_qualifier_list
                 {
-                        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
-                {
-                        distQual( $6, $2 );
-                        distQual( $6, $1 );
+                        // 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 ( isMangled( iter->linkage ) && isMangled( $2->linkage ) ) { // ignore extern "C"
+                                        iter->addQualifiers( $1->clone() );
+                                        iter->addQualifiers( $2->clone() );
+                                } // if
+                        } // for
                         xxx = false;
                         delete $1;
                         delete $2;
-                        $$ = $6;
+                        $$ = $5;
                 }
         ;