Changeset 679e644 for src/Parser/parser.yy

Timestamp:

Jul 19, 2018, 10:30:56 AM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

679a260

Parents:

2f84692

Message:

extend plan 9, anonymous declarations, change token for default argument

File:

• src/Parser/parser.yy (modified) (12 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 Jul 12 16:16:25 2018
-// Update Count     : 3756
+// Last Modified On : Thu Jul 19 10:21:43 2018
+// Update Count     : 3808
 //
 
@@ -338 +338 @@
 %type<decl> exception_declaration
 
-%type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
-%type<en> field field_list field_name fraction_constants_opt
+%type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list field_abstract_opt
+%type<en> field field_name_list field_name fraction_constants_opt
 
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
@@ -352 +352 @@
 %type<decl> cfa_array_parameter_1st_dimension
 
-%type<decl> cfa_trait_declaring_list cfa_declaration cfa_field_declaring_list
+%type<decl> cfa_trait_declaring_list cfa_declaration cfa_field_declaring_list cfa_field_abstract_list
 %type<decl> cfa_function_declaration cfa_function_return cfa_function_specifier
 
@@ -492 +492 @@
         ;
 
-identifier:
-        IDENTIFIER
-        | ATTR_IDENTIFIER                                                                       // CFA
-        | quasi_keyword
-        ;
-
 no_attr_identifier:
         IDENTIFIER
         | quasi_keyword
+        | '@'                                                                                           // CFA
+                { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
+        ;
+
+identifier:
+        no_attr_identifier
+        | ATTR_IDENTIFIER                                                                       // CFA
         ;
 
@@ -541 +542 @@
         | type_name '.' no_attr_identifier                                      // CFA, nested type
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
-        | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
+        | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
                 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
@@ -594 +595 @@
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
-        | postfix_expression '.' '[' field_list ']'                     // CFA, tuple field selector
+        | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
@@ -602 +603 @@
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
-        | postfix_expression ARROW '[' field_list ']'           // CFA, tuple field selector
+        | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ICR
@@ -629 +630 @@
         // empty
                 { $$ = nullptr; }
-        // | '@'                                                                                                // use default argument
-        //      { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
+        | '?'                                                                                           // CFA, default parameter
+                { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
+                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
         | assignment_expression
         ;
 
-field_list:                                                                                             // CFA, tuple field selector
+field_name_list:                                                                                // CFA, tuple field selector
         field
-        | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_last( $3 ); }
+        | field_name_list ',' field                                     { $$ = (ExpressionNode *)$1->set_last( $3 ); }
         ;
 
@@ -643 +645 @@
         | FLOATING_DECIMALconstant field
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
-        | FLOATING_DECIMALconstant '[' field_list ']'
+        | FLOATING_DECIMALconstant '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
-        | field_name '.' '[' field_list ']'
+        | field_name '.' '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | field_name ARROW field
                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
-        | field_name ARROW '[' field_list ']'
+        | field_name ARROW '[' field_name_list ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         ;
@@ -1932 +1934 @@
 
 field_declaration:
-        type_specifier field_declaring_list ';'
-                { $$ = distAttr( $1, $2 ); }
-        | EXTENSION type_specifier field_declaring_list ';'     // GCC
-                { distExt( $3 ); $$ = distAttr( $2, $3 ); }             // mark all fields in list
-        | INLINE type_specifier field_declaring_list ';'        // CFA
-                {
-                        if ( $2->type && ( $2->type->kind == TypeData::Aggregate || $2->type->kind == TypeData::AggregateInst ) ) {
-                                if ( $2->type->kind == TypeData::Aggregate ) {
-                                        $2->type->aggregate.inLine = true;
-                                } else {
-                                        $2->type->aggInst.inLine = true;
-                                } // if
-                                $$ = distAttr( $2, $3 );
+        type_specifier field_declaring_list_opt ';'
+                {
+                        if ( $2 ) {                                                                     // field declarator ?
+                                $$ = distAttr( $1, $2 );
+                        } else if ( $1->type && $1->type->kind == TypeData::Aggregate && $1->type->aggregate.anon ) {
+                                $$ = DeclarationNode::newName( nullptr );
+                                $$ = distAttr( $1, $$ );                                // mark all fields in list
                         } else {
-                                SemanticError( yylloc, "inline qualifier only allowed for aggregate field declarations." ); $$ = nullptr;
-                        } // if 
+                                //SemanticError( yylloc, "Superfluous declaration, does not allocate storage." ); $$ = nullptr;
+                                SemanticWarning( yylloc, Warning::SuperfluousDecl, "" );
+                        } // if
+                }
+        | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
+                {
+                        if ( $3 ) {                                                                     // field declarator ?
+                                $$ = distAttr( $2, $3 );                                // mark all fields in list
+                                distExt( $3 );
+                        } else if ( $2->type && $2->type->kind == TypeData::Aggregate && $2->type->aggregate.anon ) {
+                                $$ = DeclarationNode::newName( nullptr );
+                                $$ = distAttr( $2, $$ );                                // mark all fields in list
+                                distExt( $$ );
+                        } else {
+                                // SemanticError( yylloc, "Superfluous declaration, does not allocate storage." ); $$ = nullptr;
+                                SemanticWarning( yylloc, Warning::SuperfluousDecl, "" );
+                        } // if
+                }
+        | INLINE type_specifier field_abstract_list ';'         // CFA
+                {
+                        $2->inLine = true;
+                        $$ = distAttr( $2, $3 );                                        // mark all fields in list
                 }
         | typedef_declaration ';'                                                       // CFA
@@ -1953 +1969 @@
         | EXTENSION cfa_field_declaring_list ';'                        // GCC
                 { distExt( $2 ); $$ = $2; }                                             // mark all fields in list
+        | INLINE cfa_field_abstract_list ';'                            // CFA, new style field declaration
+                { $$ = $2; }                                                                    // mark all fields in list
         | cfa_typedef_declaration ';'                                           // CFA
         | static_assert                                                                         // C11
         ;
 
+field_declaring_list_opt:
+        // empty
+                { $$ = nullptr; }
+        | field_declarator
+        | field_declaring_list_opt ',' attribute_list_opt field_declarator
+                { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
+        ;
+
+field_declarator:
+        bit_subrange_size                                                                       // no field name
+                { $$ = DeclarationNode::newBitfield( $1 ); }
+        | variable_declarator bit_subrange_size_opt
+                // A semantic check is required to ensure bit_subrange only appears on integral types.
+                { $$ = $1->addBitfield( $2 ); }
+        | variable_type_redeclarator bit_subrange_size_opt
+                // A semantic check is required to ensure bit_subrange only appears on integral types.
+                { $$ = $1->addBitfield( $2 ); }
+        ;
+
+field_abstract_list:
+        field_abstract_opt
+        | field_abstract_list ',' attribute_list_opt field_abstract_opt
+                { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
+        ;
+
+field_abstract_opt:
+        // empty
+                { $$ = DeclarationNode::newName( nullptr ); }
+        | bit_subrange_size                                                                     // no field name
+                // A semantic check is required to ensure bit_subrange only appears on integral types.
+                { $$ = DeclarationNode::newBitfield( $1 ); }
+        | variable_abstract_declarator
+        ;
+
 cfa_field_declaring_list:                                                               // CFA, new style field declaration
-        cfa_abstract_declarator_tuple                                           // CFA, no field name
-        | cfa_abstract_declarator_tuple no_attr_identifier_or_type_name
+        cfa_abstract_declarator_tuple no_attr_identifier_or_type_name
                 { $$ = $1->addName( $2 ); }
         | cfa_field_declaring_list ',' no_attr_identifier_or_type_name
                 { $$ = $1->appendList( $1->cloneType( $3 ) ); }
-        | cfa_field_declaring_list ','                                          // CFA, no field name
+        ;
+
+cfa_field_abstract_list:                                                                // CFA, new style field declaration
+        cfa_abstract_declarator_tuple
+        | cfa_field_abstract_list ','
                 { $$ = $1->appendList( $1->cloneType( 0 ) ); }
-        ;
-
-field_declaring_list:
-        field_declarator_opt
-        | field_declaring_list ',' attribute_list_opt field_declarator_opt
-                { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
-        ;
-
-field_declarator_opt:
-        // empty
-                { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
-        // '@'
-        //      { $$ = DeclarationNode::newName( new string( DeclarationNode::anonymous.newName() ) ); } // CFA, no field name
-        | bit_subrange_size                                                                     // no field name
-                { $$ = DeclarationNode::newBitfield( $1 ); }
-        | variable_declarator bit_subrange_size_opt
-                // A semantic check is required to ensure bit_subrange only appears on base type int.
-                { $$ = $1->addBitfield( $2 ); }
-        | variable_type_redeclarator bit_subrange_size_opt
-                // A semantic check is required to ensure bit_subrange only appears on base type int.
-                { $$ = $1->addBitfield( $2 ); }
-        | variable_abstract_declarator                                          // CFA, no field name
         ;
 
@@ -2226 +2259 @@
         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); }
-        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
+        | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
                 { $$ = $4; }
         ;