style: remove some duplicate code

Author: MrIndeciso

libdestruct/backing/fake_resolver.py

@@ -8,6 +8,9 @@
 
 from libdestruct.backing.resolver import Resolver
 
+_PAGE_SIZE = 0x1000
+_ZERO_PAGE = b"\x00" * _PAGE_SIZE
+
 
 class FakeResolver(Resolver):
     """A class that can resolve elements in a simulated memory storage."""
@@ -53,11 +56,11 @@ def resolve(self: FakeResolver, size: int, _: int) -> bytes:
         result = b""
 
         while size:
-            page = self.memory.get(page_address, b"\x00" * 0x1000)
-            page_size = min(size, 0x1000 - page_offset)
+            page = self.memory.get(page_address, _ZERO_PAGE)
+            page_size = min(size, _PAGE_SIZE - page_offset)
             result += page[page_offset : page_offset + page_size]
             size -= page_size
-            page_address += 0x1000
+            page_address += _PAGE_SIZE
             page_offset = 0
 
         return result
@@ -70,11 +73,11 @@ def modify(self: FakeResolver, size: int, _: int, value: bytes) -> None:
         page_offset = address & 0xFFF
 
         while size:
-            page = self.memory.get(page_address, b"\x00" * 0x1000)
-            page_size = min(size, 0x1000 - page_offset)
+            page = self.memory.get(page_address, _ZERO_PAGE)
+            page_size = min(size, _PAGE_SIZE - page_offset)
             page = page[:page_offset] + value[:page_size] + page[page_offset + page_size :]
             self.memory[page_address] = page
             size -= page_size
             value = value[page_size:]
-            page_address += 0x1000
+            page_address += _PAGE_SIZE
             page_offset = 0

libdestruct/c/c_integer_types.py

@@ -127,3 +127,18 @@ class c_ulong(_c_integer):
 
     signed: bool = False
     """Whether the long is signed."""
+
+
+_SIGNED_INTEGER_BY_SIZE: dict[int, type[_c_integer]] = {
+    1: c_char,
+    2: c_short,
+    4: c_int,
+    8: c_long,
+}
+
+
+def signed_integer_for_size(size: int) -> type[_c_integer]:
+    """Return the signed C integer type for the given byte size (1, 2, 4, or 8)."""
+    if size not in _SIGNED_INTEGER_BY_SIZE:
+        raise ValueError("The size of the field must be 1, 2, 4, or 8 bytes.")
+    return _SIGNED_INTEGER_BY_SIZE[size]

libdestruct/c/c_str.py

@@ -26,11 +26,12 @@ def count(self: c_str) -> int:
 
     def get(self: c_str, index: int = -1) -> bytes:
         """Return the character at the given index."""
-        if (index != -1 and index < 0) or index >= self.count():
+        length = self.count()
+        if (index != -1 and index < 0) or index >= length:
             raise IndexError("String index out of range.")
 
         if index == -1:
-            return self.resolver.resolve(self.count(), 0)
+            return self.resolver.resolve(length, 0)
 
         return bytes([self.resolver.resolve(index + 1, 0)[-1]])
 

libdestruct/common/enum/int_enum_field.py

@@ -8,7 +8,7 @@
 
 from typing import TYPE_CHECKING
 
-from libdestruct.c.c_integer_types import c_char, c_int, c_long, c_short
+from libdestruct.c.c_integer_types import signed_integer_for_size
 from libdestruct.common.enum.enum import enum
 from libdestruct.common.enum.enum_field import EnumField
 
@@ -43,20 +43,7 @@ def __init__(
             self.backing_type = backing_type
             return
 
-        if not 0 < size <= 8:
-            raise ValueError("The size of the field must be between 1 and 8 bytes.")
-
-        match size:
-            case 1:
-                self.backing_type = c_char
-            case 2:
-                self.backing_type = c_short
-            case 4:
-                self.backing_type = c_int
-            case 8:
-                self.backing_type = c_long
-            case _:
-                raise ValueError("The size of the field must be a power of 2.")
+        self.backing_type = signed_integer_for_size(size)
 
     def inflate(self: IntEnumField, resolver: Resolver) -> int:
         """Inflate the field.

libdestruct/common/flags/int_flag_field.py

@@ -8,7 +8,7 @@
 
 from typing import TYPE_CHECKING
 
-from libdestruct.c.c_integer_types import c_char, c_int, c_long, c_short
+from libdestruct.c.c_integer_types import signed_integer_for_size
 from libdestruct.common.flags.flags import flags
 from libdestruct.common.flags.flags_field import FlagsField
 
@@ -36,20 +36,7 @@ def __init__(
             self.backing_type = backing_type
             return
 
-        if not 0 < size <= 8:
-            raise ValueError("The size of the field must be between 1 and 8 bytes.")
-
-        match size:
-            case 1:
-                self.backing_type = c_char
-            case 2:
-                self.backing_type = c_short
-            case 4:
-                self.backing_type = c_int
-            case 8:
-                self.backing_type = c_long
-            case _:
-                raise ValueError("The size of the field must be a power of 2.")
+        self.backing_type = signed_integer_for_size(size)
 
     def inflate(self: IntFlagField, resolver: Resolver) -> flags:
         """Inflate the field."""

libdestruct/common/struct/struct_impl.py

@@ -39,14 +39,13 @@ class struct_impl(struct):
 
     def __init__(self: struct_impl, resolver: Resolver | None = None, **kwargs: ...) -> None:
         """Initialize the struct implementation."""
-        # If we have kwargs and the resolver is None, we provide a fake resolver
         if kwargs and resolver is None:
             resolver = FakeResolver()
 
         if not isinstance(resolver, Resolver):
             raise TypeError("The resolver must be a Resolver instance.")
 
-        # struct overrides the __init__ method, so we need to call the parent class __init__ method
+        # struct.__init__ raises by design; bypass it and call obj.__init__ directly.
         obj.__init__(self, resolver)
 
         object.__setattr__(self, "_struct_name", self.__class__.__name__)
@@ -81,9 +80,7 @@ def __setattr__(self: struct_impl, name: str, value: object) -> None:
         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
-        # struct_impl -> struct -> obj becomes struct_impl -> obj
+        """Create a new struct, bypassing struct.__new__ which is for the user-facing factory."""
         return obj.__new__(cls)
 
     def _inflate_struct_attributes(
@@ -152,13 +149,12 @@ def _inflate_struct_attributes(
                 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.
+        # VLA detection uses duck-typing on _count_member to avoid a circular
+        # import between struct_impl and vla_impl (vla_impl extends array_impl,
+        # which imports struct).
         members = object.__getattribute__(self, "_members")
-        last_member = list(members.values())[-1] if members else None
+        last_name, last_member = next(reversed(members.items()), (None, None))
         if last_member is not None and hasattr(last_member, "_count_member"):
-            last_name = list(members.keys())[-1]
             object.__setattr__(self, "_vla_fixed_offset", self._member_offsets[last_name])
         else:
             object.__setattr__(self, "size", current_offset)