Changeset 3d7e53b

Timestamp:

Jul 10, 2018, 11:09:19 AM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

5cacf74

Parents:

aeec6b7

Message:

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

Location:

src

Files:

• Parser/DeclarationNode.cc (modified) (7 diffs)
• Parser/TypeData.cc (modified) (4 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• Parser/parser.yy (modified) (2 diffs)
• tests/nested-types.c (modified) (1 diff)

src/Parser/DeclarationNode.cc

@@ -273 +273 @@
 
 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
-        assert( name );
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = name;
+        newnode->type->aggregate.name =  name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
@@ -283 +282 @@
         newnode->type->aggregate.tagged = false;
         newnode->type->aggregate.parent = nullptr;
+        newnode->type->aggregate.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newAggregate
 
 DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body ) {
-        assert( name );
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.name = name;
+        newnode->type->enumeration.name = name == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
+        newnode->type->enumeration.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newEnum
@@ -971 +971 @@
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
                 try {
+                        bool extracted = false;
+                        bool anon = false;
                         if ( DeclarationNode * extr = cur->extractAggregate() ) {
                                 // handle the case where a structure declaration is contained within an object or type declaration
                                 Declaration * decl = extr->build();
                                 if ( decl ) {
+                                        // hoist the structure declaration
                                         decl->location = cur->location;
                                         * out++ = decl;
+
+                                        // need to remember the cases where a declaration contains an anonymous aggregate definition
+                                        extracted = true;
+                                        assert( extr->type );
+                                        if ( extr->type->kind == TypeData::Aggregate ) {
+                                                anon = extr->type->aggregate.anon;
+                                        } else if ( extr->type->kind == TypeData::Enum ) {
+                                                // xxx - is it useful to have an implicit anonymous enum member?
+                                                anon = extr->type->enumeration.anon;
+                                        }
                                 } // if
                                 delete extr;
@@ -983 +996 @@
                         Declaration * decl = cur->build();
                         if ( decl ) {
-                                decl->location = cur->location;
-                                * out++ = decl;
+                                // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.:
+                                // struct S {
+                                //   struct T { int x; }; // no anonymous member
+                                //   struct { int y; };   // anonymous member
+                                //   struct T;            // anonymous member
+                                // };
+                                if ( ! (extracted && decl->name == "" && ! anon) ) {
+                                        decl->location = cur->location;
+                                        * out++ = decl;
+                                }
                         } // if
                 } catch( SemanticErrorException &e ) {
@@ -996 +1017 @@
 } // buildList
 
+// currently only builds assertions, function parameters, and return values
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
         SemanticErrorException errors;
@@ -1008 +1030 @@
                                 * out++ = dwt;
                         } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
-                                // xxx - this might be where anonymous struct members are added - should be conditional on struct name
+                                // e.g., int foo(struct S) {}
                                 StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
@@ -1015 +1037 @@
                                 delete agg;
                         } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                                // e.g., int foo(union U) {}
                                 UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->name );
+                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                obj->location = cur->location;
+                                * out++ = obj;
+                        } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
+                                // e.g., int foo(enum E) {}
+                                EnumInstType * inst = new EnumInstType( Type::Qualifiers(), agg->name );
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;

src/Parser/TypeData.cc

@@ -63 +63 @@
                 enumeration.constants = nullptr;
                 enumeration.body = false;
+                enumeration.anon = false;
                 break;
           case Aggregate:
@@ -74 +75 @@
                 aggregate.tagged = false;
                 aggregate.parent = nullptr;
+                aggregate.anon = false;
                 break;
           case AggregateInst:
@@ -216 +218 @@
                 newtype->aggregate.fields = maybeClone( aggregate.fields );
                 newtype->aggregate.body = aggregate.body;
+                newtype->aggregate.anon = aggregate.anon;
                 newtype->aggregate.tagged = aggregate.tagged;
                 newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr;
@@ -228 +231 @@
                 newtype->enumeration.constants = maybeClone( enumeration.constants );
                 newtype->enumeration.body = enumeration.body;
+                newtype->enumeration.anon = enumeration.anon;
                 break;
           case Symbolic:

src/Parser/TypeData.h

@@ -36 +36 @@
                 DeclarationNode * fields;
                 bool body;
+                bool anon;
 
                 bool tagged;
@@ -57 +58 @@
                 DeclarationNode * constants;
                 bool body;
+                bool anon;
         };
 

src/Parser/parser.yy

@@ -1857 +1857 @@
 aggregate_type:                                                                                 // struct, union
         aggregate_key attribute_list_opt '{' field_declaration_list_opt '}' type_parameters_opt
-                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $6, $4, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newAggregate( $1, nullptr, $6, $4, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt no_attr_identifier fred
                 {
@@ -1981 +1981 @@
 enum_type:                                                                                              // enum
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt no_attr_identifier
                 { typedefTable.makeTypedef( *$3 ); }

src/tests/nested-types.c

@@ -16 +16 @@
 typedef int N;
 struct A {
-  // forall(otype T) // xxx - should not be an error, but currently is
-  // struct N {
-  //   T x;
-  // };
+  forall(otype T) // xxx - should not be an error, but currently is
+  struct N {
+    T x;
+  };
 };