Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/parser.yy

    r2beaf9b r4eb3a7c5  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Nov 26 13:18:06 2023
    13 // Update Count     : 6398
     12// Last Modified On : Fri Feb 23 18:25:46 2024
     13// Update Count     : 6484
    1414//
    1515
    … …  
    102102
    103103DeclarationNode * distAttr( DeclarationNode * typeSpec, DeclarationNode * declList ) {
    104         // distribute declaration_specifier across all declared variables, e.g., static, const, but not __attribute__.
     104        // Distribute type specifier across all declared variables, e.g., static, const, __attribute__.
    105105        assert( declList );
    106         // printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout );
    107         DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec );
    108         // printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout );
    109         // cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name;
    110 
     106
     107        // Do not distribute attributes for aggregates because the attributes surrounding the aggregate belong it not the
     108        // variables in the declaration list, e.g.,
     109        //
     110        //   struct __attribute__(( aligned(128) )) S { ...
     111        //   } v1 __attribute__(( aligned(64) )), v2 __attribute__(( aligned(32) )), v3;
     112        //   struct S v4;
     113        //
     114        // v1 => 64, v2 =>32, v3 => 128, v2 => 128
     115        //
     116        // Anonymous aggregates are a special case because there is no aggregate to bind the attribute to; hence it floats
     117        // to the declaration list.
     118        //
     119        //   struct __attribute__(( aligned(128) )) /*anonymous */ { ... } v1;
     120        //
     121        // v1 => 128
     122
     123        bool copyattr = ! (typeSpec->type && typeSpec->type->kind == TypeData::Aggregate && ! typeSpec->type->aggregate.anon );
     124
     125        // addType copies the type information for the aggregate instances from typeSpec into cl's aggInst.aggregate.
     126        DeclarationNode * cl = (new DeclarationNode)->addType( typeSpec ); // typeSpec IS DELETED!!!
     127
     128        // Start at second variable in declaration list and clone the type specifiers for each variable..
    111129        for ( DeclarationNode * cur = dynamic_cast<DeclarationNode *>( declList->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
    112                 cl->cloneBaseType( cur );
     130                cl->cloneBaseType( cur, copyattr );                             // cur is modified
    113131        } // for
    114         declList->addType( cl );
    115         // printf( "distAttr3 declList %p\n", declList ); declList->print( std::cout, 0 );
     132
     133        // Add first variable in declaration list with hidden type information in aggInst.aggregate, which is used by
     134        // extractType to recover the type for the aggregate instances.
     135        declList->addType( cl, copyattr );                                      // cl IS DELETED!!!
    116136        return declList;
    117137} // distAttr
    … …  
    192212                fieldList = DeclarationNode::newName( nullptr );
    193213        } // if
    194 //      return distAttr( typeSpec, fieldList );                         // mark all fields in list
    195214
    196215        // printf( "fieldDecl3 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout, 0 );
    197         DeclarationNode * temp = distAttr( typeSpec, fieldList );                               // mark all fields in list
     216        DeclarationNode * temp = distAttr( typeSpec, fieldList ); // mark all fields in list
    198217        // printf( "fieldDecl4 temp %p\n", temp ); temp->print( std::cout, 0 );
    199218        return temp;
    … …  
    761780        | string_literal '`' identifier                                         // CFA, postfix call
    762781                { $$ = new ExpressionNode( build_func( yylloc, new ExpressionNode( build_varref( yylloc, build_postfix_name( $3 ) ) ), $1 ) ); }
     782
     783                // SKULLDUGGERY: The typedef table used for parsing does not store fields in structures. To parse a qualified
     784                // name, it is assumed all name-tokens after the first are identifiers, regardless of how the lexer identifies
     785        // them. For example:
     786                //   
     787                //   struct S;
     788                //   forall(T) struct T;
     789                //   union U;
     790                //   enum E { S, T, E };
     791                //   struct Z { int S, T, Z, E, U; };
     792                //   void fred () {
     793                //       Z z;
     794                //       z.S;  // lexer returns S is TYPEDEFname
     795                //       z.T;  // lexer returns T is TYPEGENname
     796                //       z.Z;  // lexer returns Z is TYPEDEFname
     797                //       z.U;  // lexer returns U is TYPEDEFname
     798                //       z.E;  // lexer returns E is TYPEDEFname
     799                //   }
    763800        | postfix_expression '.' identifier
    764801                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
     802        | postfix_expression '.' TYPEDEFname                            // CFA, SKULLDUGGERY
     803                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
     804        | postfix_expression '.' TYPEGENname                            // CFA, SKULLDUGGERY
     805                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_varref( yylloc, $3 ) ) ); }
     806
    765807        | postfix_expression '.' INTEGERconstant                        // CFA, tuple index
    766808                { $$ = new ExpressionNode( build_fieldSel( yylloc, $1, build_constantInteger( yylloc, *$3 ) ) ); }
    … …  
    10391081        | logical_OR_expression '?' comma_expression ':' conditional_expression
    10401082                { $$ = new ExpressionNode( build_cond( yylloc, $1, $3, $5 ) ); }
     1083                // FIX ME: computes $1 twice
    10411084        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    1042                 { $$ = new ExpressionNode( build_cond( yylloc, $1, nullptr, $4 ) ); }
     1085                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); }
    10431086        ;
    10441087
    … …  
    18551898declaration_list:
    18561899        declaration
    1857         | declaration_list declaration
    1858                 { $$ = $1->appendList( $2 ); }
     1900        | declaration_list declaration          { $$ = $1->appendList( $2 ); }
    18591901        ;
    18601902
    … …  
    18891931declaration:                                                                                    // old & new style declarations
    18901932        c_declaration ';'
    1891                 {
    1892                         // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
    1893                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
    1894                         //   printf( "\tattr %s\n", attr->name.c_str() );
    1895                         // } // for
    1896                 }
    18971933        | cfa_declaration ';'                                                           // CFA
    18981934        | static_assert                                                                         // C11
    … …  
    23472383sue_declaration_specifier:                                                              // struct, union, enum + storage class + type specifier
    23482384        sue_type_specifier
    2349                 {
    2350                         // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
    2351                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
    2352                         //   printf( "\tattr %s\n", attr->name.c_str() );
    2353                         // } // for
    2354                 }
    23552385        | declaration_qualifier_list sue_type_specifier
    23562386                { $$ = $2->addQualifiers( $1 ); }
    … …  
    23632393sue_type_specifier:                                                                             // struct, union, enum + type specifier
    23642394        elaborated_type
    2365                 {
    2366                         // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
    2367                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
    2368                         //   printf( "\tattr %s\n", attr->name.c_str() );
    2369                         // } // for
    2370                 }
    23712395        | type_qualifier_list
    23722396                { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type
    … …  
    24412465elaborated_type:                                                                                // struct, union, enum
    24422466        aggregate_type
    2443                 {
    2444                         // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
    2445                         // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
    2446                         //   printf( "\tattr %s\n", attr->name.c_str() );
    2447                         // } // for
    2448                 }
    24492467        | enum_type
    24502468        ;
    … …  
    26782696                { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
    26792697        | ENUM attribute_list_opt '!' '{' enumerator_list comma_opt '}' // invalid syntax rule
    2680                 { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
     2698                { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
    26812699        | ENUM attribute_list_opt identifier
    26822700                { typedefTable.makeTypedef( *$3, "enum_type 1" ); }
    … …  
    26932711                }
    26942712        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '!' '{' enumerator_list comma_opt '}' // unqualified type name
    2695                 { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
     2713                { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
    26962714        | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
    26972715                {
    … …  
    26992717                }
    27002718        | ENUM '(' ')' attribute_list_opt '!' '{' enumerator_list comma_opt '}' // invalid syntax rule
    2701                 { SemanticError( yylloc, "syntax error, hiding '!' the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
     2719                { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
    27022720        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
    27032721                {
    … …  
    31703188                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
    31713189                        // disallowed at the moment.
    3172                         if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
     3190                        if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static &&
     3191                                 $1->type && $1->type->kind == TypeData::AggregateInst ) {
    31733192                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
    31743193                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;
Note: See TracChangeset for help on using the changeset viewer.