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

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 : Wed Jun 22 21:20:17 2016
-// Update Count     : 1584
+// Last Modified On : Mon Jun 27 17:47:56 2016
+// Update Count     : 1627
 //
 
@@ -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 type_redeclarator typedef_type_specifier
+%type<decl> type_parameter_redeclarator type_ptr variable_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 the context because it results in a commom user error: subscripting a
+                // CFA, comma_expression disallowed in this context because it results in a common 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 no_attr_identifier                                                     // GCC, address of label
-                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
+//      | ANDAND 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 ); }
         ;
 
@@ -651 +653 @@
 
 labeled_statement:
-        no_attr_identifier ':' attribute_list_opt statement
+                // labels cannot be identifiers 0 or 1
+        IDENTIFIER ':' attribute_list_opt statement
                 {
                         $$ = $4->add_label( $1 );
@@ -804 +807 @@
 
 jump_statement:
-        GOTO no_attr_identifier ';'
+        GOTO IDENTIFIER ';'
                 { $$ = new StatementNode( StatementNode::Goto, $2 ); }
         | GOTO '*' comma_expression ';'                                         // GCC, computed goto
@@ -813 +816 @@
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( StatementNode::Continue ); }
-        | CONTINUE no_attr_identifier ';'                                       // CFA, multi-level continue
+        | CONTINUE 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.
@@ -820 +823 @@
                 // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
                 { $$ = new StatementNode( StatementNode::Break ); }
-        | BREAK no_attr_identifier ';'                                          // CFA, multi-level exit
+        | BREAK 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.
@@ -1500 +1503 @@
                 // A semantic check is required to ensure bit_subrange only appears on base type int.
                 { $$ = $1->addBitfield( $2 ); }
-        | type_redeclarator bit_subrange_size_opt
+        | 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 ); }
@@ -1744 +1747 @@
 
 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 ) ); }
@@ -1994 +1997 @@
         function_definition
                 // These rules are a concession to the "implicit int" type_specifier because there is a significant amount of
-                // 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)
+                // 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)
         | function_declarator compound_statement
                 {
@@ -2074 +2078 @@
 declarator:
         variable_declarator
+        | variable_type_redeclarator
         | function_declarator
-        | type_redeclarator
         ;
 
@@ -2201 +2205 @@
         ;
 
-// 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.
+// 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.
 
 function_declarator:
@@ -2288 +2291 @@
 // and functions versus pointers to arrays and functions.
 
-type_redeclarator:
+variable_type_redeclarator:
         paren_type attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
@@ -2305 +2308 @@
 
 type_ptr:
-        ptrref_operator type_redeclarator
+        ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
-        | ptrref_operator type_qualifier_list type_redeclarator
+        | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
         | '(' type_ptr ')'
@@ -2390 +2393 @@
 //              not as redundant parentheses around the identifier."
 //
-// which precludes the following cases:
+// For example:
 //
 //              typedef float T;