Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/parser.yy

    rc6b1105 r45161b4d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // cfa.y --
    8 //
     7// cfa.y -- 
     8// 
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jun 27 17:47:56 2016
    13 // Update Count     : 1627
    14 //
     12// Last Modified On : Wed Apr 13 16:58:43 2016
     13// Update Count     : 1519
     14// 
    1515
    1616// This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the C
    … …  
    3131// two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
    3232//
    33 // 1. designation with and without '=' (use ':' instead)
    34 // 2. attributes not allowed in parenthesis of declarator
     33// 1. nested functions
     34// 2. generalized lvalues
     35// 3. designation with and without '=' (use ':' instead)
     36// 4. attributes not allowed in parenthesis of declarator
    3537//
    3638// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
    … …  
    7779%token TYPEOF LABEL                                                                             // GCC
    7880%token ENUM STRUCT UNION
    79 %token OTYPE FTYPE DTYPE TRAIT                                                  // CFA
     81%token OTYPE FTYPE DTYPE TRAIT                                          // CFA
    8082%token SIZEOF OFFSETOF
    8183%token ATTRIBUTE EXTENSION                                                              // GCC
    … …  
    129131%type<constant> constant
    130132%type<en> tuple                                                 tuple_expression_list
    131 %type<en> ptrref_operator                               unary_operator                          assignment_operator
     133%type<en> unary_operator                                assignment_operator
    132134%type<en> primary_expression                    postfix_expression                      unary_expression
    133135%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
    … …  
    224226%type<decl> typedef type_array typedef_declaration typedef_declaration_specifier typedef_expression
    225227%type<decl> type_function type_parameter_array type_parameter_function type_parameter_ptr
    226 %type<decl> type_parameter_redeclarator type_ptr variable_type_redeclarator typedef_type_specifier
     228%type<decl> type_parameter_redeclarator type_ptr type_redeclarator typedef_type_specifier
    227229%type<decl> typegen_declaration_specifier typegen_type_specifier typegen_name
    228230
    … …  
    350352        primary_expression
    351353        | postfix_expression '[' push assignment_expression pop ']'
    352                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
     354                // CFA, comma_expression disallowed in the context because it results in a commom user error: subscripting a
    353355                // matrix with x[i,j] instead of x[i][j]. While this change is not backwards compatible, there seems to be
    354356                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    … …  
    421423unary_expression:
    422424        postfix_expression
    423                 // first location where constant/string can have operator applied: sizeof 3/sizeof "abc" still requires
    424                 // semantics checks, e.g., ++3, 3--, *3, &&3
     425        // first location where constant/string can have operator applied: sizeof 3/sizeof "abc"
     426        // still requires semantics checks, e.g., ++3, 3--, *3, &&3
    425427        | constant
    426428                { $$ = $1; }
    427429        | string_literal_list
    428430                { $$ = $1; }
    429         | EXTENSION cast_expression                                                     // GCC
    430                 { $$ = $2->set_extension( true ); }
    431         | ptrref_operator cast_expression                                       // CFA
    432                 { $$ = new CompositeExprNode( $1, $2 ); }
    433                 // '*' ('&') is separated from unary_operator because of shift/reduce conflict in:
    434                 //              { * X; }         // dereference X
    435                 //              { * int X; } // CFA declaration of pointer to int
    436         | unary_operator cast_expression
    437                 { $$ = new CompositeExprNode( $1, $2 ); }
    438431        | ICR unary_expression
    439432                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), $2 ); }
    440433        | DECR unary_expression
    441434                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), $2 ); }
     435        | EXTENSION cast_expression                                                     // GCC
     436                { $$ = $2; }
     437        | unary_operator cast_expression
     438                { $$ = new CompositeExprNode( $1, $2 ); }
     439        | '!' cast_expression
     440                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Neg ), $2 ); }
     441        | '*' cast_expression                                                           // CFA
     442                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PointTo ), $2 ); }
     443                // '*' is is separated from unary_operator because of shift/reduce conflict in:
     444                //              { * X; } // dereference X
     445                //              { * int X; } // CFA declaration of pointer to int
     446                // '&' must be moved here if C++ reference variables are supported.
    442447        | SIZEOF unary_expression
    443448                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), $2 ); }
    … …  
    456461        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
    457462                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( $3 ) ); }
    458 //      | ANDAND IDENTIFIER                                                                     // GCC, address of label
    459 //              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
    460         ;
    461 
    462 ptrref_operator:
    463         '*'                                                                                     { $$ = new OperatorNode( OperatorNode::PointTo ); }
    464         | '&'                                                                           { $$ = new OperatorNode( OperatorNode::AddressOf ); }
    465                 // GCC, address of label must be handled by semantic check for ref,ref,label
    466         | ANDAND                                                                        { $$ = new OperatorNode( OperatorNode::And ); }
     463        | ANDAND no_attr_identifier                                                     // GCC, address of label
     464                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
    467465        ;
    468466
    469467unary_operator:
    470         '+'                                                                                     { $$ = new OperatorNode( OperatorNode::UnPlus ); }
     468        '&'                                                                                     { $$ = new OperatorNode( OperatorNode::AddressOf ); }
     469        | '+'                                                                           { $$ = new OperatorNode( OperatorNode::UnPlus ); }
    471470        | '-'                                                                           { $$ = new OperatorNode( OperatorNode::UnMinus ); }
    472         | '!'                                                                           { $$ = new OperatorNode( OperatorNode::Neg ); }
    473471        | '~'                                                                           { $$ = new OperatorNode( OperatorNode::BitNeg ); }
    474472        ;
    … …  
    648646                        Token fn; fn.str = new std::string( "^?{}" ); // location undefined
    649647                        $$ = new StatementNode( StatementNode::Exp, new CompositeExprNode( new VarRefNode( fn ),
    650                                 (ExpressionNode *)( $2 )->set_link( $4 ) ), 0 );
     648                                (ExpressionNode *)(new CompositeExprNode( new OperatorNode( OperatorNode::AddressOf ), $2 ))->set_link( $4 ) ), 0 );
    651649                }
    652650        ;
    653651
    654652labeled_statement:
    655                 // labels cannot be identifiers 0 or 1
    656         IDENTIFIER ':' attribute_list_opt statement
     653        no_attr_identifier ':' attribute_list_opt statement
    657654                {
    658655                        $$ = $4->add_label( $1 );
    … …  
    682679                { $$ = new StatementNode( $1 ); }
    683680        | EXTENSION declaration                                                         // GCC
    684                 { $$ = new StatementNode( $2 )/*->set_extension( true )*/; }
     681                { $$ = new StatementNode( $2 ); }
    685682        | function_definition
    686683                { $$ = new StatementNode( $1 ); }
    … …  
    807804
    808805jump_statement:
    809         GOTO IDENTIFIER ';'
     806        GOTO no_attr_identifier ';'
    810807                { $$ = new StatementNode( StatementNode::Goto, $2 ); }
    811808        | GOTO '*' comma_expression ';'                                         // GCC, computed goto
    … …  
    816813                // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
    817814                { $$ = new StatementNode( StatementNode::Continue ); }
    818         | CONTINUE IDENTIFIER ';'                                       // CFA, multi-level continue
     815        | CONTINUE no_attr_identifier ';'                                       // CFA, multi-level continue
    819816                // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
    820817                // the target of the transfer appears only at the start of an iteration statement.
    … …  
    823820                // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
    824821                { $$ = new StatementNode( StatementNode::Break ); }
    825         | BREAK IDENTIFIER ';'                                          // CFA, multi-level exit
     822        | BREAK no_attr_identifier ';'                                          // CFA, multi-level exit
    826823                // A semantic check is required to ensure this statement appears only in the body of an iteration statement, and
    827824                // the target of the transfer appears only at the start of an iteration statement.
    … …  
    14721469        new_field_declaring_list ';'                                            // CFA, new style field declaration
    14731470        | EXTENSION new_field_declaring_list ';'                        // GCC
    1474                 { $$ = $2/*->set_extension( true )*/; }
     1471                { $$ = $2; }
    14751472        | field_declaring_list ';'
    14761473        | EXTENSION field_declaring_list ';'                            // GCC
    1477                 { $$ = $2/*->set_extension( true )*/; }
     1474                { $$ = $2; }
    14781475        ;
    14791476
    … …  
    15031500                // A semantic check is required to ensure bit_subrange only appears on base type int.
    15041501                { $$ = $1->addBitfield( $2 ); }
    1505         | variable_type_redeclarator bit_subrange_size_opt
     1502        | type_redeclarator bit_subrange_size_opt
    15061503                // A semantic check is required to ensure bit_subrange only appears on base type int.
    15071504                { $$ = $1->addBitfield( $2 ); }
    … …  
    17051702                { $$ = $2; }
    17061703        | ATassign initializer
    1707                 { $$ = $2->set_maybeConstructed( false ); }
     1704                { $$ = $2; }
    17081705        ;
    17091706
    … …  
    17471744
    17481745designator:
    1749                 // lexer ambiguity: designator ".0" is floating-point constant or designator for name 0 only ".0" and ".1"
    1750                 // allowed => semantic check
     1746        // lexer ambiguity: designator ".0" is floating-point constant or designator for name 0
     1747        // only ".0" and ".1" allowed => semantic check
    17511748        FLOATINGconstant
    17521749                { $$ = new DesignatorNode( new VarRefNode( $1 ) ); }
    … …  
    19911988                }
    19921989        | EXTENSION external_definition
    1993                 { $$ = $2/*->set_extension( true )*/; }
     1990                { $$ = $2; }
    19941991        ;
    19951992
    … …  
    19971994        function_definition
    19981995                // These rules are a concession to the "implicit int" type_specifier because there is a significant amount of
    1999                 // legacy code with global functions missing the type-specifier for the return type, and assuming "int".
    2000                 // Parsing is possible because function_definition does not appear in the context of an expression (nested
    2001                 // functions preclude this concession, i.e., all nested function must have a return type). A function prototype
    2002                 // declaration must still have a type_specifier.  OBSOLESCENT (see 1)
     1996                // code with functions missing a type-specifier on the return type.  Parsing is possible because
     1997                // function_definition does not appear in the context of an expression (nested functions would preclude this
     1998                // concession). A function prototype declaration must still have a type_specifier.  OBSOLESCENT (see 1)
    20031999        | function_declarator compound_statement
    20042000                {
    … …  
    20782074declarator:
    20792075        variable_declarator
    2080         | variable_type_redeclarator
    20812076        | function_declarator
     2077        | type_redeclarator
    20822078        ;
    20832079
    … …  
    21792175
    21802176variable_ptr:
    2181         ptrref_operator variable_declarator
     2177        '*' variable_declarator
    21822178                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2183         | ptrref_operator type_qualifier_list variable_declarator
     2179        | '*' type_qualifier_list variable_declarator
    21842180                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    21852181        | '(' variable_ptr ')'
    … …  
    22052201        ;
    22062202
    2207 // This pattern parses a function declarator that is not redefining a typedef name. For non-nested functions, there is
    2208 // no context where a function definition can redefine a typedef name, i.e., the typedef and function name cannot exist
    2209 // is the same scope.  The pattern precludes returning arrays and functions versus pointers to arrays and functions.
     2203// This pattern parses a function declarator that is not redefining a typedef name. Because functions cannot be nested,
     2204// there is no context where a function definition can redefine a typedef name. To allow nested functions requires
     2205// further separation of variable and function declarators in type_redeclarator.  The pattern precludes returning
     2206// arrays and functions versus pointers to arrays and functions.
    22102207
    22112208function_declarator:
    … …  
    22272224
    22282225function_ptr:
    2229         ptrref_operator function_declarator
     2226        '*' function_declarator
    22302227                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2231         | ptrref_operator type_qualifier_list function_declarator
     2228        | '*' type_qualifier_list function_declarator
    22322229                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    22332230        | '(' function_ptr ')'
    … …  
    22642261
    22652262old_function_ptr:
    2266         ptrref_operator old_function_declarator
     2263        '*' old_function_declarator
    22672264                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2268         | ptrref_operator type_qualifier_list old_function_declarator
     2265        | '*' type_qualifier_list old_function_declarator
    22692266                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    22702267        | '(' old_function_ptr ')'
    … …  
    22912288// and functions versus pointers to arrays and functions.
    22922289
    2293 variable_type_redeclarator:
     2290type_redeclarator:
    22942291        paren_type attribute_list_opt
    22952292                { $$ = $1->addQualifiers( $2 ); }
    … …  
    23082305
    23092306type_ptr:
    2310         ptrref_operator variable_type_redeclarator
     2307        '*' type_redeclarator
    23112308                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2312         | ptrref_operator type_qualifier_list variable_type_redeclarator
     2309        | '*' type_qualifier_list type_redeclarator
    23132310                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    23142311        | '(' type_ptr ')'
    … …  
    23522349
    23532350identifier_parameter_ptr:
    2354         ptrref_operator identifier_parameter_declarator
     2351        '*' identifier_parameter_declarator
    23552352                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2356         | ptrref_operator type_qualifier_list identifier_parameter_declarator
     2353        | '*' type_qualifier_list identifier_parameter_declarator
    23572354                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    23582355        | '(' identifier_parameter_ptr ')'
    … …  
    23932390//              not as redundant parentheses around the identifier."
    23942391//
    2395 // For example:
     2392// which precludes the following cases:
    23962393//
    23972394//              typedef float T;
    … …  
    24302427
    24312428type_parameter_ptr:
    2432         ptrref_operator type_parameter_redeclarator
     2429        '*' type_parameter_redeclarator
    24332430                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2434         | ptrref_operator type_qualifier_list type_parameter_redeclarator
     2431        | '*' type_qualifier_list type_parameter_redeclarator
    24352432                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24362433        | '(' type_parameter_ptr ')'
    … …  
    24702467
    24712468abstract_ptr:
    2472         ptrref_operator
     2469        '*'
    24732470                { $$ = DeclarationNode::newPointer( 0 ); }
    2474         | ptrref_operator type_qualifier_list
     2471        | '*' type_qualifier_list
    24752472                { $$ = DeclarationNode::newPointer( $2 ); }
    2476         | ptrref_operator abstract_declarator
     2473        | '*' abstract_declarator
    24772474                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2478         | ptrref_operator type_qualifier_list abstract_declarator
     2475        | '*' type_qualifier_list abstract_declarator
    24792476                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24802477        | '(' abstract_ptr ')'
    … …  
    25392536
    25402537abstract_parameter_ptr:
    2541         ptrref_operator
     2538        '*'
    25422539                { $$ = DeclarationNode::newPointer( 0 ); }
    2543         | ptrref_operator type_qualifier_list
     2540        | '*' type_qualifier_list
    25442541                { $$ = DeclarationNode::newPointer( $2 ); }
    2545         | ptrref_operator abstract_parameter_declarator
     2542        | '*' abstract_parameter_declarator
    25462543                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2547         | ptrref_operator type_qualifier_list abstract_parameter_declarator
     2544        | '*' type_qualifier_list abstract_parameter_declarator
    25482545                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25492546        | '(' abstract_parameter_ptr ')'
    … …  
    26172614
    26182615variable_abstract_ptr:
    2619         ptrref_operator
     2616        '*'
    26202617                { $$ = DeclarationNode::newPointer( 0 ); }
    2621         | ptrref_operator type_qualifier_list
     2618        | '*' type_qualifier_list
    26222619                { $$ = DeclarationNode::newPointer( $2 ); }
    2623         | ptrref_operator variable_abstract_declarator
     2620        | '*' variable_abstract_declarator
    26242621                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    2625         | ptrref_operator type_qualifier_list variable_abstract_declarator
     2622        | '*' type_qualifier_list variable_abstract_declarator
    26262623                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26272624        | '(' variable_abstract_ptr ')'
    … …  
    26622659
    26632660new_identifier_parameter_ptr:                                                   // CFA
    2664         ptrref_operator type_specifier
     2661        '*' type_specifier
    26652662                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    2666         | type_qualifier_list ptrref_operator type_specifier
     2663        | type_qualifier_list '*' type_specifier
    26672664                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    2668         | ptrref_operator new_abstract_function
     2665        | '*' new_abstract_function
    26692666                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    2670         | type_qualifier_list ptrref_operator new_abstract_function
     2667        | type_qualifier_list '*' new_abstract_function
    26712668                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    2672         | ptrref_operator new_identifier_parameter_declarator_tuple
     2669        | '*' new_identifier_parameter_declarator_tuple
    26732670                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    2674         | type_qualifier_list ptrref_operator new_identifier_parameter_declarator_tuple
     2671        | type_qualifier_list '*' new_identifier_parameter_declarator_tuple
    26752672                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    26762673        ;
    … …  
    27492746
    27502747new_abstract_ptr:                                                                               // CFA
    2751         ptrref_operator type_specifier
     2748        '*' type_specifier
    27522749                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    2753         | type_qualifier_list ptrref_operator type_specifier
     2750        | type_qualifier_list '*' type_specifier
    27542751                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    2755         | ptrref_operator new_abstract_function
     2752        | '*' new_abstract_function
    27562753                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    2757         | type_qualifier_list ptrref_operator new_abstract_function
     2754        | type_qualifier_list '*' new_abstract_function
    27582755                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    2759         | ptrref_operator new_abstract_declarator_tuple
     2756        | '*' new_abstract_declarator_tuple
    27602757                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    2761         | type_qualifier_list ptrref_operator new_abstract_declarator_tuple
     2758        | type_qualifier_list '*' new_abstract_declarator_tuple
    27622759                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    27632760        ;
Note: See TracChangeset for help on using the changeset viewer.