Changes in src/Parser/parser.yy [c6b1105:e7aed49]

File:

• src/Parser/parser.yy (modified) (19 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 Jun 27 17:47:56 2016
-// Update Count     : 1627
+// Last Modified On : Wed Jun 22 21:20:17 2016
+// Update Count     : 1584
 //
 
@@ -224 +224 @@
 %type<decl> typedef type_array typedef_declaration typedef_declaration_specifier typedef_expression
 %type<decl> type_function type_parameter_array type_parameter_function type_parameter_ptr
-%type<decl> type_parameter_redeclarator type_ptr variable_type_redeclarator typedef_type_specifier
+%type<decl> type_parameter_redeclarator type_ptr type_redeclarator typedef_type_specifier
 %type<decl> typegen_declaration_specifier typegen_type_specifier typegen_name
 
@@ -350 +350 @@
         primary_expression
         | postfix_expression '[' push assignment_expression pop ']'
-                // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
+                // CFA, comma_expression disallowed in the context because it results in a commom user error: subscripting a
                 // matrix with x[i,j] instead of x[i][j]. While this change is not backwards compatible, there seems to be
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
@@ -421 +421 @@
 unary_expression:
         postfix_expression
-                // first location where constant/string can have operator applied: sizeof 3/sizeof "abc" still requires
-                // semantics checks, e.g., ++3, 3--, *3, &&3
+        // first location where constant/string can have operator applied: sizeof 3/sizeof "abc" still requires semantics
+        // checks, e.g., ++3, 3--, *3, &&3
         | constant
                 { $$ = $1; }
@@ -431 +431 @@
         | ptrref_operator cast_expression                                       // CFA
                 { $$ = new CompositeExprNode( $1, $2 ); }
-                // '*' ('&') is separated from unary_operator because of shift/reduce conflict in:
-                //              { * X; }         // dereference X
-                //              { * int X; } // CFA declaration of pointer to int
+        // '*' ('&') is separated from unary_operator because of shift/reduce conflict in:
+        //              { * X; }         // dereference X
+        //              { * int X; } // CFA declaration of pointer to int
         | unary_operator cast_expression
                 { $$ = new CompositeExprNode( $1, $2 ); }
@@ -456 +456 @@
         | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( $3 ) ); }
-//      | ANDAND IDENTIFIER                                                                     // GCC, address of label
-//              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
+        | ANDAND no_attr_identifier                                                     // GCC, address of label
+                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
         ;
 
@@ -463 +463 @@
         '*'                                                                                     { $$ = new OperatorNode( OperatorNode::PointTo ); }
         | '&'                                                                           { $$ = new OperatorNode( OperatorNode::AddressOf ); }
-                // GCC, address of label must be handled by semantic check for ref,ref,label
-        | ANDAND                                                                        { $$ = new OperatorNode( OperatorNode::And ); }
         ;
 
@@ -653 +651 @@
 
 labeled_statement:
-                // labels cannot be identifiers 0 or 1
-        IDENTIFIER ':' attribute_list_opt statement
+        no_attr_identifier ':' attribute_list_opt statement
                 {
                         $$ = $4->add_label( $1 );
@@ -807 +804 @@
 
 jump_statement:
-        GOTO IDENTIFIER ';'
+        GOTO no_attr_identifier ';'
                 { $$ = new StatementNode( StatementNode::Goto, $2 ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
@@ -816 +813 @@
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( StatementNode::Continue ); }
-        | CONTINUE IDENTIFIER ';'                                       // CFA, multi-level continue
+        | CONTINUE no_attr_identifier ';'                                       // CFA, multi-level continue
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
@@ -823 +820 @@
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( StatementNode::Break ); }
-        | BREAK IDENTIFIER ';'                                          // CFA, multi-level exit
+        | BREAK no_attr_identifier ';'                                          // CFA, multi-level exit
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
                 // the target of the transfer appears only at the start of an iteration statement.
@@ -1503 +1500 @@
                 // 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
+        | type_redeclarator bit_subrange_size_opt
                 // A semantic check is required to ensure bit_subrange only appears on base type int.
                 { $$ = $1->addBitfield( $2 ); }
@@ -1747 +1744 @@
 
 designator:
-                // lexer ambiguity: designator ".0" is floating-point constant or designator for name 0 only ".0" and ".1"
-                // allowed => semantic check
+        // lexer ambiguity: designator ".0" is floating-point constant or designator for name 0
+        // only ".0" and ".1" allowed => semantic check
         FLOATINGconstant
                 { $$ = new DesignatorNode( new VarRefNode( $1 ) ); }
@@ -1997 +1994 @@
         function_definition
                 // These rules are a concession to the "implicit int" type_specifier because there is a significant amount of
-                // legacy code with global functions missing the type-specifier for the return type, and assuming "int".
-                // Parsing is possible because function_definition does not appear in the context of an expression (nested
-                // functions preclude this concession, i.e., all nested function must have a return type). A function prototype
-                // declaration must still have a type_specifier.  OBSOLESCENT (see 1)
+                // code with functions missing a type-specifier on the return type.  Parsing is possible because
+                // function_definition does not appear in the context of an expression (nested functions would preclude this
+                // concession). A function prototype declaration must still have a type_specifier.  OBSOLESCENT (see 1)
         | function_declarator compound_statement
                 {
@@ -2078 +2074 @@
 declarator:
         variable_declarator
-        | variable_type_redeclarator
         | function_declarator
+        | type_redeclarator
         ;
 
@@ -2205 +2201 @@
         ;
 
-// This pattern parses a function declarator that is not redefining a typedef name. For non-nested functions, there is
-// no context where a function definition can redefine a typedef name, i.e., the typedef and function name cannot exist
-// is the same scope.  The pattern precludes returning arrays and functions versus pointers to arrays and functions.
+// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot be nested,
+// there is no context where a function definition can redefine a typedef name. To allow nested functions requires
+// further separation of variable and function declarators in type_redeclarator.  The pattern precludes returning
+// arrays and functions versus pointers to arrays and functions.
 
 function_declarator:
@@ -2291 +2288 @@
 // and functions versus pointers to arrays and functions.
 
-variable_type_redeclarator:
+type_redeclarator:
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
@@ -2308 +2305 @@
 
 type_ptr:
-        ptrref_operator variable_type_redeclarator
+        ptrref_operator type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-        | ptrref_operator type_qualifier_list variable_type_redeclarator
+        | ptrref_operator type_qualifier_list type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
         | '(' type_ptr ')'
@@ -2393 +2390 @@
 //              not as redundant parentheses around the identifier."
 //
-// For example:
+// which precludes the following cases:
 //
 //              typedef float T;