Changeset 3d7e53b


Ignore:
Timestamp:
Jul 10, 2018, 11:09:19 AM (3 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
5cacf74
Parents:
aeec6b7
Message:

Add anon flag to TypeData? and remove anonymous members for named aggregates

Location:
src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    raeec6b7 r3d7e53b  
    273273
    274274DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
    275         assert( name );
    276275        DeclarationNode * newnode = new DeclarationNode;
    277276        newnode->type = new TypeData( TypeData::Aggregate );
    278277        newnode->type->aggregate.kind = kind;
    279         newnode->type->aggregate.name = name;
     278        newnode->type->aggregate.name =  name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
    280279        newnode->type->aggregate.actuals = actuals;
    281280        newnode->type->aggregate.fields = fields;
     
    283282        newnode->type->aggregate.tagged = false;
    284283        newnode->type->aggregate.parent = nullptr;
     284        newnode->type->aggregate.anon = name == nullptr;
    285285        return newnode;
    286286} // DeclarationNode::newAggregate
    287287
    288288DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body ) {
    289         assert( name );
    290289        DeclarationNode * newnode = new DeclarationNode;
    291290        newnode->type = new TypeData( TypeData::Enum );
    292         newnode->type->enumeration.name = name;
     291        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
    293292        newnode->type->enumeration.constants = constants;
    294293        newnode->type->enumeration.body = body;
     294        newnode->type->enumeration.anon = name == nullptr;
    295295        return newnode;
    296296} // DeclarationNode::newEnum
     
    971971        for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
    972972                try {
     973                        bool extracted = false;
     974                        bool anon = false;
    973975                        if ( DeclarationNode * extr = cur->extractAggregate() ) {
    974976                                // handle the case where a structure declaration is contained within an object or type declaration
    975977                                Declaration * decl = extr->build();
    976978                                if ( decl ) {
     979                                        // hoist the structure declaration
    977980                                        decl->location = cur->location;
    978981                                        * out++ = decl;
     982
     983                                        // need to remember the cases where a declaration contains an anonymous aggregate definition
     984                                        extracted = true;
     985                                        assert( extr->type );
     986                                        if ( extr->type->kind == TypeData::Aggregate ) {
     987                                                anon = extr->type->aggregate.anon;
     988                                        } else if ( extr->type->kind == TypeData::Enum ) {
     989                                                // xxx - is it useful to have an implicit anonymous enum member?
     990                                                anon = extr->type->enumeration.anon;
     991                                        }
    979992                                } // if
    980993                                delete extr;
     
    983996                        Declaration * decl = cur->build();
    984997                        if ( decl ) {
    985                                 decl->location = cur->location;
    986                                 * out++ = decl;
     998                                // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
     999                                // struct S {
     1000                                //   struct T { int x; }; // no anonymous member
     1001                                //   struct { int y; };   // anonymous member
     1002                                //   struct T;            // anonymous member
     1003                                // };
     1004                                if ( ! (extracted && decl->name == "" && ! anon) ) {
     1005                                        decl->location = cur->location;
     1006                                        * out++ = decl;
     1007                                }
    9871008                        } // if
    9881009                } catch( SemanticErrorException &e ) {
     
    9961017} // buildList
    9971018
     1019// currently only builds assertions, function parameters, and return values
    9981020void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
    9991021        SemanticErrorException errors;
     
    10081030                                * out++ = dwt;
    10091031                        } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
    1010                                 // xxx - this might be where anonymous struct members are added - should be conditional on struct name
     1032                                // e.g., int foo(struct S) {}
    10111033                                StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
    10121034                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     
    10151037                                delete agg;
    10161038                        } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
     1039                                // e.g., int foo(union U) {}
    10171040                                UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
     1041                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
     1042                                obj->location = cur->location;
     1043                                * out++ = obj;
     1044                        } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
     1045                                // e.g., int foo(enum E) {}
     1046                                EnumInstType * inst = new EnumInstType( Type::Qualifiers(), agg->name );
    10181047                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
    10191048                                obj->location = cur->location;
  • src/Parser/TypeData.cc

    raeec6b7 r3d7e53b  
    6363                enumeration.constants = nullptr;
    6464                enumeration.body = false;
     65                enumeration.anon = false;
    6566                break;
    6667          case Aggregate:
     
    7475                aggregate.tagged = false;
    7576                aggregate.parent = nullptr;
     77                aggregate.anon = false;
    7678                break;
    7779          case AggregateInst:
     
    216218                newtype->aggregate.fields = maybeClone( aggregate.fields );
    217219                newtype->aggregate.body = aggregate.body;
     220                newtype->aggregate.anon = aggregate.anon;
    218221                newtype->aggregate.tagged = aggregate.tagged;
    219222                newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
     
    228231                newtype->enumeration.constants = maybeClone( enumeration.constants );
    229232                newtype->enumeration.body = enumeration.body;
     233                newtype->enumeration.anon = enumeration.anon;
    230234                break;
    231235          case Symbolic:
  • src/Parser/TypeData.h

    raeec6b7 r3d7e53b  
    3636                DeclarationNode * fields;
    3737                bool body;
     38                bool anon;
    3839
    3940                bool tagged;
     
    5758                DeclarationNode * constants;
    5859                bool body;
     60                bool anon;
    5961        };
    6062
  • src/Parser/parser.yy

    raeec6b7 r3d7e53b  
    18571857aggregate_type:                                                                                 // struct, union
    18581858        aggregate_key attribute_list_opt '{' field_declaration_list_opt '}' type_parameters_opt
    1859                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $6, $4, true )->addQualifiers( $2 ); }
     1859                { $$ = DeclarationNode::newAggregate( $1, nullptr, $6, $4, true )->addQualifiers( $2 ); }
    18601860        | aggregate_key attribute_list_opt no_attr_identifier fred
    18611861                {
     
    19811981enum_type:                                                                                              // enum
    19821982        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
    1983                 { $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
     1983                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
    19841984        | ENUM attribute_list_opt no_attr_identifier
    19851985                { typedefTable.makeTypedef( *$3 ); }
  • src/tests/nested-types.c

    raeec6b7 r3d7e53b  
    1616typedef int N;
    1717struct A {
    18   // forall(otype T) // xxx - should not be an error, but currently is
    19   // struct N {
    20   //   T x;
    21   // };
     18  forall(otype T) // xxx - should not be an error, but currently is
     19  struct N {
     20    T x;
     21  };
    2222};
    2323
Note: See TracChangeset for help on using the changeset viewer.