fix: Opus found even more bugs, everything should be fixed now

Author: MrIndeciso

libdestruct/c/c_float_types.py

@@ -11,71 +11,54 @@
 from libdestruct.common.obj import obj
 
 
-class c_float(obj):
-    """A C float (IEEE 754 single-precision, 32-bit)."""
+class _c_float_base(obj):
+    """A generic C floating-point type, to be subclassed by c_float and c_double."""
 
-    size: int = 4
-    """The size of a float in bytes."""
+    size: int
+    """The size of the float in bytes."""
+
+    _format: str
+    """The struct format character ('f' or 'd')."""
 
     _frozen_value: float | None = None
     """The frozen value of the float."""
 
-    def _format_char(self: c_float) -> str:
-        return "<f" if self.endianness == "little" else ">f"
+    def _format_char(self: _c_float_base) -> str:
+        prefix = "<" if self.endianness == "little" else ">"
+        return prefix + self._format
 
-    def get(self: c_float) -> float:
+    def get(self: _c_float_base) -> float:
         """Return the value of the float."""
         return struct.unpack(self._format_char(), self.resolver.resolve(self.size, 0))[0]
 
-    def _set(self: c_float, value: float) -> None:
+    def _set(self: _c_float_base, value: float) -> None:
         """Set the value of the float."""
         self.resolver.modify(self.size, 0, struct.pack(self._format_char(), value))
 
-    def to_bytes(self: c_float) -> bytes:
+    def to_bytes(self: _c_float_base) -> bytes:
         """Return the serialized representation of the float."""
         if self._frozen:
             return struct.pack(self._format_char(), self._frozen_value)
         return self.resolver.resolve(self.size, 0)
 
-    def __float__(self: c_float) -> float:
+    def __float__(self: _c_float_base) -> float:
         """Return the value as a Python float."""
         return self.get()
 
-    def __int__(self: c_float) -> int:
+    def __int__(self: _c_float_base) -> int:
         """Return the value as a Python int."""
         return int(self.get())
 
 
-class c_double(obj):
-    """A C double (IEEE 754 double-precision, 64-bit)."""
-
-    size: int = 8
-    """The size of a double in bytes."""
-
-    _frozen_value: float | None = None
-    """The frozen value of the double."""
-
-    def _format_char(self: c_double) -> str:
-        return "<d" if self.endianness == "little" else ">d"
-
-    def get(self: c_double) -> float:
-        """Return the value of the double."""
-        return struct.unpack(self._format_char(), self.resolver.resolve(self.size, 0))[0]
+class c_float(_c_float_base):
+    """A C float (IEEE 754 single-precision, 32-bit)."""
 
-    def _set(self: c_double, value: float) -> None:
-        """Set the value of the double."""
-        self.resolver.modify(self.size, 0, struct.pack(self._format_char(), value))
+    size: int = 4
+    _format: str = "f"
 
-    def to_bytes(self: c_double) -> bytes:
-        """Return the serialized representation of the double."""
-        if self._frozen:
-            return struct.pack(self._format_char(), self._frozen_value)
-        return self.resolver.resolve(self.size, 0)
 
-    def __float__(self: c_double) -> float:
-        """Return the value as a Python float."""
-        return self.get()
+class c_double(_c_float_base):
+    """A C double (IEEE 754 double-precision, 64-bit)."""
 
-    def __int__(self: c_double) -> int:
-        """Return the value as a Python int."""
-        return int(self.get())
+    size: int = 8
+    _format: str = "d"

libdestruct/common/array/array_field_inflater.py

@@ -43,8 +43,8 @@ def _subscripted_array_handler(
     if len(args) != 2:
         return None
     element_type, count = args
-    if not isinstance(count, int):
-        return None
+    if not isinstance(count, int) or count <= 0:
+        raise ValueError(f"array count must be a positive integer, got {count}")
     field = LinearArrayField(element_type, count)
     field.item = registry.inflater_for(element_type)
     return field.inflate

libdestruct/common/obj.py

@@ -136,7 +136,11 @@ def _compare_value(self: obj, other: object) -> tuple[object, object] | None:
         """Extract comparable values from self and other, or None if incompatible."""
         self_val = self.value
         if isinstance(other, obj):
-            return self_val, other.value
+            other_val = other.value
+            # Guard against incompatible value types (e.g. int vs str from struct.get())
+            if type(self_val) is not type(other_val) and not isinstance(self_val, type(other_val)) and not isinstance(other_val, type(self_val)):
+                return None
+            return self_val, other_val
         if isinstance(other, int | float | bytes):
             return self_val, other
         return None

libdestruct/common/struct/struct_impl.py

@@ -245,20 +245,22 @@ def get(self: struct_impl) -> str:
 
     def to_bytes(self: struct_impl) -> bytes:
         """Return the serialized representation of the struct, including padding."""
-        if self._frozen:
-            return self._frozen_struct_bytes
+        if object.__getattribute__(self, "_frozen"):
+            return object.__getattribute__(self, "_frozen_struct_bytes")
         resolver = object.__getattribute__(self, "resolver")
         return resolver.resolve(size_of(self), 0)
 
     def to_dict(self: struct_impl) -> dict[str, object]:
         """Return a JSON-serializable dict of field names to values."""
-        return {name: member.to_dict() for name, member in self._members.items()}
+        members = object.__getattribute__(self, "_members")
+        return {name: member.to_dict() for name, member in members.items()}
 
     def hexdump(self: struct_impl) -> str:
         """Return a hex dump of this struct's bytes with field annotations."""
         member_offsets = object.__getattribute__(self, "_member_offsets")
-        annotations = {member_offsets[name]: name for name in self._members}
-        address = struct_impl.address.fget(self) if not self._frozen else 0
+        members = object.__getattribute__(self, "_members")
+        annotations = {member_offsets[name]: name for name in members}
+        address = struct_impl.address.fget(self) if not object.__getattribute__(self, "_frozen") else 0
         return format_hexdump(self.to_bytes(), address, annotations)
 
     def _set(self: struct_impl, _: str) -> None:
@@ -268,18 +270,20 @@ def _set(self: struct_impl, _: str) -> None:
     def freeze(self: struct_impl) -> None:
         """Freeze the struct, capturing the full byte representation including padding."""
         resolver = object.__getattribute__(self, "resolver")
-        self._frozen_struct_bytes = resolver.resolve(size_of(self), 0)
+        object.__setattr__(self, "_frozen_struct_bytes", resolver.resolve(size_of(self), 0))
 
-        for member in self._members.values():
+        members = object.__getattribute__(self, "_members")
+        for member in members.values():
             member.freeze()
 
         super().freeze()
 
     def to_str(self: struct_impl, indent: int = 0) -> str:
         """Return a string representation of the struct."""
         name = object.__getattribute__(self, "_struct_name")
+        members_dict = object.__getattribute__(self, "_members")
         members = ",\n".join(
-            [f"{' ' * (indent + 4)}{n}: {member.to_str(indent + 4)}" for n, member in self._members.items()],
+            [f"{' ' * (indent + 4)}{n}: {member.to_str(indent + 4)}" for n, member in members_dict.items()],
         )
         return f"""{name} {{
 {members}
@@ -289,7 +293,8 @@ def __repr__(self: struct_impl) -> str:
         """Return a string representation of the struct."""
         name = object.__getattribute__(self, "_struct_name")
         addr = struct_impl.address.fget(self)
-        members = ",\n".join([f"{n}: {member}" for n, member in self._members.items()])
+        members_dict = object.__getattribute__(self, "_members")
+        members = ",\n".join([f"{n}: {member}" for n, member in members_dict.items()])
         return f"""{name} {{
     address: 0x{addr:x},
     size: 0x{size_of(self):x},
@@ -306,7 +311,10 @@ def __eq__(self: struct_impl, value: object) -> bool:
         if size_of(self) != size_of(value):
             return False
 
-        if not self._members.keys() == value._members.keys():
+        self_members = object.__getattribute__(self, "_members")
+        other_members = object.__getattribute__(value, "_members")
+
+        if self_members.keys() != other_members.keys():
             return False
 
-        return all(getattr(self, name) == getattr(value, name) for name in self._members)
+        return all(getattr(self, name) == getattr(value, name) for name in self_members)

libdestruct/common/type_registry.py

@@ -146,7 +146,8 @@ def register_type_handler(
         if parent not in self.type_handlers:
             self.type_handlers[parent] = []
 
-        self.type_handlers[parent].append(handler)
+        if handler not in self.type_handlers[parent]:
+            self.type_handlers[parent].append(handler)
 
     def register_instance_handler(
         self: TypeRegistry,
@@ -165,7 +166,8 @@ def register_instance_handler(
         if parent not in self.instance_handlers:
             self.instance_handlers[parent] = []
 
-        self.instance_handlers[parent].append(handler)
+        if handler not in self.instance_handlers[parent]:
+            self.instance_handlers[parent].append(handler)
 
     def register_generic_handler(
         self: TypeRegistry,
@@ -181,7 +183,8 @@ def register_generic_handler(
         if origin not in self.generic_handlers:
             self.generic_handlers[origin] = []
 
-        self.generic_handlers[origin].append(handler)
+        if handler not in self.generic_handlers[origin]:
+            self.generic_handlers[origin].append(handler)
 
     def register_mapping(
         self: TypeRegistry,

libdestruct/common/union/union.py

@@ -119,10 +119,18 @@ def to_str(self: union, indent: int = 0) -> str:
 
     def __getattr__(self: union, name: str) -> object:
         """Delegate attribute access to named variants or the active variant."""
-        variants = object.__getattribute__(self, "_variants")
-        if name in variants:
-            return variants[name]
-        variant = object.__getattribute__(self, "_variant")
-        if variant is not None:
-            return getattr(variant, name)
+        try:
+            variants = object.__getattribute__(self, "_variants")
+            if name in variants:
+                return variants[name]
+        except AttributeError:
+            pass
+
+        try:
+            variant = object.__getattribute__(self, "_variant")
+            if variant is not None:
+                return getattr(variant, name)
+        except AttributeError:
+            pass
+
         raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")

libdestruct/libdestruct.py

@@ -16,11 +16,17 @@
     from libdestruct.common.obj import obj
 
 
+_VALID_ENDIANNESS = ("little", "big")
+
+
 def inflater(memory: Sequence, endianness: str = "little") -> Inflater:
     """Return a TypeInflater instance."""
     if not isinstance(memory, Sequence):
         raise TypeError(f"memory must be a Sequence, not {type(memory).__name__}")
 
+    if endianness not in _VALID_ENDIANNESS:
+        raise ValueError(f"endianness must be 'little' or 'big', not {endianness!r}")
+
     return Inflater(memory, endianness=endianness)