Changes in src/Parser/parser.yy [9a705dc8:1dbc8590]

File:

• src/Parser/parser.yy (modified) (18 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 : Tue Apr 17 17:10:30 2018
-// Update Count     : 3144
+// Last Modified On : Fri May 11 17:51:38 2018
+// Update Count     : 3261
 //
 
@@ -133 +133 @@
 } // build_postfix_name
 
-bool forall = 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
@@ -208 +208 @@
 %token<tok> ATTR_IDENTIFIER             ATTR_TYPEDEFname                ATTR_TYPEGENname
 %token<tok> INTEGERconstant             CHARACTERconstant               STRINGliteral
+%token<tok> DIRECTIVE
 // Floating point constant is broken into three kinds of tokens because of the ambiguity with tuple indexing and
 // overloading constants 0/1, e.g., x.1 is lexed as (x)(.1), where (.1) is a factional constant, but is semantically
@@ -282 +283 @@
 %type<decl> aggregate_type aggregate_type_nobody
 
-%type<decl> assertion assertion_list_opt
+%type<decl> assertion assertion_list assertion_list_opt
 
 %type<en>   bit_subrange_size_opt bit_subrange_size
@@ -301 +302 @@
 
 %type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
-%type<en> field field_list field_name fraction_constants
+%type<en> field field_list field_name fraction_constants_opt
 
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
@@ -498 +499 @@
         | type_name '.' no_attr_identifier                                      // CFA, nested type
                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
+//              { $$ = nullptr; }
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
+//              { $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
                 { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
@@ -532 +535 @@
         | postfix_expression '.' no_attr_identifier
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
+        | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
+        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
-        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
                 {
                         $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
                 }
-        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
-                        { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
+        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
@@ -596 +601 @@
 
 field_name:
-        INTEGERconstant fraction_constants
+        INTEGERconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
-        | FLOATINGconstant fraction_constants
+        | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
-        | no_attr_identifier fraction_constants
+        | no_attr_identifier fraction_constants_opt
                 {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
@@ -606 +611 @@
         ;
 
-fraction_constants:
+fraction_constants_opt:
         // empty
                 { $$ = nullptr; }
-        | fraction_constants FLOATING_FRACTIONconstant
+        | fraction_constants_opt FLOATING_FRACTIONconstant
                 {
                         Expression * constant = build_field_name_FLOATING_FRACTIONconstant( *$2 );
@@ -875 +880 @@
                 { SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; }
         | asm_statement
+        | DIRECTIVE
+                { $$ = new StatementNode( build_directive( $1 ) ); }
         ;
 
@@ -1204 +1211 @@
 asm_statement:
         ASM asm_volatile_opt '(' string_literal ')' ';'
-                { $$ = new StatementNode( build_asmstmt( $2, $4, 0 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, 0 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ')' ';' // remaining GCC
-                { $$ = new StatementNode( build_asmstmt( $2, $4, $6 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ')' ';'
-                { $$ = new StatementNode( build_asmstmt( $2, $4, $6, $8 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6, $8 ) ); }
         | ASM asm_volatile_opt '(' string_literal ':' asm_operands_opt ':' asm_operands_opt ':' asm_clobbers_list_opt ')' ';'
-                { $$ = new StatementNode( build_asmstmt( $2, $4, $6, $8, $10 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $4, $6, $8, $10 ) ); }
         | ASM asm_volatile_opt GOTO '(' string_literal ':' ':' asm_operands_opt ':' asm_clobbers_list_opt ':' label_list ')' ';'
-                { $$ = new StatementNode( build_asmstmt( $2, $5, 0, $8, $10, $12 ) ); }
+                { $$ = new StatementNode( build_asm( $2, $5, 0, $8, $10, $12 ) ); }
         ;
 
@@ -1866 +1873 @@
                 {
                         typedefTable.makeTypedef( *$3 );
+                        if ( forall ) typedefTable.changeKind( *$3, TypedefTable::TG ); // possibly update
+                        forall = false;                                                         // reset
                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
                 }
@@ -2235 +2244 @@
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
         | type_specifier identifier_parameter_declarator
+        | assertion_list
+                { $$ = DeclarationNode::newTypeParam( DeclarationNode::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
         ;
 
@@ -2251 +2262 @@
         // empty
                 { $$ = nullptr; }
-        | assertion_list_opt assertion
+        | assertion_list
+        ;
+
+assertion_list:                                                                                 // CFA
+        assertion
+        | assertion_list assertion
                 { $$ = $1 ? $1->appendList( $2 ) : $2; }
         ;
@@ -2378 +2394 @@
 external_definition_list:
         external_definition
-        | external_definition_list push external_definition
-                { $$ = $1 ? $1->appendList( $3 ) : $3; }
+        | external_definition_list
+                { forall = xxx; }
+          push external_definition
+                { $$ = $1 ? $1->appendList( $4 ) : $4; }
         ;
 
@@ -2393 +2411 @@
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
                 {
-                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asmstmt( false, $3, 0 ) ) );
+                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
                 }
         | EXTERN STRINGliteral                                                          // C++-style linkage specifier
@@ -2411 +2429 @@
                         $$ = $2;
                 }
-        | type_qualifier_list '{' external_definition_list '}'                  // CFA, namespace
+        | type_qualifier_list
+                {
+                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
+                }
+          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        for ( DeclarationNode * iter = $5; 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;
+                }
+        | declaration_qualifier_list
+                {
+                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
+                }
+          push '{' external_definition_list '}'                         // CFA, namespace
+                {
+                        for ( DeclarationNode * iter = $5; 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;
+                }
+        | declaration_qualifier_list type_qualifier_list
+                {
+                        // forall must be in the type_qualifier_list
+                        if ( $2->type->forall ) xxx = forall = true; // remember generic type
+                }
+          push '{' external_definition_list '}'                         // 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() );
+                                        iter->addQualifiers( $2->clone() );
+                                } // if
+                        } // for
+                        xxx = false;
+                        delete $1;
+                        delete $2;
+                        $$ = $6;
+                }
         ;
 
@@ -2437 +2502 @@
 with_clause_opt:
         // empty
-                { $$ = nullptr; }
+                { $$ = nullptr; forall = false; }
         | WITH '(' tuple_expression_list ')'
-                { $$ = $3; }
+                { $$ = $3; forall = false; }
         ;