feat: make structs instantiatable, to generate their in-memory representation from the initializers

Author: MrIndeciso

libdestruct/backing/fake_resolver.py

@@ -0,0 +1,76 @@
+#
+# 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.backing.resolver import Resolver
+
+
+class FakeResolver(Resolver):
+    """A class that can resolve elements in a simulated memory storage."""
+
+    def __init__(self: FakeResolver, memory: dict | None = None, address: int | None = 0) -> FakeResolver:
+        """Initializes a basic fake resolver."""
+        self.memory = memory if memory is not None else {}
+        self.address = address
+        self.parent = None
+        self.offset = None
+
+    def resolve_address(self: FakeResolver) -> int:
+        """Resolves self's address, mainly used by children to determine their own address."""
+        if self.address is not None:
+            return self.address
+
+        return self.parent.resolve_address() + self.offset
+
+    def relative_from_own(self: FakeResolver, address_offset: int, _: int) -> FakeResolver:
+        """Creates a resolver that references a parent, such that a change in the parent is propagated on the child."""
+        new_resolver = FakeResolver(self.memory, None)
+        new_resolver.parent = self
+        new_resolver.offset = address_offset
+        return new_resolver
+
+    def absolute_from_own(self: FakeResolver, address: int) -> FakeResolver:
+        """Creates a resolver that has an absolute reference to an object, from the parent's view."""
+        return FakeResolver(self.memory, address)
+
+    def resolve(self: FakeResolver, size: int, _: int) -> bytes:
+        """Resolves itself, providing the bytes it references for the specified size and index."""
+        address = self.resolve_address()
+        # We store data in the dictionary as 4K pages
+        page_address = address & ~0xFFF
+        page_offset = address & 0xFFF
+
+        result = b""
+
+        while size:
+            page = self.memory.get(page_address, b"\x00" * (0x1000 - page_offset))
+            page_size = min(size, 0x1000 - page_offset)
+            result += page[page_offset : page_offset + page_size]
+            size -= page_size
+            page_address += 0x1000
+            page_offset = 0
+
+        return result
+
+    def modify(self: FakeResolver, size: int, _: int, value: bytes) -> None:
+        """Modifies itself in memory."""
+        address = self.resolve_address()
+        # We store data in the dictionary as 4K pages
+        page_address = address & ~0xFFF
+        page_offset = address & 0xFFF
+
+        while size:
+            page = self.memory.get(page_address, b"\x00" * 0x1000)
+            page_size = min(size, 0x1000 - 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_offset = 0

libdestruct/common/struct/struct.py

@@ -9,6 +9,7 @@
 from typing import TYPE_CHECKING
 
 from libdestruct.common.obj import obj
+from libdestruct.common.type_registry import TypeRegistry
 from libdestruct.libdestruct import inflater
 
 if TYPE_CHECKING: # pragma: no cover
@@ -22,6 +23,12 @@ def __init__(self: struct) -> None:
         """Initialize the struct."""
         raise RuntimeError("This type should not be directly instantiated.")
 
+    def __new__(cls: type[struct], *args: ..., **kwargs: ...) -> struct: # noqa: PYI034
+        """Create a new struct."""
+        # Look for an inflater for this struct
+        inflater = TypeRegistry().inflater_for(cls)
+        return inflater(*args, **kwargs)
+
     @classmethod
     def from_bytes(cls: type[struct], data: bytes) -> struct_impl:
         """Create a struct from a serialized representation."""

libdestruct/common/struct/struct_impl.py

@@ -6,18 +6,17 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import Self
 
+from libdestruct.backing.fake_resolver import FakeResolver
+from libdestruct.backing.resolver import Resolver
 from libdestruct.common.attributes.offset_attribute import OffsetAttribute
 from libdestruct.common.field import Field
 from libdestruct.common.obj import obj
 from libdestruct.common.struct import struct
 from libdestruct.common.type_registry import TypeRegistry
 from libdestruct.common.utils import iterate_annotation_chain
 
-if TYPE_CHECKING:  # pragma: no cover
-    from libdestruct.backing.resolver import Resolver
-
 
 class struct_impl(struct):
     """The implementation for the C struct type."""
@@ -34,9 +33,16 @@ class struct_impl(struct):
     _inflater: TypeRegistry = TypeRegistry()
     """The type registry, used for inflating the attributes."""
 
-    def __init__(self: struct_impl, resolver: Resolver) -> None:
+    def __init__(self: struct_impl, resolver: Resolver | None = None, **kwargs: ...) -> None:
         """Initialize the struct implementation."""
-        # array overrides the __init__ method, so we need to call the parent class __init__ method
+        # 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
         obj.__init__(self, resolver)
 
         self.name = self.__class__.__name__
@@ -45,6 +51,15 @@ def __init__(self: struct_impl, resolver: Resolver) -> None:
         reference_type = self._reference_struct
         self._inflate_struct_attributes(self._inflater, resolver, reference_type)
 
+        for name, value in kwargs.items():
+            getattr(self, name).value = 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
+        return obj.__new__(cls)
+
     def _inflate_struct_attributes(
         self: struct_impl,
         inflater: TypeRegistry,