Changes in src/Parser/DeclarationNode.cc [3d7e53b:284da8c]

File:

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

src/Parser/DeclarationNode.cc

@@ -254 +254 @@
 } // DeclarationNode::newFromTypedef
 
-DeclarationNode * DeclarationNode::newFromGlobalScope() {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::GlobalScope );
-        return newnode;
-}
-
-DeclarationNode * DeclarationNode::newQualifiedType( DeclarationNode * parent, DeclarationNode * child) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Qualified );
-        newnode->type->qualified.parent = parent->type;
-        newnode->type->qualified.child = child->type;
-        parent->type = nullptr;
-        child->type = nullptr;
-        delete parent;
-        delete child;
-        return newnode;
-}
-
 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 == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->aggregate.name = name;
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
@@ -282 +265 @@
         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 == nullptr ? new string( DeclarationNode::anonymous.newName() ) : name;
+        newnode->type->enumeration.name = name;
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
-        newnode->type->enumeration.anon = name == nullptr;
         return newnode;
 } // DeclarationNode::newEnum
@@ -971 +953 @@
         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;
@@ -996 +965 @@
                         Declaration * decl = cur->build();
                         if ( 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;
-                                }
+                                decl->location = cur->location;
+                                * out++ = decl;
                         } // if
                 } catch( SemanticErrorException &e ) {
@@ -1017 +978 @@
 } // buildList
 
-// currently only builds assertions, function parameters, and return values
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
         SemanticErrorException errors;
@@ -1025 +985 @@
                 try {
                         Declaration * decl = cur->build();
-                        assert( decl );
-                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
-                                dwt->location = cur->location;
-                                * out++ = dwt;
-                        } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
-                                // e.g., int foo(struct S) {}
-                                StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->name );
-                                auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
-                                obj->location = cur->location;
-                                * out++ = obj;
-                                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;
-                                * out++ = obj;
+                        if ( decl ) {
+                                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                        dwt->location = cur->location;
+                                        * out++ = dwt;
+                                } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
+                                        StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
+                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                        obj->location = cur->location;
+                                        * out++ = obj;
+                                        delete agg;
+                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
+                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                        obj->location = cur->location;
+                                        * out++ = obj;
+                                } // if
                         } // if
                 } catch( SemanticErrorException &e ) {