Ignore:
Timestamp:
Jul 23, 2018, 6:00:57 PM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
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:
e68b3a8
Parents:
cbdf565 (diff), c29c342 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/parser.yy

    rcbdf565 r2514607d  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 12 16:16:25 2018
    13 // Update Count     : 3756
     12// Last Modified On : Fri Jul 20 11:46:46 2018
     13// Update Count     : 3837
    1414//
    1515
     
    114114        } // for
    115115} // distExt
     116
     117void distInl( DeclarationNode * declaration ) {
     118        // distribute EXTENSION across all declarations
     119        for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
     120                iter->set_inLine( true );
     121        } // for
     122} // distInl
    116123
    117124void distQual( DeclarationNode * declaration, DeclarationNode * qualifiers ) {
     
    166173} // build_postfix_name
    167174
     175DeclarationNode * fieldDecl( DeclarationNode * typeSpec, DeclarationNode * fieldList ) {
     176        if ( ! fieldList ) {                                                            // field declarator ?
     177                if ( ! ( typeSpec->type && typeSpec->type->kind == TypeData::Aggregate ) ) {
     178                        stringstream ss;
     179                        typeSpec->type->print( ss );
     180                        SemanticWarning( yylloc, Warning::SuperfluousDecl, ss.str().c_str() );
     181                        return nullptr;
     182                } // if
     183                fieldList = DeclarationNode::newName( nullptr );
     184        } // if
     185        return distAttr( typeSpec, fieldList );                         // mark all fields in list
     186} // fieldDecl
     187
    168188bool forall = false, yyy = false;                                               // aggregate have one or more forall qualifiers ?
    169189
     
    338358%type<decl> exception_declaration
    339359
    340 %type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
    341 %type<en> field field_list field_name fraction_constants_opt
     360%type<decl> field_declaration_list_opt field_declaration field_declaring_list_opt field_declarator field_abstract_list_opt field_abstract
     361%type<en> field field_name_list field_name fraction_constants_opt
    342362
    343363%type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
     
    352372%type<decl> cfa_array_parameter_1st_dimension
    353373
    354 %type<decl> cfa_trait_declaring_list cfa_declaration cfa_field_declaring_list
     374%type<decl> cfa_trait_declaring_list cfa_declaration cfa_field_declaring_list cfa_field_abstract_list
    355375%type<decl> cfa_function_declaration cfa_function_return cfa_function_specifier
    356376
     
    492512        ;
    493513
    494 identifier:
    495         IDENTIFIER
    496         | ATTR_IDENTIFIER                                                                       // CFA
    497         | quasi_keyword
    498         ;
    499 
    500514no_attr_identifier:
    501515        IDENTIFIER
    502516        | quasi_keyword
     517        | '@'                                                                                           // CFA
     518                { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
     519        ;
     520
     521identifier:
     522        no_attr_identifier
     523        | ATTR_IDENTIFIER                                                                       // CFA
    503524        ;
    504525
     
    541562        | type_name '.' no_attr_identifier                                      // CFA, nested type
    542563                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    543         | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
     564        | type_name '.' '[' field_name_list ']'                         // CFA, nested type / tuple field selector
    544565                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    545566        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
     
    594615        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
    595616                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
    596         | postfix_expression '.' '[' field_list ']'                     // CFA, tuple field selector
     617        | postfix_expression '.' '[' field_name_list ']'        // CFA, tuple field selector
    597618                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    598619        | postfix_expression ARROW no_attr_identifier
     
    602623        | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
    603624                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
    604         | postfix_expression ARROW '[' field_list ']'           // CFA, tuple field selector
     625        | postfix_expression ARROW '[' field_name_list ']'      // CFA, tuple field selector
    605626                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
    606627        | postfix_expression ICR
     
    629650        // empty
    630651                { $$ = nullptr; }
    631         // | '@'                                                                                                // use default argument
    632         //      { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
     652        | '?'                                                                                           // CFA, default parameter
     653                { SemanticError( yylloc, "Default parameter for argument is currently unimplemented." ); $$ = nullptr; }
     654                // { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
    633655        | assignment_expression
    634656        ;
    635657
    636 field_list:                                                                                             // CFA, tuple field selector
     658field_name_list:                                                                                // CFA, tuple field selector
    637659        field
    638         | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_last( $3 ); }
     660        | field_name_list ',' field                                     { $$ = (ExpressionNode *)$1->set_last( $3 ); }
    639661        ;
    640662
     
    643665        | FLOATING_DECIMALconstant field
    644666                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
    645         | FLOATING_DECIMALconstant '[' field_list ']'
     667        | FLOATING_DECIMALconstant '[' field_name_list ']'
    646668                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
    647669        | field_name '.' field
    648670                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
    649         | field_name '.' '[' field_list ']'
     671        | field_name '.' '[' field_name_list ']'
    650672                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    651673        | field_name ARROW field
    652674                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
    653         | field_name ARROW '[' field_list ']'
     675        | field_name ARROW '[' field_name_list ']'
    654676                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
    655677        ;
     
    19321954
    19331955field_declaration:
    1934         type_specifier field_declaring_list ';'
    1935                 { $$ = distAttr( $1, $2 ); }
    1936         | EXTENSION type_specifier field_declaring_list ';'     // GCC
    1937                 { distExt( $3 ); $$ = distAttr( $2, $3 ); }             // mark all fields in list
    1938         | INLINE type_specifier field_declaring_list ';'        // CFA
    1939                 {
    1940                         if ( $2->type && ( $2->type->kind == TypeData::Aggregate || $2->type->kind == TypeData::AggregateInst ) ) {
    1941                                 if ( $2->type->kind == TypeData::Aggregate ) {
    1942                                         $2->type->aggregate.inLine = true;
    1943                                 } else {
    1944                                         $2->type->aggInst.inLine = true;
    1945                                 } // if
    1946                                 $$ = distAttr( $2, $3 );
    1947                         } else {
    1948                                 SemanticError( yylloc, "inline qualifier only allowed for aggregate field declarations." ); $$ = nullptr;
    1949                         } // if
     1956        type_specifier field_declaring_list_opt ';'
     1957                { $$ = fieldDecl( $1, $2 ); }
     1958        | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
     1959                { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
     1960        | INLINE type_specifier field_abstract_list_opt ';'     // CFA
     1961                {
     1962                        if ( ! $3 ) {                                                           // field declarator ?
     1963                                $3 = DeclarationNode::newName( nullptr );
     1964                        } // if
     1965                        $3->inLine = true;
     1966                        $$ = distAttr( $2, $3 );                                        // mark all fields in list
     1967                        distInl( $3 );
    19501968                }
    19511969        | typedef_declaration ';'                                                       // CFA
     
    19531971        | EXTENSION cfa_field_declaring_list ';'                        // GCC
    19541972                { distExt( $2 ); $$ = $2; }                                             // mark all fields in list
     1973        | INLINE cfa_field_abstract_list ';'                            // CFA, new style field declaration
     1974                { $$ = $2; }                                                                    // mark all fields in list
    19551975        | cfa_typedef_declaration ';'                                           // CFA
    19561976        | static_assert                                                                         // C11
    19571977        ;
    19581978
     1979field_declaring_list_opt:
     1980        // empty
     1981                { $$ = nullptr; }
     1982        | field_declarator
     1983        | field_declaring_list_opt ',' attribute_list_opt field_declarator
     1984                { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
     1985        ;
     1986
     1987field_declarator:
     1988        bit_subrange_size                                                                       // C special case, no field name
     1989                { $$ = DeclarationNode::newBitfield( $1 ); }
     1990        | variable_declarator bit_subrange_size_opt
     1991                // A semantic check is required to ensure bit_subrange only appears on integral types.
     1992                { $$ = $1->addBitfield( $2 ); }
     1993        | variable_type_redeclarator bit_subrange_size_opt
     1994                // A semantic check is required to ensure bit_subrange only appears on integral types.
     1995                { $$ = $1->addBitfield( $2 ); }
     1996        ;
     1997
     1998field_abstract_list_opt:
     1999        // empty
     2000                { $$ = nullptr; }
     2001        | field_abstract
     2002        | field_abstract_list_opt ',' attribute_list_opt field_abstract
     2003                { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
     2004        ;
     2005
     2006field_abstract:
     2007                //      no bit fields
     2008        variable_abstract_declarator
     2009        ;
     2010
    19592011cfa_field_declaring_list:                                                               // CFA, new style field declaration
    1960         cfa_abstract_declarator_tuple                                           // CFA, no field name
    1961         | cfa_abstract_declarator_tuple no_attr_identifier_or_type_name
     2012        // bit-fields are handled by C declarations
     2013        cfa_abstract_declarator_tuple no_attr_identifier_or_type_name
    19622014                { $$ = $1->addName( $2 ); }
    19632015        | cfa_field_declaring_list ',' no_attr_identifier_or_type_name
    19642016                { $$ = $1->appendList( $1->cloneType( $3 ) ); }
    1965         | cfa_field_declaring_list ','                                          // CFA, no field name
     2017        ;
     2018
     2019cfa_field_abstract_list:                                                                // CFA, new style field declaration
     2020        // bit-fields are handled by C declarations
     2021        cfa_abstract_declarator_tuple
     2022        | cfa_field_abstract_list ','
    19662023                { $$ = $1->appendList( $1->cloneType( 0 ) ); }
    1967         ;
    1968 
    1969 field_declaring_list:
    1970         field_declarator_opt
    1971         | field_declaring_list ',' attribute_list_opt field_declarator_opt
    1972                 { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
    1973         ;
    1974 
    1975 field_declarator_opt:
    1976         // empty
    1977                 { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
    1978         // '@'
    1979         //      { $$ = DeclarationNode::newName( new string( DeclarationNode::anonymous.newName() ) ); } // CFA, no field name
    1980         | bit_subrange_size                                                                     // no field name
    1981                 { $$ = DeclarationNode::newBitfield( $1 ); }
    1982         | variable_declarator bit_subrange_size_opt
    1983                 // A semantic check is required to ensure bit_subrange only appears on base type int.
    1984                 { $$ = $1->addBitfield( $2 ); }
    1985         | variable_type_redeclarator bit_subrange_size_opt
    1986                 // A semantic check is required to ensure bit_subrange only appears on base type int.
    1987                 { $$ = $1->addBitfield( $2 ); }
    1988         | variable_abstract_declarator                                          // CFA, no field name
    19892024        ;
    19902025
     
    22262261        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    22272262                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); }
    2228         | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
     2263        | '.' '[' push field_name_list pop ']'                          // CFA, tuple field selector
    22292264                { $$ = $4; }
    22302265        ;
Note: See TracChangeset for help on using the changeset viewer.