fix: solve the last remaining bugs I could find in the codebase

Author: MrIndeciso

docs/advanced/alignment.md

@@ -109,7 +109,7 @@ class s_t(struct):
     b: c_int = offset(3)   # placed at offset 3, not rounded to 4
     c: c_int               # aligned normally after b
 
-size_of(s_t)  # 7 (3 + 4)
+size_of(s_t)  # 12 (b at offset 3 + 4 bytes = 7, c aligned to offset 8 + 4 bytes = 12)
 ```
 
 ## alignment_of()

docs/advanced/forward_refs.md

@@ -50,14 +50,14 @@ memory[4:12] = pystruct.pack("<q", 12)   # next -> offset 12
 
 # Node 1 at offset 12
 memory[12:16] = pystruct.pack("<i", 20)
-memory[16:24] = pystruct.pack("<q", 0)   # next -> null
+memory[16:24] = pystruct.pack("<q", 0xDEAD)   # next -> out of bounds
 
 lib = inflater(memory)
 head = lib.inflate(Node, 0)
 
 print(head.val.value)                        # 10
 print(head.next.unwrap().val.value)          # 20
-print(head.next.unwrap().next.try_unwrap())  # None
+print(head.next.unwrap().next.try_unwrap())  # None (address out of bounds)
 ```
 
 ## Tree Example

docs/basics/pointers.md

@@ -54,13 +54,17 @@ class node_t(struct):
     val: c_int
     next: ptr[c_int]
 
-memory = b"\x0a\x00\x00\x00" + b"\x00" * 8  # val=10, next=null
+# next points to address 0xFF..FF which is out of bounds
+memory = b"\x0a\x00\x00\x00" + b"\xff" * 8
 node = node_t.from_bytes(memory)
 
 result = node.next.try_unwrap()
 print(result)  # None
 ```
 
+!!! note
+    A null pointer (address 0) is **not** automatically invalid — address 0 is a valid index in Python byte sequences. `try_unwrap()` only returns `None` when the address causes an `IndexError` or `ValueError` during resolution.
+
 ## Self-Referential Structs
 
 Use `ptr["TypeName"]` for self-referential structs:
@@ -94,16 +98,16 @@ import struct as pystruct
 # Node 0 at offset 0: val=10, next -> offset 12
 memory[0:4] = pystruct.pack("<i", 10)
 memory[4:12] = pystruct.pack("<q", 12)
-# Node 1 at offset 12: val=20, next -> null
+# Node 1 at offset 12: val=20, next -> out of bounds
 memory[12:16] = pystruct.pack("<i", 20)
-memory[16:24] = pystruct.pack("<q", 0)
+memory[16:24] = pystruct.pack("<q", 0xDEAD)
 
 lib = inflater(memory)
 head = lib.inflate(node_t, 0)
 
 print(head.val.value)                    # 10
 print(head.next.unwrap().val.value)      # 20
-print(head.next.unwrap().next.try_unwrap())  # None
+print(head.next.unwrap().next.try_unwrap())  # None (address out of bounds)
 ```
 
 ## Pointer Arithmetic

docs/memory/resolvers.md

@@ -49,10 +49,10 @@ All resolvers implement these methods:
 
 | Method | Description |
 |---|---|
-| `resolve(size, offset)` | Read `size` bytes starting at the resolved address + offset |
+| `resolve(size, index)` | Read `size` bytes starting at the resolved address + index |
 | `resolve_address()` | Return the absolute address of this resolver |
 | `modify(size, index, value)` | Write `value` bytes at the resolved address + index |
-| `relative_from_own(offset, size)` | Create a child resolver at a relative offset |
+| `relative_from_own(address_offset, index_offset)` | Create a child resolver at a relative offset |
 | `absolute_from_own(address)` | Create a child resolver at an absolute address |
 
 ## Custom Memory Backends

libdestruct/c/struct_parser.py

@@ -97,7 +97,8 @@ def definition_to_type(definition: str) -> type[obj]:
 
     result = struct_to_type(root)
 
-    PARSED_STRUCTS[root.name] = result
+    if root.name:
+        PARSED_STRUCTS[root.name] = result
 
     return result
 
@@ -170,6 +171,9 @@ def arr_to_type(arr: c_ast.ArrayDecl) -> type[obj]:
 
     typ = ptr_to_type(arr.type) if isinstance(arr.type, c_ast.PtrDecl) else type_decl_to_type(arr.type)
 
+    if arr.dim is None:
+        raise ValueError("Unsized arrays (flexible array members) are not supported.")
+
     return array_of(typ, int(arr.dim.value))
 
 

libdestruct/common/array/array_impl.py

@@ -48,6 +48,10 @@ def count(self: array_impl) -> int:
 
     def get(self: array, index: int = -1) -> object:
         """Return the element at the given index, or all elements if index is -1."""
+        if hasattr(self, "_frozen_elements"):
+            if index == -1:
+                return list(self._frozen_elements)
+            return self._frozen_elements[index]
         if index == -1:
             return [self.backing_type(self.resolver.relative_from_own(i * self.item_size, 0)) for i in range(self._count)]
         return self.backing_type(self.resolver.relative_from_own(index * self.item_size, 0))
@@ -64,8 +68,21 @@ def to_dict(self: array_impl) -> list[object]:
         """Return a JSON-serializable list of element values."""
         return [elem.to_dict() for elem in self]
 
+    def freeze(self: array_impl) -> None:
+        """Freeze the array, individually freezing each element."""
+        self._frozen_elements = [
+            self.backing_type(self.resolver.relative_from_own(i * self.item_size, 0))
+            for i in range(self._count)
+        ]
+        for elem in self._frozen_elements:
+            elem.freeze()
+        self._frozen_array_bytes = b"".join(bytes(x) for x in self._frozen_elements)
+        super().freeze()
+
     def to_bytes(self: array_impl) -> bytes:
         """Return the serialized representation of the array."""
+        if self._frozen:
+            return self._frozen_array_bytes
         return b"".join(bytes(x) for x in self)
 
     def to_str(self: array_impl, indent: int = 0) -> str:
@@ -87,5 +104,8 @@ def __setitem__(self: array_impl, index: int, value: obj) -> None:
 
     def __iter__(self: array_impl) -> Generator[obj, None, None]:
         """Iterate over the array."""
-        for i in range(self._count):
-            yield self[i]
+        if self._frozen:
+            yield from self._frozen_elements
+        else:
+            for i in range(self._count):
+                yield self[i]

libdestruct/common/enum/enum.py

@@ -64,7 +64,7 @@ def get(self: enum) -> Enum:
 
     def _set(self: enum, value: Enum) -> None:
         """Set the value of the enum."""
-        self._backing_type.set(value.value)
+        self._backing_type.set(int(value))
 
     def to_bytes(self: enum) -> bytes:
         """Return the serialized representation of the enum."""

libdestruct/common/obj.py

@@ -77,8 +77,8 @@ def set(self: obj, value: object) -> None:
 
     def freeze(self: obj) -> None:
         """Freeze the object."""
-        self._frozen_value = self.get()
-        self._frozen = True
+        object.__setattr__(self, "_frozen_value", self.get())
+        object.__setattr__(self, "_frozen", True)
 
     def diff(self: obj) -> tuple[object, object]:
         """Return the difference between the current value and the frozen value."""
@@ -97,7 +97,7 @@ def reset(self: obj) -> None:
     def update(self: obj) -> None:
         """Update the object with the given value."""
         try:
-            self._frozen_value = self.get()
+            object.__setattr__(self, "_frozen_value", self.get())
         except ValueError as e:
             raise RuntimeError("Could not update the object.") from e
 

libdestruct/common/ptr/ptr.py

@@ -103,7 +103,7 @@ def unwrap(self: ptr, length: int | None = None) -> obj | bytes:
             result = self.wrapper(self.resolver.absolute_from_own(address))
         else:
             target_resolver = self.resolver.absolute_from_own(address)
-            result = target_resolver.resolve(length or 1, 0)
+            result = target_resolver.resolve(length if length is not None else 1, 0)
 
         self._cached_unwrap = result
         self._cache_valid = True
@@ -123,7 +123,7 @@ def try_unwrap(self: ptr, length: int | None = None) -> obj | bytes | None:
 
         try:
             # If the address is invalid, this will raise an IndexError or ValueError.
-            self.resolver.absolute_from_own(address).resolve(length or 1, 0)
+            self.resolver.absolute_from_own(address).resolve(length if length is not None else 1, 0)
         except (IndexError, ValueError):
             return None
 

libdestruct/common/struct/struct_impl.py

@@ -49,8 +49,8 @@ def __init__(self: struct_impl, resolver: Resolver | None = None, **kwargs: ...)
         # struct overrides the __init__ method, so we need to call the parent class __init__ method
         obj.__init__(self, resolver)
 
-        self._struct_name = self.__class__.__name__
-        self._members = {}
+        object.__setattr__(self, "_struct_name", self.__class__.__name__)
+        object.__setattr__(self, "_members", {})
 
         reference_type = self._reference_struct
         self._inflate_struct_attributes(self._inflater, resolver, reference_type)
@@ -69,6 +69,17 @@ def __getattribute__(self: struct_impl, name: str) -> object:
             pass
         return super().__getattribute__(name)
 
+    def __setattr__(self: struct_impl, name: str, value: object) -> None:
+        """Set an attribute, delegating to member.value for struct fields."""
+        try:
+            members = object.__getattribute__(self, "_members")
+            if name in members:
+                members[name].value = value
+                return
+        except AttributeError:
+            pass
+        object.__setattr__(self, name, value)
+
     def __new__(cls: struct_impl, *args: ..., **kwargs: ...) -> Self:
         """Create a new struct."""
         # Skip the __new__ method of the parent class
@@ -82,9 +93,10 @@ def _inflate_struct_attributes(
         reference_type: type,
     ) -> None:
         current_offset = 0
+        max_alignment = 1
         bf_tracker = BitfieldTracker()
         aligned = getattr(reference_type, "_aligned_", False)
-        self._member_offsets = {}
+        object.__setattr__(self, "_member_offsets", {})
 
         for name, annotation, reference in iterate_annotation_chain(reference_type, terminate_at=struct):
             if name == "_aligned_":
@@ -103,7 +115,9 @@ def _inflate_struct_attributes(
             if bitfield_field:
                 if aligned and bf_tracker.needs_new_group(bitfield_field):
                     current_offset += bf_tracker.flush()
-                    current_offset = _align_offset(current_offset, alignment_of(bitfield_field.backing_type))
+                    field_align = alignment_of(bitfield_field.backing_type)
+                    max_alignment = max(max_alignment, field_align)
+                    current_offset = _align_offset(current_offset, field_align)
                 self._member_offsets[name] = current_offset
                 result, offset_delta = bf_tracker.create_bitfield(
                     bitfield_field, inflater, resolver, current_offset,
@@ -112,7 +126,18 @@ def _inflate_struct_attributes(
             else:
                 current_offset += bf_tracker.flush()
                 if aligned and explicit_offset is None:
-                    current_offset = _align_offset(current_offset, alignment_of(resolved_type))
+                    # Try alignment from the resolved type directly; for closures
+                    # (e.g. union inflaters) alignment_of can't inspect them, so
+                    # fall back to creating a probe instance.
+                    field_align = alignment_of(resolved_type)
+                    if field_align <= 1:
+                        try:
+                            probe = resolved_type(resolver.relative_from_own(current_offset, 0))
+                            field_align = alignment_of(probe)
+                        except (ValueError, TypeError):
+                            pass
+                    max_alignment = max(max_alignment, field_align)
+                    current_offset = _align_offset(current_offset, field_align)
                 self._member_offsets[name] = current_offset
                 result = resolved_type(resolver.relative_from_own(current_offset, 0))
                 current_offset += size_of(result)
@@ -121,16 +146,22 @@ def _inflate_struct_attributes(
 
         current_offset += bf_tracker.flush()
 
+        # Apply tail padding for aligned structs
+        if aligned:
+            if isinstance(aligned, int) and aligned is not True:
+                max_alignment = max(max_alignment, aligned)
+            current_offset = _align_offset(current_offset, max_alignment)
+
         # For VLA structs, size must be computed dynamically since the count
         # can change at runtime.  Detect VLA by duck-typing: vla_impl has a
         # _count_member attribute that plain array_impl does not.
         members = object.__getattribute__(self, "_members")
         last_member = list(members.values())[-1] if members else None
         if last_member is not None and hasattr(last_member, "_count_member"):
-            last_name = list(self._members.keys())[-1]
-            self._vla_fixed_offset = self._member_offsets[last_name]
+            last_name = list(members.keys())[-1]
+            object.__setattr__(self, "_vla_fixed_offset", self._member_offsets[last_name])
         else:
-            self.size = current_offset
+            object.__setattr__(self, "size", current_offset)
 
     @staticmethod
     def _resolve_field(
@@ -316,7 +347,7 @@ def freeze(self: struct_impl) -> None:
 
     def reset(self: struct_impl) -> None:
         """Reset each member to its frozen value."""
-        if not self._frozen:
+        if not object.__getattribute__(self, "_frozen"):
             raise RuntimeError("Cannot reset a struct that has not been frozen.")
 
         members = object.__getattribute__(self, "_members")