feat: add big-endian support in the resolver

This propagates down the chain, and everything works big-endian

Author: MrIndeciso

libdestruct/backing/fake_resolver.py

@@ -12,12 +12,13 @@
 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) -> None:
+    def __init__(self: FakeResolver, memory: dict | None = None, address: int | None = 0, endianness: str = "little") -> None:
         """Initializes a basic fake resolver."""
         self.memory = memory if memory is not None else {}
         self.address = address
         self.parent = None
         self.offset = None
+        self.endianness = endianness
 
     def resolve_address(self: FakeResolver) -> int:
         """Resolves self's address, mainly used by children to determine their own address."""
@@ -28,14 +29,14 @@ def resolve_address(self: FakeResolver) -> int:
 
     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 = FakeResolver(self.memory, None, self.endianness)
         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)
+        return FakeResolver(self.memory, address, self.endianness)
 
     def resolve(self: FakeResolver, size: int, _: int) -> bytes:
         """Resolves itself, providing the bytes it references for the specified size and index."""

libdestruct/backing/memory_resolver.py

@@ -17,12 +17,13 @@
 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) -> None:
+    def __init__(self: MemoryResolver, memory: MutableSequence, address: int | None, endianness: str = "little") -> None:
         """Initializes a basic memory resolver."""
         self.memory = memory
         self.address = address
         self.parent = None
         self.offset = None
+        self.endianness = endianness
 
     def resolve_address(self: MemoryResolver) -> int:
         """Resolves self's address, mainly used by childs to determine their own address."""
@@ -33,14 +34,14 @@ def resolve_address(self: MemoryResolver) -> int:
 
     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 = MemoryResolver(self.memory, None, self.endianness)
         new_resolver.parent = self
         new_resolver.offset = address_offset
         return new_resolver
 
     def absolute_from_own(self: MemoryResolver, address: int) -> MemoryResolver:
         """Creates a resolver that has an absolute reference to an object, from the parent's view."""
-        return MemoryResolver(self.memory, address)
+        return MemoryResolver(self.memory, address, self.endianness)
 
     def resolve(self: MemoryResolver, size: int, _: int) -> bytes:
         """Resolves itself, providing the bytes it references for the specified size and index."""

libdestruct/backing/resolver.py

@@ -16,6 +16,9 @@ class Resolver(ABC):
 
     parent: Self
 
+    endianness: str = "little"
+    """The endianness of the data this resolver accesses."""
+
     @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."""

libdestruct/common/inflater.py

@@ -21,9 +21,10 @@
 class Inflater:
     """The memory manager, which inflates any memory-referencing type."""
 
-    def __init__(self: Inflater, memory: MutableSequence) -> None:
+    def __init__(self: Inflater, memory: MutableSequence, endianness: str = "little") -> None:
         """Initialize the memory manager."""
         self.memory = memory
+        self.endianness = endianness
         self.type_registry = TypeRegistry()
 
     def inflate(self: Inflater, item: type, address: int | Resolver) -> obj:
@@ -38,6 +39,6 @@ def inflate(self: Inflater, item: type, address: int | Resolver) -> obj:
         """
         if isinstance(address, int):
             # Create a memory resolver from the address
-            address = MemoryResolver(self.memory, address)
+            address = MemoryResolver(self.memory, address, self.endianness)
 
         return self.type_registry.inflater_for(item)(address)

libdestruct/common/obj.py

@@ -38,6 +38,8 @@ def __init__(self: obj, resolver: Resolver) -> None:
             resolver: The resolver for the value of this object.
         """
         self.resolver = resolver
+        if resolver is not None:
+            self.endianness = resolver.endianness
 
     @property
     def address(self: obj) -> int:
@@ -57,11 +59,11 @@ def to_bytes(self: obj) -> bytes:
         """Serialize the object to bytes."""
 
     @classmethod
-    def from_bytes(cls: type[obj], data: bytes) -> obj:
+    def from_bytes(cls: type[obj], data: bytes, endianness: str = "little") -> obj:
         """Deserialize the object from bytes."""
         from libdestruct.libdestruct import inflater
 
-        lib = inflater(data)
+        lib = inflater(data, endianness=endianness)
         item = lib.inflate(cls, 0)
         item.freeze()
         return item

libdestruct/common/ptr/ptr.py

@@ -25,12 +25,13 @@ class _ArithmeticResolver(Resolver):
     def __init__(self: _ArithmeticResolver, original: Resolver, address: int) -> None:
         self._original = original
         self._address = address
+        self.endianness = original.endianness
 
     def resolve_address(self: _ArithmeticResolver) -> int:
         return self._address
 
     def resolve(self: _ArithmeticResolver, size: int, _: int) -> bytes:
-        return self._address.to_bytes(size, "little")
+        return self._address.to_bytes(size, self.endianness)
 
     def modify(self: _ArithmeticResolver, _size: int, _index: int, _value: bytes) -> None:
         raise RuntimeError("Cannot modify a synthetic pointer.")
@@ -98,10 +99,9 @@ def unwrap(self: ptr, length: int | None = None) -> obj:
                 raise ValueError("Length is not supported when unwrapping a pointer to a wrapper object.")
 
             result = self.wrapper(self.resolver.absolute_from_own(address))
-        elif not length:
-            result = self.resolver.resolve(1, 0)
         else:
-            result = self.resolver.resolve(length, 0)
+            target_resolver = self.resolver.absolute_from_own(address)
+            result = target_resolver.resolve(length or 1, 0)
 
         self._cached_unwrap = result
         self._cache_valid = True

libdestruct/common/struct/struct.py

@@ -30,8 +30,8 @@ def __new__(cls: type[struct], *args: ..., **kwargs: ...) -> struct:  # noqa: PY
         return type_impl(*args, **kwargs)
 
     @classmethod
-    def from_bytes(cls: type[struct], data: bytes) -> struct_impl:
+    def from_bytes(cls: type[struct], data: bytes, endianness: str = "little") -> struct_impl:
         """Create a struct from a serialized representation."""
-        type_inflater = inflater(data)
+        type_inflater = inflater(data, endianness=endianness)
 
         return type_inflater.inflate(cls, 0)

libdestruct/libdestruct.py

@@ -16,26 +16,27 @@
     from libdestruct.common.obj import obj
 
 
-def inflater(memory: Sequence) -> Inflater:
+def inflater(memory: Sequence, endianness: str = "little") -> Inflater:
     """Return a TypeInflater instance."""
     if not isinstance(memory, Sequence):
         raise TypeError(f"memory must be a MutableSequence, not {type(memory).__name__}")
 
-    return Inflater(memory)
+    return Inflater(memory, endianness=endianness)
 
 
-def inflate(item: type, memory: Sequence, address: int | Resolver) -> obj:
+def inflate(item: type, memory: Sequence, address: int | Resolver, endianness: str = "little") -> obj:
     """Inflate a memory-referencing type.
 
     Args:
         item: The type to inflate.
         memory: The memory view, which can be mutable or immutable.
         address: The address of the object in the memory view.
+        endianness: The byte order ("little" or "big").
 
     Returns:
         The inflated object.
     """
     if not isinstance(address, int) and not isinstance(address, Resolver):
         raise TypeError(f"address must be an int or a Resolver, not {type(address).__name__}")
 
-    return inflater(memory).inflate(item, address)
+    return inflater(memory, endianness=endianness).inflate(item, address)