Changes in / [e825c9d:1f55a75]


Ignore:
Location:
src/Parser
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/DeclarationNode.cc

    re825c9d r1f55a75  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:37 2021
    13 // Update Count     : 1141
     12// Last Modified On : Tue Mar 23 08:44:08 2021
     13// Update Count     : 1149
    1414//
    1515
    … …  
    167167}
    168168
    169 DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
    170         DeclarationNode * newnode = new DeclarationNode;
    171         newnode->name = name;
    172         newnode->type = new TypeData( TypeData::Function );
    173         newnode->type->function.params = param;
    174         newnode->type->function.body = body;
    175 
    176         if ( ret ) {
    177                 newnode->type->base = ret->type;
    178                 ret->type = nullptr;
    179                 delete ret;
    180         } // if
    181 
    182         return newnode;
    183 } // DeclarationNode::newFunction
    184 
    185 
    186169DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
    187170        DeclarationNode * newnode = new DeclarationNode;
    … …  
    237220        return newnode;
    238221} // DeclarationNode::newForall
    239 
    240 DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
    241         DeclarationNode * newnode = new DeclarationNode;
    242         newnode->type = new TypeData( TypeData::SymbolicInst );
    243         newnode->type->symbolic.name = name;
    244         newnode->type->symbolic.isTypedef = true;
    245         newnode->type->symbolic.params = nullptr;
    246         return newnode;
    247 } // DeclarationNode::newFromTypedef
    248222
    249223DeclarationNode * DeclarationNode::newFromGlobalScope() {
    … …  
    289263} // DeclarationNode::newEnum
    290264
     265DeclarationNode * DeclarationNode::newName( const string * name ) {
     266        DeclarationNode * newnode = new DeclarationNode;
     267        assert( ! newnode->name );
     268        newnode->name = name;
     269        return newnode;
     270} // DeclarationNode::newName
     271
    291272DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
    292         DeclarationNode * newnode = new DeclarationNode;
    293         newnode->name = name;
     273        DeclarationNode * newnode = newName( name );
    294274        newnode->enumeratorValue.reset( constant );
    295275        return newnode;
    296276} // DeclarationNode::newEnumConstant
    297277
    298 DeclarationNode * DeclarationNode::newName( const string * name ) {
    299         DeclarationNode * newnode = new DeclarationNode;
    300         newnode->name = name;
    301         return newnode;
    302 } // DeclarationNode::newName
     278DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
     279        DeclarationNode * newnode = new DeclarationNode;
     280        newnode->type = new TypeData( TypeData::SymbolicInst );
     281        newnode->type->symbolic.name = name;
     282        newnode->type->symbolic.isTypedef = true;
     283        newnode->type->symbolic.params = nullptr;
     284        return newnode;
     285} // DeclarationNode::newFromTypedef
    303286
    304287DeclarationNode * DeclarationNode::newFromTypeGen( const string * name, ExpressionNode * params ) {
    … …  
    312295
    313296DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
    314         DeclarationNode * newnode = new DeclarationNode;
     297        DeclarationNode * newnode = newName( name );
    315298        newnode->type = nullptr;
    316         assert( ! newnode->name );
    317 //      newnode->variable.name = name;
    318         newnode->name = name;
    319299        newnode->variable.tyClass = tc;
    320300        newnode->variable.assertions = nullptr;
    … …  
    343323
    344324DeclarationNode * DeclarationNode::newTypeDecl( const string * name, DeclarationNode * typeParams ) {
    345         DeclarationNode * newnode = new DeclarationNode;
    346         newnode->name = name;
     325        DeclarationNode * newnode = newName( name );
    347326        newnode->type = new TypeData( TypeData::Symbolic );
    348327        newnode->type->symbolic.isTypedef = false;
    … …  
    416395        return newnode;
    417396} // DeclarationNode::newBuiltinType
     397
     398DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
     399        DeclarationNode * newnode = newName( name );
     400        newnode->type = new TypeData( TypeData::Function );
     401        newnode->type->function.params = param;
     402        newnode->type->function.body = body;
     403
     404        if ( ret ) {
     405                newnode->type->base = ret->type;
     406                ret->type = nullptr;
     407                delete ret;
     408        } // if
     409
     410        return newnode;
     411} // DeclarationNode::newFunction
    418412
    419413DeclarationNode * DeclarationNode::newAttribute( const string * name, ExpressionNode * expr ) {
    … …  
    885879}
    886880
    887 DeclarationNode * DeclarationNode::cloneType( string * newName ) {
    888         DeclarationNode * newnode = new DeclarationNode;
     881DeclarationNode * DeclarationNode::cloneType( string * name ) {
     882        DeclarationNode * newnode = newName( name );
    889883        newnode->type = maybeClone( type );
    890884        newnode->copySpecifiers( this );
    891         assert( newName );
    892         newnode->name = newName;
    893885        return newnode;
    894886}

  • src/Parser/TypedefTable.cc

    re825c9d r1f55a75  
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 08:06:36 2020
    13 // Update Count     : 259
     12// Last Modified On : Mon Mar 15 20:56:47 2021
     13// Update Count     : 260
    1414//
    1515
    … …  
    8989        debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << " level " << level << " note " << kindTable.getNote( kindTable.currentScope() - 1 ).level << endl );
    9090        auto ret = kindTable.insertAt( scope, identifier, kind );
    91         if ( ! ret.second ) ret.first->second = kind;   // exists => update
     91        if ( ! ret.second ) ret.first->second = kind;           // exists => update
    9292} // TypedefTable::addToEnclosingScope
    9393

  • src/Parser/parser.yy

    re825c9d r1f55a75  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 15 13:34:17 2021
    13 // Update Count     : 4740
     12// Last Modified On : Tue Mar 23 20:56:24 2021
     13// Update Count     : 4929
    1414//
    1515
    … …  
    3232//
    3333// 1. designation with and without '=' (use ':' instead)
    34 // 2. attributes not allowed in parenthesis of declarator
     34
    3535//
    3636// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
    … …  
    321321%type<en> constant
    322322%type<en> tuple                                                 tuple_expression_list
    323 %type<op> ptrref_operator                               unary_operator                          assignment_operator
     323%type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
    324324%type<en> primary_expression                    postfix_expression                      unary_expression
    325325%type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
    … …  
    428428
    429429%type<decl> type_declaration_specifier type_type_specifier type_name typegen_name
    430 %type<decl> typedef typedef_declaration typedef_expression
     430%type<decl> typedef_name typedef_declaration typedef_expression
    431431
    432432%type<decl> variable_type_redeclarator type_ptr type_array type_function
    … …  
    440440
    441441%type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
    442 %type<decl> type_specifier type_specifier_nobody enum_specifier_nobody
     442%type<decl> type_specifier type_specifier_nobody
    443443
    444444%type<decl> variable_declarator variable_ptr variable_array variable_function
    445445%type<decl> variable_abstract_declarator variable_abstract_ptr variable_abstract_array variable_abstract_function
    446446
    447 %type<decl> attribute_list_opt attribute_list attribute_opt attribute attribute_name_list attribute_name
     447%type<decl> attribute_list_opt attribute_list attribute attribute_name_list attribute_name
    448448
    449449// initializers
    … …  
    950950
    951951assignment_operator:
     952        simple_assignment_operator
     953        | compound_assignment_operator
     954        ;
     955
     956simple_assignment_operator:
    952957        '='                                                                                     { $$ = OperKinds::Assign; }
    953         | ATassign                                                                      { $$ = OperKinds::AtAssn; }
    954         | EXPassign                                                                     { $$ = OperKinds::ExpAssn; }
     958        | ATassign                                                                      { $$ = OperKinds::AtAssn; } // CFA
     959        ;
     960
     961compound_assignment_operator:
     962        EXPassign                                                                       { $$ = OperKinds::ExpAssn; }
    955963        | MULTassign                                                            { $$ = OperKinds::MulAssn; }
    956964        | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
    … …  
    17541762        ;
    17551763
    1756 enum_specifier_nobody:                                                                  // type specifier - {...}
    1757                 // Preclude SUE declarations in restricted scopes (see type_specifier_nobody)
    1758         basic_type_specifier
    1759         | sue_type_specifier_nobody
    1760         ;
    1761 
    17621764type_qualifier_list_opt:                                                                // GCC, used in asm_statement
    17631765        // empty
    … …  
    20382040          '{' field_declaration_list_opt '}' type_parameters_opt
    20392041                { $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); }
    2040         | aggregate_key attribute_list_opt type_name
    2041                 {
    2042                         // for type_name can be a qualified type name S.T, in which case only the last name in the chain needs a typedef (other names in the chain should already have one)
    2043                         typedefTable.makeTypedef( *$3->type->leafName(), forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
     2042        | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
     2043                {
     2044                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
    20442045                        forall = false;                                                         // reset
    20452046                }
    20462047          '{' field_declaration_list_opt '}' type_parameters_opt
    2047                 { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $8, $6, true )->addQualifiers( $2 ); }
     2048                {
     2049                        DeclarationNode::newFromTypedef( $3 );
     2050                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
     2051                }
     2052        | aggregate_key attribute_list_opt TYPEGENname          // unqualified type name
     2053                {
     2054                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
     2055                        forall = false;                                                         // reset
     2056                }
     2057          '{' field_declaration_list_opt '}' type_parameters_opt
     2058                {
     2059                        DeclarationNode::newFromTypeGen( $3, nullptr );
     2060                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
     2061                }
    20482062        | aggregate_type_nobody
    20492063        ;
    … …  
    22012215        ;
    22022216
    2203 // Cannot use attribute_list_opt because of ambiguity with enum_specifier_nobody, which already parses attribute.
    2204 // Hence, only a single attribute is allowed after the "ENUM".
    22052217enum_type:                                                                                              // enum
    2206         ENUM attribute_opt '{' enumerator_list comma_opt '}'
     2218        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
    22072219                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
    2208         | ENUM attribute_opt identifier
     2220        | ENUM attribute_list_opt identifier
    22092221                { typedefTable.makeTypedef( *$3 ); }
    22102222          '{' enumerator_list comma_opt '}'
    22112223                { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
    2212         | ENUM attribute_opt typedef                                            // enum cannot be generic
     2224        | ENUM attribute_list_opt typedef_name                          // unqualified type name
    22132225          '{' enumerator_list comma_opt '}'
    22142226                { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
    2215         | ENUM enum_specifier_nobody '{' enumerator_list comma_opt '}'
    2216                 // { $$ = DeclarationNode::newEnum( nullptr, $4, true ); }
    2217                 { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
    2218         | ENUM enum_specifier_nobody declarator '{' enumerator_list comma_opt '}'
    2219                 // {
    2220                 //      typedefTable.makeTypedef( *$3->name );
    2221                 //      $$ = DeclarationNode::newEnum( nullptr, $5, true );
    2222                 // }
    2223                 { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
     2227        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
     2228                // { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
     2229                { $$ = nullptr; }
     2230        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt '{' enumerator_list comma_opt '}'
     2231                // { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
     2232                { typedefTable.makeTypedef( *$6 ); }
     2233        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
     2234                // { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
     2235                { typedefTable.makeTypedef( *$6->name ); }
    22242236        | enum_type_nobody
    22252237        ;
    22262238
    22272239enum_type_nobody:                                                                               // enum - {...}
    2228         ENUM attribute_opt identifier
    2229                 {
    2230                         typedefTable.makeTypedef( *$3 );
    2231                         $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 );
    2232                 }
    2233         | ENUM attribute_opt type_name                                          // enum cannot be generic
    2234                 {
    2235                         typedefTable.makeTypedef( *$3->type->symbolic.name );
    2236                         $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 );
    2237                 }
     2240        ENUM attribute_list_opt identifier
     2241                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
     2242        | ENUM attribute_list_opt type_name                                     // qualified type name
     2243                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
    22382244        ;
    22392245
    … …  
    22412247        identifier_or_type_name enumerator_value_opt
    22422248                { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
     2249        | INLINE type_name
     2250                { $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
    22432251        | enumerator_list ',' identifier_or_type_name enumerator_value_opt
    22442252                { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
     2253        | enumerator_list ',' INLINE type_name enumerator_value_opt
     2254                { $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
    22452255        ;
    22462256
    … …  
    22502260        // | '=' constant_expression
    22512261        //      { $$ = $2; }
    2252         | '=' initializer
     2262        | simple_assignment_operator initializer
    22532263                { $$ = $2->get_expression(); }                                  // FIX ME: enum only deals with constant_expression
    22542264        ;
    … …  
    23782388        // empty
    23792389                { $$ = nullptr; }
    2380         | '=' initializer
    2381                 { $$ = $2; }
    2382         | '=' VOID
    2383                 { $$ = new InitializerNode( true ); }
    2384         | ATassign initializer
    2385                 { $$ = $2->set_maybeConstructed( false ); }
     2390        | simple_assignment_operator initializer        { $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
     2391        | '=' VOID                                                                      { $$ = new InitializerNode( true ); }
    23862392        ;
    23872393
    … …  
    27932799        | attribute_list attribute
    27942800                { $$ = $2->addQualifiers( $1 ); }
    2795         ;
    2796 
    2797 attribute_opt:
    2798         // empty
    2799                 { $$ = nullptr; }
    2800         | attribute
    28012801        ;
    28022802
    … …  
    30323032
    30333033paren_type:
    3034         typedef
    3035                 // hide type name in enclosing scope by variable name
    3036                 {
    3037                         // if ( ! typedefTable.existsCurr( *$1->name ) ) {
    3038                                 typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
    3039                         // } else {
    3040                         //      SemanticError( yylloc, string("'") + *$1->name + "' redeclared as different kind of symbol." ); $$ = nullptr;
    3041                         // } // if
     3034        typedef_name
     3035                {
     3036                        // hide type name in enclosing scope by variable name
     3037                        typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
    30423038                }
    30433039        | '(' paren_type ')'
    … …  
    31523148
    31533149type_parameter_redeclarator:
    3154         typedef attribute_list_opt
     3150        typedef_name attribute_list_opt
    31553151                { $$ = $1->addQualifiers( $2 ); }
    3156         | '&' MUTEX typedef attribute_list_opt
     3152        | '&' MUTEX typedef_name attribute_list_opt
    31573153                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
    31583154        | type_parameter_ptr
    … …  
    31633159        ;
    31643160
    3165 typedef:
     3161typedef_name:
    31663162        TYPEDEFname
    31673163                { $$ = DeclarationNode::newName( $1 ); }
    … …  
    31803176
    31813177type_parameter_array:
    3182         typedef array_parameter_dimension
     3178        typedef_name array_parameter_dimension
    31833179                { $$ = $1->addArray( $2 ); }
    31843180        | '(' type_parameter_ptr ')' array_parameter_dimension
    … …  
    31873183
    31883184type_parameter_function:
    3189         typedef '(' push parameter_type_list_opt pop ')'        // empty parameter list OBSOLESCENT (see 3)
     3185        typedef_name '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    31903186                { $$ = $1->addParamList( $4 ); }
    31913187        | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
Note: See TracChangeset for help on using the changeset viewer.