Fix #42: Support attributes on anonymous struct types (#96)

This commit adds support for parsing and generating C code with attributes
on anonymous struct types, such as `struct __attribute__((packed)) { ... };`
and `struct { ... } __attribute__((packed));`.

Implementation details:
- Added StructExt class to extend c_ast.Struct with attribute support
- Added three parser rules to handle different attribute positions:
  * Attributes before anonymous struct body
  * Attributes before named struct body
  * Attributes after anonymous struct in declarations
- Updated generator with visit_StructExt method to output attributes
- Enhanced test cases with round-trip verification

The fix handles both syntactic forms and ensures proper code generation
and round-trip parsing.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: retif

pycparserext/ext_c_generator.py

@@ -162,6 +162,18 @@ def visit_TypeList(self, n):
     def visit_RangeExpression(self, n):
         return "%s ... %s" % (self.visit(n.first), self.visit(n.last))
 
+    def visit_Struct(self, n):
+        """Generate code for struct, handling attributes if present."""
+        s = self._generate_struct_union_enum(n, "struct")
+        # If this is a StructExt with attributes, add them
+        if hasattr(n, "attrib") and n.attrib:
+            s += " " + self.visit(n.attrib)
+        return s
+
+    def visit_StructExt(self, n):
+        """Generate code for StructExt with attributes."""
+        return self.visit_Struct(n)
+
 
 class GNUCGenerator(GnuCGenerator):
     def __init__(self):

pycparserext/ext_c_parser.py

@@ -216,6 +216,18 @@ def from_pycparser(ad):
         )
 
 
+class StructExt(c_ast.Struct):
+    """Extended Struct that can hold attributes."""
+    @staticmethod
+    def from_pycparser(st):
+        assert isinstance(st, c_ast.Struct)
+        return StructExt(
+            name=st.name,
+            decls=st.decls,
+            coord=st.coord
+        )
+
+
 def to_decl_ext(d):
     if isinstance(d, c_ast.TypeDecl):
         return TypeDeclExt.from_pycparser(d)
@@ -589,6 +601,44 @@ def p_struct_declaration_list_1(self, p):
         """ struct_declaration_list : empty """
         p[0] = None
 
+    # Support attributes on anonymous struct/union declarations
+    # e.g., struct { int a; } __attribute__((packed));
+    def p_struct_declaration_anonymous_with_attr(self, p):
+        """ struct_declaration : specifier_qualifier_list attributes_opt SEMI
+        """
+        spec = p[1]
+        attr_decl = p[2]
+        assert "typedef" not in spec["storage"]
+
+        # Anonymous struct/union with attributes
+        if len(spec["type"]) == 1:
+            node = spec["type"][0]
+            if isinstance(node, c_ast.Node):
+                decl_type = node
+
+                # If we have attributes and this is a Struct/Union, attach them
+                if attr_decl and attr_decl.exprs and isinstance(node, c_ast.Struct):
+                    # Convert to StructExt and attach attributes
+                    if not isinstance(node, StructExt):
+                        struct_ext = StructExt.from_pycparser(node)
+                        struct_ext.attrib = AttributeSpecifier(attr_decl)
+                        decl_type = struct_ext
+                    else:
+                        node.attrib = AttributeSpecifier(attr_decl)
+            else:
+                decl_type = c_ast.IdentifierType(node)
+
+            decls = self._build_declarations(
+                spec=spec,
+                decls=[{"decl": decl_type}])
+        else:
+            # Structure/union members can have the same names as typedefs
+            decls = self._build_declarations(
+                spec=spec,
+                decls=[{"decl": None, "init": None}])
+
+        p[0] = decls
+
     def p_range_designator(self, p):
         """ designator  : LBRACKET constant_expression \
                             ELLIPSIS constant_expression RBRACKET
@@ -611,6 +661,70 @@ def p_unified_volatile_gnu(self, p):
                              | __VOLATILE__
         """
         p[0] = p[1]
+
+    # Support attributes on struct/union types
+    # struct __attribute__((packed)) { int a; };
+    def p_struct_or_union_specifier_with_attr_1(self, p):
+        """struct_or_union_specifier  : struct_or_union attributes_opt \
+                brace_open struct_declaration_list brace_close
+                                      | struct_or_union attributes_opt \
+                brace_open brace_close
+        """
+        klass = self._select_struct_union_class(p[1])
+        attr_decl = p[2]
+
+        if len(p) == 5:
+            # Empty struct/union
+            struct = klass(
+                name=None,
+                decls=[],
+                coord=self._token_coord(p, 1))
+        else:
+            struct = klass(
+                name=None,
+                decls=p[4],
+                coord=self._token_coord(p, 1))
+
+        # Attach attributes if present
+        if attr_decl and attr_decl.exprs:
+            struct_ext = StructExt.from_pycparser(struct)
+            struct_ext.attrib = AttributeSpecifier(attr_decl)
+            p[0] = struct_ext
+        else:
+            p[0] = struct
+
+    def p_struct_or_union_specifier_with_attr_2(self, p):
+        """struct_or_union_specifier  : struct_or_union ID attributes_opt \
+                brace_open struct_declaration_list brace_close
+                                      | struct_or_union ID attributes_opt \
+                brace_open brace_close
+                                      | struct_or_union TYPEID \
+                attributes_opt brace_open struct_declaration_list brace_close
+                                      | struct_or_union TYPEID \
+                attributes_opt brace_open brace_close
+        """
+        klass = self._select_struct_union_class(p[1])
+        attr_decl = p[3]
+
+        if len(p) == 6:
+            # Empty struct/union with name
+            struct = klass(
+                name=p[2],
+                decls=[],
+                coord=self._token_coord(p, 2))
+        else:
+            struct = klass(
+                name=p[2],
+                decls=p[5],
+                coord=self._token_coord(p, 2))
+
+        # Attach attributes if present
+        if attr_decl and attr_decl.exprs:
+            struct_ext = StructExt.from_pycparser(struct)
+            struct_ext.attrib = AttributeSpecifier(attr_decl)
+            p[0] = struct_ext
+        else:
+            p[0] = struct
 # }}}
 
 

test/test_pycparserext.py

@@ -687,6 +687,74 @@ def test_pointer_to_function_with_attribute():
     assert _round_trip_matches(src)
 
 
+def test_packed_anonymous_struct_in_struct():
+    from pycparser import c_ast
+
+    from pycparserext.ext_c_parser import GnuCParser
+    parser = GnuCParser()
+    code = """
+    struct foo_t {
+        struct __attribute__((packed)) {
+            int a;
+            char b;
+        };
+    };
+    """
+    ast = parser.parse(code)
+    assert isinstance(ast, c_ast.FileAST)
+    assert len(ast.ext) == 1
+    decl = ast.ext[0]
+    assert isinstance(decl, c_ast.Decl)
+    struct_foo = decl.type
+    assert isinstance(struct_foo, c_ast.Struct)
+    assert struct_foo.name == "foo_t"
+    assert len(struct_foo.decls) == 1
+    anon_struct_decl = struct_foo.decls[0]
+    assert isinstance(anon_struct_decl, c_ast.Decl)
+    anon_struct = anon_struct_decl.type
+    assert isinstance(anon_struct, c_ast.Struct)
+    assert anon_struct.name is None
+    assert hasattr(anon_struct, "attrib")
+    assert anon_struct.attrib is not None
+
+    # Verify round-trip code generation
+    assert _round_trip_matches(code)
+
+
+def test_packed_anonymous_struct_in_struct_after():
+    from pycparser import c_ast
+
+    from pycparserext.ext_c_parser import GnuCParser
+    parser = GnuCParser()
+    code = """
+    struct foo_t {
+        struct {
+            int a;
+            char b;
+        } __attribute__((packed));
+    };
+    """
+    ast = parser.parse(code)
+    assert isinstance(ast, c_ast.FileAST)
+    assert len(ast.ext) == 1
+    decl = ast.ext[0]
+    assert isinstance(decl, c_ast.Decl)
+    struct_foo = decl.type
+    assert isinstance(struct_foo, c_ast.Struct)
+    assert struct_foo.name == "foo_t"
+    assert len(struct_foo.decls) == 1
+    anon_struct_decl = struct_foo.decls[0]
+    assert isinstance(anon_struct_decl, c_ast.Decl)
+    anon_struct = anon_struct_decl.type
+    assert isinstance(anon_struct, c_ast.Struct)
+    assert anon_struct.name is None
+    assert hasattr(anon_struct, "attrib")
+    assert anon_struct.attrib is not None
+
+    # Verify round-trip code generation
+    assert _round_trip_matches(code)
+
+
 if __name__ == "__main__":
     import sys
     if len(sys.argv) > 1: