feat: partially migrate from memory to a resolver system

Author: MrIndeciso

libdestruct/backing/__init__.py

@@ -0,0 +1,53 @@
+#
+# 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
+
+if TYPE_CHECKING:
+    from collections.abc import MutableSequence
+
+
+class MemoryResolver(Resolver):
+    """A class that can resolve itself to a value in a referenced memory storage."""
+
+    def __init__(self: MemoryResolver, memory: MutableSequence, address: int | None) -> MemoryResolver:
+        """Initializes a basic memory resolver."""
+        self.memory = memory
+        self.address = address
+        self.parent = None
+        self.offset = None
+
+    def resolve_address(self: MemoryResolver) -> int:
+        """Resolves self's address, mainly used by childs 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: MemoryResolver, address_offset: int, _: int) -> MemoryResolver:
+        """Creates a resolver that references a parent, such that a change in the parent is propagated on the child."""
+        new_resolver = MemoryResolver(self.memory, None)
+        new_resolver.parent = self
+        new_resolver.offset = address_offset
+        return new_resolver
+
+    def absolute_from_own(self: Resolver, address: int) -> MemoryResolver:
+        """Creates a resolver that has an absolute reference to an object, from the parent's view."""
+        return MemoryResolver(self.memory, address)
+
+    def resolve(self: MemoryResolver, size: int, _: int) -> bytes:
+        """Resolves itself, providing the bytes it references for the specified size and index."""
+        address = self.resolve_address()
+        return self.memory[address : address + size]
+
+    def modify(self: Resolver, size: int, _: int, value: bytes) -> None:
+        """Modifies itself in memory."""
+        address = self.resolve_address()
+        self.memory[address : address + size] = value

libdestruct/backing/memory_resolver.py

@@ -0,0 +1,36 @@
+#
+# 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 abc import ABC, abstractmethod
+from typing import Self
+
+
+class Resolver(ABC):
+    """A class that can resolve itself to a value, either in memory or in other storage types."""
+
+    parent: Self
+
+    @abstractmethod
+    def relative_from_own(self: Resolver, address_offset: int, index_offset: int) -> Self:
+        """Creates a resolver that references a parent, such that a change in the parent is propagated on the child."""
+
+    @abstractmethod
+    def absolute_from_own(self: Resolver, address: int) -> Self:
+        """Creates a resolver that has an absolute reference to an object, from the parent's view."""
+
+    @abstractmethod
+    def resolve_address(self: Resolver) -> int:
+        """Resolves self's address, mainly used by childs to determine their own address."""
+
+    @abstractmethod
+    def resolve(self: Resolver, size: int, index: int) -> bytes:
+        """Resolves itself, providing the bytes it references for the specified size and index."""
+
+    @abstractmethod
+    def modify(self: Resolver, size: int, index: int, value: bytes) -> None:
+        """Modifies itself."""

libdestruct/backing/resolver.py

@@ -23,21 +23,25 @@ class _c_integer(obj):
 
     def get(self: _c_integer) -> int:
         """Return the value of the integer."""
-        return int.from_bytes(self.memory[self.address : self.address + self.size], self.endianness, signed=self.signed)
+        return int.from_bytes(self.resolver.resolve(self.size, 0), self.endianness, signed=self.signed)
 
     def to_bytes(self: _c_integer) -> bytes:
         """Return the serialized representation of the object."""
         if self._frozen:
             return self._frozen_value.to_bytes(self.size, self.endianness, signed=self.signed)
 
-        return self.memory[self.address : self.address + self.size]
+        return self.resolver.resolve(self.size, 0)
 
     def _set(self: _c_integer, value: int) -> None:
         """Set the value of the integer to the given value."""
-        self.memory[self.address : self.address + self.size] = value.to_bytes(
+        self.resolver.modify(
             self.size,
-            self.endianness,
-            signed=self.signed,
+            0,
+            value.to_bytes(
+                self.size,
+                self.endianness,
+                signed=self.signed,
+            ),
         )
 
     def __int__(self: _c_integer) -> int:

libdestruct/c/c_integer_types.py

@@ -17,36 +17,38 @@ def size(self: c_str) -> int:
         size = 0
 
         try:
-            while self.memory[self.address + size] != b"\x00":
+            while self.resolver.resolve(size, 0)[-1:] != b"\x00":
                 size += 1
         except IndexError as e:
             raise RuntimeError("String is not null-terminated.") from e
 
-        return size
+        return size - 1
 
     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.size():
             raise IndexError("String index out of range.")
 
         if index == -1:
-            return self.memory[self.address : self.address + self.size()]
+            return self.resolver.resolve(self.size(), 0)
 
-        return bytes([self.memory[self.address + index]])
+        return bytes([self.resolver.resolve(index)[-1]])
 
     def to_bytes(self: c_str) -> bytes:
         """Return the serialized representation of the object."""
-        return self.memory[self.address : self.address + self.size()]
+        return self.resolver.resolve(self.size(), 0)
 
     def _set(self: c_str, value: bytes, index: int = -1) -> None:
         """Set the character at the given index to the given value."""
         if index != -1 and index < 0 or index >= self.size():
             raise IndexError("String index out of range.")
 
         if index == -1:
-            self.memory[self.address] = value
+            # This is rather clunky
+            self.resolver.modify(len(value), 0, value)
         else:
-            self.memory[self.address + index] = value
+            prev = self.resolver.resolve(index, 0)
+            self.resolver.modify(index + len(value), 0, prev + value)
 
     def __iter__(self: c_str) -> iter:
         """Return an iterator over the string."""

libdestruct/c/c_str.py

@@ -8,11 +8,13 @@
 
 from typing import TYPE_CHECKING
 
+from libdestruct.backing.memory_resolver import MemoryResolver
 from libdestruct.common.type_registry import TypeRegistry
 
 if TYPE_CHECKING:
     from collections.abc import MutableSequence
 
+    from libdestruct.backing.resolver import Resolver
     from libdestruct.common.obj import obj
 
 
@@ -24,7 +26,7 @@ def __init__(self: Inflater, memory: MutableSequence) -> None:
         self.memory = memory
         self.type_registry = TypeRegistry()
 
-    def inflate(self: Inflater, item: type, address: int | tuple[obj, int]) -> obj:
+    def inflate(self: Inflater, item: type, address: int | Resolver) -> obj:
         """Inflate a memory-referencing type.
 
         Args:
@@ -34,4 +36,8 @@ def inflate(self: Inflater, item: type, address: int | tuple[obj, int]) -> obj:
         Returns:
             The inflated object.
         """
-        return self.type_registry.inflater_for(item)(self.memory, address)
+        if isinstance(address, int):
+            # Create a memory resolver from the address
+            address = MemoryResolver(self.memory, address)
+
+        return self.type_registry.inflater_for(item)(address)

libdestruct/common/inflater.py

@@ -10,50 +10,36 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from collections.abc import MutableSequence
+    from libdestruct.backing.resolver import Resolver
 
 
 class obj(ABC):
     """A generic object, with reference to the backing memory view."""
 
-    address: int
-    """The address of the object in the memory view."""
-
     endianness: str = "little"
     """The endianness of the backing reference view."""
 
-    memory: MutableSequence
-    """The backing memory view."""
+    resolver: Resolver
+    """The backing storage that resolves to this instance of a type."""
 
     _frozen: bool = False
     """Whether the object is frozen."""
 
     _frozen_value: object = None
     """The frozen value of the object."""
 
-    def __init__(self: obj, memory: MutableSequence, address: int | tuple[obj, int]) -> None:
+    def __init__(self: obj, resolver: Resolver) -> None:
         """Initialize a generic object.
 
         Args:
-            memory: The backing memory view.
-            address: The address of the object in the memory view
+            resolver: The resolver for the value of this object.
         """
-        self.memory = memory
-
-        if isinstance(address, tuple):
-            self._address = None
-            self._reference = address[0]
-            self._offset = address[1]
-        else:
-            self._address = address
+        self.resolver = resolver
 
     @property
     def address(self: obj) -> int:
         """Return the address of the object in the memory view."""
-        if self._address is not None:
-            return self._address
-
-        return self._reference.address + self._offset
+        return self.resolver.resolve_address()
 
     @abstractmethod
     def get(self: obj) -> object:

libdestruct/common/obj.py

@@ -6,41 +6,46 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from libdestruct.common.field import Field
 from libdestruct.common.obj import obj
 
+if TYPE_CHECKING:
+    from libdestruct.backing.resolver import Resolver
+
 
 class ptr(obj):
     """A pointer to an object in memory."""
 
     size: int = 8
     """The size of a pointer in bytes."""
 
-    def __init__(self: ptr, memory: bytearray, address: int, wrapper: type | None = None) -> None:
+    def __init__(self: ptr, resolver: Resolver, wrapper: type | None = None) -> None:
         """Initialize a pointer.
 
         Args:
-            memory: The backing memory view.
-            address: The address of the pointer in the memory view.
+            resolver: The backing value resolver.
             wrapper: The object this pointer points to.
         """
-        super().__init__(memory, address)
+        super().__init__(resolver)
         self.wrapper = wrapper
 
     def get(self: ptr) -> int:
         """Return the value of the pointer."""
-        return int.from_bytes(self.memory[self.address : self.address + self.size], self.endianness)
+        value = self.resolver.resolve(self.size, 0)
+        return int.from_bytes(value, self.endianness)
 
     def to_bytes(self: obj) -> bytes:
         """Return the serialized representation of the object."""
         if self._frozen:
             return self._frozen_value.to_bytes(self.size, self.endianness)
 
-        return self.memory[self.address : self.address + self.size]
+        return self.resolver.resolve(self.size, 0)
 
     def _set(self: ptr, value: int) -> None:
         """Set the value of the pointer to the given value."""
-        self.memory[self.address : self.address + self.size] = value.to_bytes(self.size, self.endianness)
+        self.resolver.modify(self.size, 0, value.to_bytes(self.size, self.endianness))
 
     def unwrap(self: ptr, length: int | None = None) -> obj:
         """Return the object pointed to by the pointer.
@@ -54,12 +59,12 @@ def unwrap(self: ptr, length: int | None = None) -> obj:
             if length:
                 raise ValueError("Length is not supported when unwrapping a pointer to a wrapper object.")
 
-            return self.wrapper(self.memory, address)
+            return self.wrapper(self.resolver.absolute_from_own(address))
 
         if not length:
             length = 1
 
-        return self.memory[address : address + length]
+        return self.resolver.resolve(length, 0)
 
     def try_unwrap(self: ptr, length: int | None = None) -> obj | None:
         """Return the object pointed to by the pointer, if it is valid.
@@ -71,7 +76,7 @@ def try_unwrap(self: ptr, length: int | None = None) -> obj | None:
 
         try:
             # If the address is invalid, this will raise an IndexError or ValueError.
-            self.memory[address]
+            self.resolver.absolute_from_own(address).resolve(length)
         except (IndexError, ValueError):
             return None
 
@@ -90,7 +95,6 @@ def to_str(self: ptr, indent: int = 0) -> str:
 
         return f"{' ' * indent}{name}@0x{self.get():x}"
 
-
     def __str__(self: ptr) -> str:
         """Return a string representation of the pointer."""
         return self.to_str()

libdestruct/common/ptr.py

@@ -13,8 +13,7 @@
 from libdestruct.common.struct.struct_field import StructField
 
 if TYPE_CHECKING:
-    from collections.abc import MutableSequence
-
+    from libdestruct.backing.resolver import Resolver
     from libdestruct.common.obj import obj
 
 
@@ -29,9 +28,9 @@ def __init__(self: PtrStructField, backing_type: type | Field) -> None:
         """
         self.backing_type = backing_type
 
-    def inflate(self: PtrStructField, memory: MutableSequence, address: int | tuple[obj, int]) -> obj:
+    def inflate(self: PtrStructField, resolver: Resolver) -> obj:
         """Inflate the field."""
         if isinstance(self.backing_type, Field):
-            return ptr(memory, address, self.backing_type.inflate)
+            return ptr(resolver, self.backing_type.inflate)
 
-        return ptr(memory, address, self.backing_type)
+        return ptr(resolver, self.backing_type)