Changeset 3d7e53b for src/Parser/DeclarationNode.cc

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

File:

• src/Parser/DeclarationNode.cc (modified) (7 diffs)

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;