Changes in / [1761046:46aa60e]


Ignore:
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • doc/LaTeXmacros/lstlang.sty

    r1761046 r46aa60e  
    88%% Created On       : Sat May 13 16:34:42 2017
    99%% Last Modified By : Peter A. Buhr
    10 %% Last Modified On : Tue Feb 13 13:27:00 2024
    11 %% Update Count     : 36
     10%% Last Modified On : Fri Feb 16 07:59:29 2024
     11%% Update Count     : 37
    1212%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1313
    … …  
    125125}
    126126
    127 % C++ programming language
    128 \lstdefinelanguage{C++}[ANSI]{C++}{
    129         morekeywords={nullptr,}
    130 }
    131 
    132127% uC++ programming language, based on ANSI C++
    133 \lstdefinelanguage{uC++}[ANSI]{C++}{
     128\lstdefinelanguage{uC++}[GNU]{C++}{
    134129        morekeywords={
    135130                _Accept, _AcceptReturn, _AcceptWait, _Actor, _At, _Catch, _CatchResume, _CorActor, _Cormonitor, _Coroutine,

  • src/AST/Attribute.hpp

    r1761046 r46aa60e  
    99// Author           : Aaron B. Moss
    1010// Created On       : Fri May 10 10:30:00 2019
    11 // Last Modified By : Aaron B. Moss
     11// Last Modified By : Peter A. Buhr
    1212// Created On       : Fri May 10 10:30:00 2019
    13 // Update Count     : 1
     13// Update Count     : 2
    1414//
    1515
    … …  
    3434
    3535        Attribute( const std::string & name = "", std::vector<ptr<Expr>> && params = {})
    36         : name( name ), params( params ) {}
     36                : name( name ), params( params ) {}
    3737        virtual ~Attribute() = default;
    3838

  • src/Parser/DeclarationNode.cc

    r1761046 r46aa60e  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec 14 19:05:17 2023
    13 // Update Count     : 1407
     12// Last Modified On : Fri Feb 23 18:25:57 2024
     13// Update Count     : 1533
    1414//
    1515
    … …  
    159159
    160160        if ( ! attributes.empty() ) {
    161                 os << string( indent + 2, ' ' ) << "with attributes " << endl;
     161                os << string( indent + 2, ' ' ) << "with attributes" << endl;
    162162                for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( attributes ) ) {
    163                         os << string( indent + 4, ' ' ) << attr->name.c_str() << endl;
     163                        os << string( indent + 4, ' ' );
     164                        ast::print( os, attr, indent + 2 );
    164165                } // for
    165166        } // if
    … …  
    537538} // DeclarationNode::checkSpecifiers
    538539
    539 DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
     540DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q, bool copyattr ) {
    540541        funcSpecs |= q->funcSpecs;
    541542        storageClasses |= q->storageClasses;
    542543
    543         std::vector<ast::ptr<ast::Attribute>> tmp;
    544         tmp.reserve( q->attributes.size() );
    545         for ( auto const & attr : q->attributes ) {
    546                 tmp.emplace_back( ast::shallowCopy( attr.get() ) );
    547         }
    548         spliceBegin( attributes, tmp );
     544        if ( copyattr ) {
     545                std::vector<ast::ptr<ast::Attribute>> tmp;
     546                tmp.reserve( q->attributes.size() );
     547                for ( auto const & attr : q->attributes ) {
     548                        tmp.emplace_back( ast::shallowCopy( attr.get() ) );
     549                } // for
     550                spliceBegin( attributes, tmp );
     551        } // if
    549552
    550553        return this;
    … …  
    681684}
    682685
    683 DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
     686DeclarationNode * DeclarationNode::addType( DeclarationNode * o, bool copyattr ) {
    684687        if ( o ) {
    685688                checkSpecifiers( o );
    686                 copySpecifiers( o );
     689                copySpecifiers( o, copyattr );
    687690                if ( o->type ) {
    688691                        if ( ! type ) {
    689692                                if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
     693                                        // Hide type information aggregate instances.
    690694                                        type = new TypeData( TypeData::AggregateInst );
    691                                         type->aggInst.aggregate = o->type;
     695                                        type->aggInst.aggregate = o->type;      // change ownership
     696                                        type->aggInst.aggregate->aggregate.attributes.swap( o->attributes ); // change ownership                                       
    692697                                        if ( o->type->kind == TypeData::Aggregate ) {
    693698                                                type->aggInst.hoistType = o->type->aggregate.body;
    … …  
    700705                                        type = o->type;
    701706                                } // if
    702                                 o->type = nullptr;
     707                                o->type = nullptr;                                              // change ownership
    703708                        } else {
    704709                                addTypeToType( o->type, type );
    … …  
    953958}
    954959
    955 DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) {
     960DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o, bool copyattr ) {
    956961        if ( ! o ) return nullptr;
    957962
    958         o->copySpecifiers( this );
     963        o->copySpecifiers( this, copyattr );
    959964        if ( type ) {
    960965                TypeData * srcType = type;
    … …  
    9991004                        DeclarationNode * newnode = new DeclarationNode;
    10001005                        newnode->type = ret;
     1006                        if ( ret->kind == TypeData::Aggregate ) {
     1007                                newnode->attributes.swap( ret->aggregate.attributes );
     1008                        } // if
    10011009                        return newnode;
    10021010                } // if
    … …  
    11101118                                        if ( extr->type->kind == TypeData::Aggregate ) {
    11111119                                                // typedef struct { int A } B is the only case?
    1112                                                 extracted_named = !extr->type->aggregate.anon;
     1120                                                extracted_named = ! extr->type->aggregate.anon;
    11131121                                        } else if ( extr->type->kind == TypeData::Enum ) {
    11141122                                                // typedef enum { A } B is the only case?
    1115                                                 extracted_named = !extr->type->enumeration.anon;
     1123                                                extracted_named = ! extr->type->enumeration.anon;
    11161124                                        } else {
    11171125                                                extracted_named = true;

  • src/Parser/DeclarationNode.h

    r1761046 r46aa60e  
    99// Author           : Andrew Beach
    1010// Created On       : Wed Apr  5 11:38:00 2023
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Apr  5 11:55:00 2023
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sat Feb 17 09:24:12 2024
     13// Update Count     : 4
    1414//
    1515
    … …  
    8383        void checkQualifiers( const TypeData *, const TypeData * );
    8484        void checkSpecifiers( DeclarationNode * );
    85         DeclarationNode * copySpecifiers( DeclarationNode * );
    86         DeclarationNode * addType( DeclarationNode * );
     85        DeclarationNode * copySpecifiers( DeclarationNode *, bool = true );
     86        DeclarationNode * addType( DeclarationNode *, bool = true );
    8787        DeclarationNode * addTypedef();
    8888        DeclarationNode * addEnumBase( DeclarationNode * );
    … …  
    106106
    107107        DeclarationNode * cloneType( std::string * newName );
    108         DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
     108        DeclarationNode * cloneBaseType( DeclarationNode * newdecl, bool = true );
    109109
    110110        DeclarationNode * appendList( DeclarationNode * node ) {

  • src/Parser/TypeData.cc

    r1761046 r46aa60e  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec 14 18:59:12 2023
    13 // Update Count     : 684
     12// Last Modified On : Fri Feb 23 08:58:30 2024
     13// Update Count     : 734
    1414//
    1515
    … …  
    2020
    2121#include "AST/Decl.hpp"            // for AggregateDecl, ObjectDecl, TypeDe...
     22#include "AST/Attribute.hpp"       // for Attribute
    2223#include "AST/Init.hpp"            // for SingleInit, ListInit
    2324#include "AST/Print.hpp"           // for print
    2425#include "Common/SemanticError.h"  // for SemanticError
    2526#include "Common/utility.h"        // for splice, spliceBegin
     27#include "Common/Iterate.hpp"      // for reverseIterate
    2628#include "Parser/ExpressionNode.h" // for ExpressionNode
    2729#include "Parser/StatementNode.h"  // for StatementNode
    … …  
    199201                newtype->aggregate.kind = aggregate.kind;
    200202                newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
     203                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
    201204                newtype->aggregate.params = maybeCopy( aggregate.params );
    202205                newtype->aggregate.actuals = maybeCopy( aggregate.actuals );
    203206                newtype->aggregate.fields = maybeCopy( aggregate.fields );
     207                newtype->aggregate.attributes = aggregate.attributes;
    204208                newtype->aggregate.body = aggregate.body;
    205209                newtype->aggregate.anon = aggregate.anon;
    206210                newtype->aggregate.tagged = aggregate.tagged;
    207                 newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
    208211                break;
    209212        case AggregateInst:
    … …  
    336339                } // if
    337340                if ( aggregate.body ) {
    338                         os << string( indent + 2, ' ' ) << " with body" << endl;
     341                        os << string( indent + 2, ' ' ) << "with body" << endl;
     342                } // if
     343                if ( ! aggregate.attributes.empty() ) {
     344                        os << string( indent + 2, ' ' ) << "with attributes" << endl;
     345                        for ( ast::ptr<ast::Attribute> const & attr : reverseIterate( aggregate.attributes ) ) {
     346                                os << string( indent + 4, ' ' );
     347                                ast::print( os, attr, indent + 2 );
     348                        } // for
    339349                } // if
    340350                break;
    … …  
    358368                } // if
    359369                if ( enumeration.body ) {
    360                         os << string( indent + 2, ' ' ) << " with body" << endl;
     370                        os << string( indent + 2, ' ' ) << "with body" << endl;
    361371                } // if
    362372                if ( base ) {
    … …  
    10881098
    10891099ast::BaseInstType * buildComAggInst(
    1090                 const TypeData * type,
     1100                const TypeData * td,
    10911101                std::vector<ast::ptr<ast::Attribute>> && attributes,
    10921102                ast::Linkage::Spec linkage ) {
    1093         switch ( type->kind ) {
     1103        switch ( td->kind ) {
    10941104        case TypeData::Enum:
    1095                 if ( type->enumeration.body ) {
     1105                if ( td->enumeration.body ) {
    10961106                        ast::EnumDecl * typedecl =
    1097                                 buildEnum( type, std::move( attributes ), linkage );
     1107                                buildEnum( td, std::move( attributes ), linkage );
    10981108                        return new ast::EnumInstType(
    10991109                                typedecl,
    1100                                 buildQualifiers( type )
     1110                                buildQualifiers( td )
    11011111                        );
    11021112                } else {
    11031113                        return new ast::EnumInstType(
    1104                                 *type->enumeration.name,
    1105                                 buildQualifiers( type )
     1114                                *td->enumeration.name,
     1115                                buildQualifiers( td )
    11061116                        );
    11071117                } // if
    11081118                break;
    11091119        case TypeData::Aggregate:
    1110                 if ( type->aggregate.body ) {
     1120                if ( td->aggregate.body ) {
    11111121                        ast::AggregateDecl * typedecl =
    1112                                 buildAggregate( type, std::move( attributes ), linkage );
    1113                         switch ( type->aggregate.kind ) {
     1122                                buildAggregate( td, std::move( attributes ), linkage );
     1123                        switch ( td->aggregate.kind ) {
    11141124                        case ast::AggregateDecl::Struct:
    11151125                        case ast::AggregateDecl::Coroutine:
    … …  
    11181128                                return new ast::StructInstType(
    11191129                                        strict_dynamic_cast<ast::StructDecl *>( typedecl ),
    1120                                         buildQualifiers( type )
     1130                                        buildQualifiers( td )
    11211131                                );
    11221132                        case ast::AggregateDecl::Union:
    11231133                                return new ast::UnionInstType(
    11241134                                        strict_dynamic_cast<ast::UnionDecl *>( typedecl ),
    1125                                         buildQualifiers( type )
     1135                                        buildQualifiers( td )
    11261136                                );
    11271137                        case ast::AggregateDecl::Trait:
    … …  
    11321142                        } // switch
    11331143                } else {
    1134                         switch ( type->aggregate.kind ) {
     1144                        switch ( td->aggregate.kind ) {
    11351145                        case ast::AggregateDecl::Struct:
    11361146                        case ast::AggregateDecl::Coroutine:
    … …  
    11381148                        case ast::AggregateDecl::Thread:
    11391149                                return new ast::StructInstType(
    1140                                         *type->aggregate.name,
    1141                                         buildQualifiers( type )
     1150                                        *td->aggregate.name,
     1151                                        buildQualifiers( td )
    11421152                                );
    11431153                        case ast::AggregateDecl::Union:
    11441154                                return new ast::UnionInstType(
    1145                                         *type->aggregate.name,
    1146                                         buildQualifiers( type )
     1155                                        *td->aggregate.name,
     1156                                        buildQualifiers( td )
    11471157                                );
    11481158                        case ast::AggregateDecl::Trait:
    11491159                                return new ast::TraitInstType(
    1150                                         *type->aggregate.name,
    1151                                         buildQualifiers( type )
     1160                                        *td->aggregate.name,
     1161                                        buildQualifiers( td )
    11521162                                );
    11531163                        default:

  • src/Parser/TypeData.h

    r1761046 r46aa60e  
    99// Author           : Peter A. Buhr
    1010// Created On       : Sat May 16 15:18:36 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Mar  1 10:44:00 2023
    13 // Update Count     : 206
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Feb 22 16:30:31 2024
     13// Update Count     : 210
    1414//
    1515
    … …  
    3030                ast::AggregateDecl::Aggregate kind;
    3131                const std::string * name = nullptr;
     32                const std::string * parent = nullptr;
    3233                DeclarationNode * params = nullptr;
    3334                ExpressionNode * actuals = nullptr;                             // holds actual parameters later applied to AggInst
    3435                DeclarationNode * fields = nullptr;
     36                std::vector<ast::ptr<ast::Attribute>> attributes;
    3537                bool body;
    3638                bool anon;
    3739                bool tagged;
    38                 const std::string * parent = nullptr;
    3940        };
    4041

  • src/Parser/parser.yy

    r1761046 r46aa60e  
    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 ) ) ); }
    … …  
    18551897declaration_list:
    18561898        declaration
    1857         | declaration_list declaration
    1858                 { $$ = $1->appendList( $2 ); }
     1899        | declaration_list declaration          { $$ = $1->appendList( $2 ); }
    18591900        ;
    18601901
    … …  
    18891930declaration:                                                                                    // old & new style declarations
    18901931        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                 }
    18971932        | cfa_declaration ';'                                                           // CFA
    18981933        | static_assert                                                                         // C11
    … …  
    23472382sue_declaration_specifier:                                                              // struct, union, enum + storage class + type specifier
    23482383        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                 }
    23552384        | declaration_qualifier_list sue_type_specifier
    23562385                { $$ = $2->addQualifiers( $1 ); }
    … …  
    23632392sue_type_specifier:                                                                             // struct, union, enum + type specifier
    23642393        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                 }
    23712394        | type_qualifier_list
    23722395                { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type
    … …  
    24412464elaborated_type:                                                                                // struct, union, enum
    24422465        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                 }
    24492466        | enum_type
    24502467        ;
    … …  
    26782695                { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
    26792696        | 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; }
     2697                { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
    26812698        | ENUM attribute_list_opt identifier
    26822699                { typedefTable.makeTypedef( *$3, "enum_type 1" ); }
    … …  
    26932710                }
    26942711        | 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; }
     2712                { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
    26962713        | ENUM '(' ')' attribute_list_opt '{' enumerator_list comma_opt '}'
    26972714                {
    … …  
    26992716                }
    27002717        | 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; }
     2718                { SemanticError( yylloc, "syntax error, hiding ('!') the enumerator names of an anonymous enumeration means the names are inaccessible." ); $$ = nullptr; }
    27022719        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
    27032720                {
    … …  
    31703187                        // unit, which is a dubious task, especially because C uses name rather than structural typing; hence it is
    31713188                        // disallowed at the moment.
    3172                         if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static && $1->type && $1->type->kind == TypeData::AggregateInst ) {
     3189                        if ( $1->linkage == ast::Linkage::Cforall && ! $1->storageClasses.is_static &&
     3190                                 $1->type && $1->type->kind == TypeData::AggregateInst ) {
    31733191                                if ( $1->type->aggInst.aggregate->kind == TypeData::Enum && $1->type->aggInst.aggregate->enumeration.anon ) {
    31743192                                        SemanticError( yylloc, "extern anonymous enumeration is currently unimplemented." ); $$ = nullptr;

  • tests/.expect/attributes.x64.txt

    r1761046 r46aa60e  
    66
    77}
    8 struct __anonymous0 {
     8struct __attribute__ ((unused)) __anonymous0 {
    99};
    1010static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);

  • tests/errors/.expect/declaration.txt

    r1761046 r46aa60e  
    88  with members
    99    i: int
    10    with body
     10  with body
    1111
    1212
    … …  
    1414  with members
    1515    i: int
    16    with body
     16  with body
    1717
    1818
Note: See TracChangeset for help on using the changeset viewer.