feat: refactor library to remove circular imports

As a side-effect, registering new types is much easier

Author: MrIndeciso

libdestruct/c/__init__.py

@@ -11,3 +11,5 @@
 from libdestruct.c.c_ulong import c_ulong
 
 __all__ = ["c_int", "c_long", "c_str", "c_uint", "c_ulong"]
+
+import libdestruct.c.base_type_inflater

libdestruct/c/base_type_inflater.py

@@ -0,0 +1,23 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from libdestruct.c.c_int import c_int
+from libdestruct.c.c_long import c_long
+from libdestruct.c.c_str import c_str
+from libdestruct.c.c_uint import c_uint
+from libdestruct.c.c_ulong import c_ulong
+from libdestruct.common.type_registry import TypeRegistry
+
+registry = TypeRegistry()
+
+
+registry.register_mapping(c_int, c_int)
+registry.register_mapping(c_uint, c_uint)
+registry.register_mapping(c_long, c_long)
+registry.register_mapping(c_ulong, c_ulong)
+registry.register_mapping(c_str, c_str)

libdestruct/c/c_str.py

@@ -6,7 +6,7 @@
 
 from __future__ import annotations
 
-from libdestruct.common.array import array
+from libdestruct.common.array.array import array
 from libdestruct.common.obj import obj
 
 

libdestruct/common/array/__init__.py

@@ -0,0 +1,46 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.array.array import array
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSequence
+
+    from libdestruct.common.obj import obj
+
+
+class arr_impl(array):
+    """A linear sequential array."""
+
+    size: int
+    """The size of the array."""
+
+    def __init__(
+        self: arr_impl,
+        memory: MutableSequence,
+        address: int | tuple[obj, int],
+        backing_type: obj,
+        count: int,
+    ) -> None:
+        """Initialize the array."""
+        self.memory = memory
+        self.address = address
+        self.backing_type = backing_type
+        self.count = count
+
+        self.size = self.backing_type.size * self.count
+
+    def __getitem__(self: arr_impl, index: int) -> obj:
+        """Get an item from the array."""
+        return self.backing_type(self.memory, (self.address, index * self.backing_type.size))
+
+    def __setitem__(self: arr_impl, index: int, value: obj) -> None:
+        """Set an item in the array."""
+        raise NotImplementedError("Cannot set items in an array.")

libdestruct/common/array/arr_impl.py

@@ -0,0 +1,37 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.type_registry import TypeRegistry
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSequence
+
+    from libdestruct.common.obj import obj
+
+
+class Inflater:
+    """The memory manager, which inflates any memory-referencing type."""
+
+    def __init__(self: Inflater, memory: MutableSequence) -> None:
+        """Initialize the memory manager."""
+        self.memory = memory
+        self.type_registry = TypeRegistry()
+
+    def inflate(self: Inflater, item: type, address: int | tuple[obj, int]) -> obj:
+        """Inflate a memory-referencing type.
+
+        Args:
+            item: The type to inflate.
+            address: The address of the object in the memory view.
+
+        Returns:
+            The inflated object.
+        """
+        return self.type_registry.inflater_for(item)(self.memory, address)

libdestruct/common/array.py libdestruct/common/array/array.pylibdestruct/common/array.py renamed to libdestruct/common/array/array.py

@@ -9,3 +9,6 @@
 from libdestruct.common.struct.struct_impl import struct_impl
 
 __all__ = ["struct", "struct_impl", "ptr_to", "ptr_to_self"]
+
+import libdestruct.common.struct.field_inflater
+import libdestruct.common.struct.struct_inflater

libdestruct/common/inflater.py

@@ -0,0 +1,38 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from libdestruct.common.struct.ptr_struct_field import PtrStructField
+from libdestruct.common.struct.struct import struct
+from libdestruct.common.struct.struct_impl import struct_impl
+from libdestruct.common.type_registry import TypeRegistry
+
+if TYPE_CHECKING:
+    from libdestruct.common.obj import obj
+
+registry = TypeRegistry()
+
+
+def inflate_ptr_field(
+    field: PtrStructField,
+    _: type[obj],
+    owner: tuple[obj, type[obj]] | None,
+) -> obj:
+    """Inflate a field of a struct that has an associated generator."""
+    if not field.backing_type:
+        if owner:
+            _, owner_type = owner
+            field.backing_type = owner_type
+    elif issubclass(field.backing_type, struct) and not issubclass(field.backing_type, struct_impl):
+        field.backing_type = registry.inflater_for(field.backing_type)
+
+    return field.inflate
+
+
+registry.register_instance_handler(PtrStructField, inflate_ptr_field)

libdestruct/common/struct/__init__.py

@@ -9,6 +9,7 @@
 from typing import TYPE_CHECKING
 
 from libdestruct.common.obj import obj
+from libdestruct.libdestruct import inflater
 
 if TYPE_CHECKING:
     from libdestruct.common.struct.struct_impl import struct_impl
@@ -17,18 +18,16 @@
 class struct(obj):
     """A C struct."""
 
-    def __init__(self: obj) -> None:
+    def __init__(self: struct) -> None:
         """Initialize the struct."""
         raise RuntimeError("This type should not be directly instantiated.")
 
     @classmethod
     def from_bytes(cls: type[struct], data: bytes) -> struct_impl:
         """Create a struct from a serialized representation."""
-        from libdestruct import inflater
-
         type_inflater = inflater(data)
 
-        result = type_inflater.inflate_struct(cls, 0)
+        result = type_inflater.inflate(cls, 0)
 
         if result.size != len(data):
             raise ValueError("The length of the serialized struct does not match the struct size.")