Changeset 67467a3 for src/Parser/DeclarationNode.cc

Timestamp:

Mar 26, 2024, 3:17:51 PM (3 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

544b799

Parents:

84886499

Message:

Fused TypeData::Enum and TypeData::Aggregate, an enumeration is a kind of aggregate after all. There will always be some unused fields in Aggregate_t (but less in TypeData? overall) but the code is almost always simpler.

File:

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

src/Parser/DeclarationNode.cc

@@ -189 +189 @@
 
 DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base, EnumHiding hiding ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.anon = name == nullptr;
-        newnode->type->enumeration.name = newnode->type->enumeration.anon ? new string( DeclarationNode::anonymous.newName() ) : name;
-        newnode->type->enumeration.constants = constants;
-        newnode->type->enumeration.body = body;
-        newnode->type->enumeration.typed = typed;
-        newnode->type->enumeration.hiding = hiding;
+        DeclarationNode * newnode = newAggregate( ast::AggregateDecl::Enum, name, nullptr, constants, body );
+        newnode->type->aggregate.typed = typed;
+        newnode->type->aggregate.hiding = hiding;
         if ( base ) {
                 assert( typed );
@@ -549 +544 @@
         newaggr->aggregate.body = false;
         newaggr->aggregate.anon = oldaggr->aggregate.anon;
+        newaggr->aggregate.typed = oldaggr->aggregate.typed;
+        newaggr->aggregate.hiding = oldaggr->aggregate.hiding;
         swap( newaggr, oldaggr );
 
@@ -558 +555 @@
 
         moveUnionAttribute( olddecl, newdecl );
-
-        return newdecl;
-}
-
-// Helper for addTypedef, handles the case where the typedef wraps an
-// enumeration declaration (not a type), returns a chain of nodes.
-static DeclarationNode * addTypedefEnum(
-                DeclarationNode * olddecl, TypeData * newtype ) {
-        TypeData *& oldenum = olddecl->type->aggInst.aggregate;
-
-        // Handle anonymous enumeration: typedef enum { A, B, C } foo
-        // Give the typedefed type a consistent name across translation units.
-        if ( oldenum->enumeration.anon ) {
-                delete oldenum->enumeration.name;
-                oldenum->enumeration.name = new string( "__anonymous_" + *olddecl->name );
-                oldenum->enumeration.anon = false;
-                oldenum->qualifiers.reset();
-        }
-
-        // Replace the wrapped TypeData with a forward declaration.
-        TypeData * newenum = new TypeData( TypeData::Enum );
-        newenum->enumeration.name = oldenum->enumeration.name ? new string( *oldenum->enumeration.name ) : nullptr;
-        newenum->enumeration.body = false;
-        newenum->enumeration.anon = oldenum->enumeration.anon;
-        newenum->enumeration.typed = oldenum->enumeration.typed;
-        newenum->enumeration.hiding = oldenum->enumeration.hiding;
-        swap( newenum, oldenum );
-
-        newtype->base = olddecl->type;
-        olddecl->type = newtype;
-        DeclarationNode * newdecl = new DeclarationNode;
-        newdecl->type = newenum;
-        newdecl->next = olddecl;
 
         return newdecl;
@@ -610 +574 @@
                         && type->aggInst.aggregate->aggregate.body ) {
                 return addTypedefAggr( this, newtype );
-        // If this typedef is wrapping an enumeration, separate them out.
-        } else if ( TypeData::AggregateInst == type->kind
-                        && TypeData::Enum == type->aggInst.aggregate->kind
-                        && type->aggInst.aggregate->enumeration.body ) {
-                return addTypedefEnum( this, newtype );
         // There is no internal declaration, just a type.
         } else {
@@ -854 +813 @@
                                                 // typedef struct { int A } B is the only case?
                                                 extracted_named = ! extr->type->aggregate.anon;
-                                        } else if ( extr->type->kind == TypeData::Enum ) {
-                                                // typedef enum { A } B is the only case?
-                                                extracted_named = ! extr->type->enumeration.anon;
                                         } else {
                                                 extracted_named = true;
@@ -1063 +1019 @@
 
         switch ( type->kind ) {
-        case TypeData::Enum:
         case TypeData::Aggregate: {
                 ast::BaseInstType * ret =