dissect.cstruct 5.0.dev0__py3-none-any.whl → 5.0.dev7__py3-none-any.whl

dissect/cstruct/types/leb128.py

@@ -7,6 +7,8 @@ from dissect.cstruct.types.base import BaseType
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import Endianness
+
 
 class LEB128(int, BaseType):
     """Variable-length code compression to store an arbitrarily large integer in a small number of bytes.
@@ -17,7 +19,7 @@ class LEB128(int, BaseType):
     signed: bool
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         result = 0
         shift = 0
         while True:
@@ -37,11 +39,11 @@ class LEB128(int, BaseType):
         return cls.__new__(cls, result)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:
+    def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[Self]:
         result = []
 
         while True:
-            if (value := cls._read(stream, context)) == 0:
+            if (value := cls._read(stream, context=context, endian=endian)) == 0:
                 break
 
             result.append(value)
@@ -49,7 +51,7 @@ class LEB128(int, BaseType):
         return result
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: int) -> int:
+    def _write(cls, stream: BinaryIO, data: int, *, endian: Endianness) -> int:
         # only write negative numbers when in signed mode
         if data < 0 and not cls.signed:
             raise ValueError("Attempt to encode a negative integer using unsigned LEB128 encoding")

dissect/cstruct/types/packed.py

@@ -9,6 +9,8 @@ from dissect.cstruct.types.base import EOF, BaseType
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import Endianness
+
 
 @lru_cache(1024)
 def _struct(endian: str, packchar: str) -> Struct:
@@ -24,11 +26,18 @@ class Packed(BaseType, Generic[T]):
     packchar: str
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
-        return cls._read_array(stream, 1, context)[0]
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
+        data = stream.read(cls.size)
+
+        if len(data) != cls.size:
+            raise EOFError(f"Read {len(data)} bytes, but expected {cls.size}")
+
+        return cls.__new__(cls, _struct(endian, cls.packchar).unpack(data)[0])
 
     @classmethod
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Self]:
+    def _read_array(
+        cls, stream: BinaryIO, count: int, *, context: dict[str, Any] | None = None, endian: Endianness
+    ) -> list[Self]:
         if count == EOF:
             data = stream.read()
             length = len(data)
@@ -37,7 +46,7 @@ class Packed(BaseType, Generic[T]):
             length = cls.size * count
             data = stream.read(length)
 
-        fmt = _struct(cls.cs.endian, f"{count}{cls.packchar}")
+        fmt = _struct(endian, f"{count}{cls.packchar}")
 
         if len(data) != length:
             raise EOFError(f"Read {len(data)} bytes, but expected {length}")
@@ -45,10 +54,10 @@ class Packed(BaseType, Generic[T]):
         return [cls.__new__(cls, value) for value in fmt.unpack(data)]
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None, *, endian: Endianness) -> Self:
         result = []
 
-        fmt = _struct(cls.cs.endian, cls.packchar)
+        fmt = _struct(endian, cls.packchar)
         while True:
             data = stream.read(cls.size)
 
@@ -63,9 +72,9 @@ class Packed(BaseType, Generic[T]):
         return result
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: Packed[T]) -> int:
-        return stream.write(_struct(cls.cs.endian, cls.packchar).pack(data))
+    def _write(cls, stream: BinaryIO, data: Packed[T], *, endian: Endianness) -> int:
+        return stream.write(_struct(endian, cls.packchar).pack(data))
 
     @classmethod
-    def _write_array(cls, stream: BinaryIO, data: list[Packed[T]]) -> int:
-        return stream.write(_struct(cls.cs.endian, f"{len(data)}{cls.packchar}").pack(*data))
+    def _write_array(cls, stream: BinaryIO, data: list[Packed[T]], *, endian: Endianness) -> int:
+        return stream.write(_struct(endian, f"{len(data)}{cls.packchar}").pack(*data))

dissect/cstruct/types/pointer.py

@@ -1,15 +1,20 @@
 from __future__ import annotations
 
+from functools import cache
 from typing import TYPE_CHECKING, Any, BinaryIO, Generic, TypeVar
 
-from dissect.cstruct.exceptions import NullPointerDereference
-from dissect.cstruct.types.base import BaseType
+from dissect.cstruct.exception import NullPointerDereference
+from dissect.cstruct.types.base import BaseType, normalize_endianness
 from dissect.cstruct.types.char import Char
 from dissect.cstruct.types.void import Void
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import AllowedEndianness, Endianness
+
 T = TypeVar("T", bound=BaseType)
 
 
@@ -19,13 +24,16 @@ class Pointer(int, BaseType, Generic[T]):
     type: type[T]
     _stream: BinaryIO | None
     _context: dict[str, Any] | None
-    _value: T | None
+    _endian: Endianness
 
-    def __new__(cls, value: int, stream: BinaryIO | None, context: dict[str, Any] | None = None) -> Self:
+    def __new__(
+        cls, value: int, stream: BinaryIO | None, *, context: dict[str, Any] | None = None, endian: Endianness
+    ) -> Self:
         obj = super().__new__(cls, value)
         obj._stream = stream
         obj._context = context
-        obj._value = None
+        obj._endian = endian
+        obj.dereference = cache(obj.dereference)
         return obj
 
     def __repr__(self) -> str:
@@ -37,68 +45,78 @@ class Pointer(int, BaseType, Generic[T]):
     def __getattr__(self, attr: str) -> Any:
         return getattr(self.dereference(), attr)
 
-    def __add__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__add__(self, other), self._stream, self._context)
-
-    def __sub__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__sub__(self, other), self._stream, self._context)
-
-    def __mul__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__mul__(self, other), self._stream, self._context)
-
-    def __floordiv__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__floordiv__(self, other), self._stream, self._context)
-
-    def __mod__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__mod__(self, other), self._stream, self._context)
-
-    def __pow__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__pow__(self, other), self._stream, self._context)
-
-    def __lshift__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__lshift__(self, other), self._stream, self._context)
-
-    def __rshift__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__rshift__(self, other), self._stream, self._context)
-
-    def __and__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__and__(self, other), self._stream, self._context)
-
-    def __xor__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__xor__(self, other), self._stream, self._context)
-
-    def __or__(self, other: int) -> Self:
-        return type.__call__(self.__class__, int.__or__(self, other), self._stream, self._context)
+    @staticmethod
+    def __op(op: Callable[[int, int], int]) -> Callable[[Self, int], Self]:
+        def method(self: Self, other: int) -> Self:
+            return type.__call__(
+                self.__class__,
+                op(self, other),
+                self._stream,
+                context=self._context,
+                endian=self._endian,
+            )
+
+        return method
+
+    __add__ = __op(int.__add__)
+    __sub__ = __op(int.__sub__)
+    __mul__ = __op(int.__mul__)
+    __floordiv__ = __op(int.__floordiv__)
+    __mod__ = __op(int.__mod__)
+    __pow__ = __op(int.__pow__)
+    __lshift__ = __op(int.__lshift__)
+    __rshift__ = __op(int.__rshift__)
+    __and__ = __op(int.__and__)
+    __xor__ = __op(int.__xor__)
+    __or__ = __op(int.__or__)
 
     @classmethod
     def __default__(cls) -> Self:
-        return cls.__new__(cls, cls.cs.pointer.__default__(), None, None)
+        return cls.__new__(
+            cls,
+            cls.cs.pointer.__default__(),
+            None,
+            context=None,
+            endian=cls.cs.endian,
+        )
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
-        return cls.__new__(cls, cls.cs.pointer._read(stream, context), stream, context)
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
+        return cls.__new__(
+            cls,
+            cls.cs.pointer._read(stream, context=context, endian=endian),
+            stream,
+            context=context,
+            endian=endian,
+        )
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: int) -> int:
-        return cls.cs.pointer._write(stream, data)
+    def _write(cls, stream: BinaryIO, data: int, *, endian: Endianness) -> int:
+        return cls.cs.pointer._write(stream, data, endian=endian)
+
+    def dereference(self, *, endian: AllowedEndianness | None = None) -> T | None:
+        """Dereference the pointer and read the value it points to.
 
-    def dereference(self) -> T:
+        Args:
+            endian: Optional endianness to use when reading the value.
+                    If not provided, the endianness used when reading the pointer itself will be used.
+        """
         if self == 0 or self._stream is None:
             raise NullPointerDereference
 
-        if self._value is None and not issubclass(self.type, Void):
-            # Read current position of file read/write pointer
-            position = self._stream.tell()
-            # Reposition the file read/write pointer
-            self._stream.seek(self)
+        endian = normalize_endianness(endian) if endian is not None else self._endian
+        if issubclass(self.type, Void):
+            return None
 
-            if issubclass(self.type, Char):
-                # this makes the assumption that a char pointer is a null-terminated string
-                value = self.type._read_0(self._stream, self._context)
-            else:
-                value = self.type._read(self._stream, self._context)
+        position = self._stream.tell()
+        self._stream.seek(self)
 
-            self._stream.seek(position)
-            self._value = value
+        if issubclass(self.type, Char):
+            # This makes the assumption that a char pointer is a null-terminated string
+            value = self.type._read_0(self._stream, context=self._context, endian=endian)
+        else:
+            value = self.type._read(self._stream, context=self._context, endian=endian)
 
-        return self._value
+        # Restore the stream position after reading the value
+        self._stream.seek(position)
+        return value

dissect/cstruct/types/structure.py

@@ -13,7 +13,10 @@ from types import FunctionType
 from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.cstruct.bitbuffer import BitBuffer
+from dissect.cstruct.expression import Expression
+from dissect.cstruct.lexer import IDENTIFIER_TYPES
 from dissect.cstruct.types.base import (
+    BaseArray,
     BaseType,
     MetaType,
     _is_buffer_type,
@@ -28,6 +31,8 @@ if TYPE_CHECKING:
 
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import Endianness
+
 
 class Field:
     """Structure field."""
@@ -71,15 +76,6 @@ class StructureMetaType(MetaType):
         return super().__new__(metacls, name, bases, classdict)
 
     def __call__(cls, *args, **kwargs) -> Self:  # type: ignore
-        if (
-            cls.__fields__
-            and len(args) == len(cls.__fields__) == 1
-            and isinstance(args[0], bytes)
-            and issubclass(cls.__fields__[0].type, bytes)
-            and len(args[0]) == cls.__fields__[0].type.size
-        ):
-            # Shortcut for single char/bytes type
-            return type.__call__(cls, *args, **kwargs)
         if not args and not kwargs:
             obj = type.__call__(cls)
             object.__setattr__(obj, "__dynamic_sizes__", {})
@@ -246,8 +242,8 @@ class StructureMetaType(MetaType):
         # The structure size is whatever the currently calculated offset is
         return offset, alignment
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:  # type: ignore
-        bit_buffer = BitBuffer(stream, cls.cs.endian)
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:  # type: ignore
+        bit_buffer = BitBuffer(stream, endian=endian)
         struct_start = stream.tell()
 
         result = {}
@@ -256,7 +252,7 @@ class StructureMetaType(MetaType):
             offset = stream.tell()
 
             if field.offset is not None and offset != struct_start + field.offset:
-                # Field is at a specific offset, either alligned or added that way
+                # Field is at a specific offset, either aligned or added that way
                 offset = struct_start + field.offset
                 stream.seek(offset)
 
@@ -276,7 +272,7 @@ class StructureMetaType(MetaType):
 
             bit_buffer.reset()
 
-            value = field.type._read(stream, result)
+            value = field.type._read(stream, context=result, endian=endian)
 
             result[field._name] = value
             if field.type.dynamic:
@@ -292,21 +288,21 @@ class StructureMetaType(MetaType):
         obj.__dynamic_sizes__ = sizes
         return obj
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:  # type: ignore
+    def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[Self]:  # type: ignore
         result = []
 
-        while obj := cls._read(stream, context):
+        while obj := cls._read(stream, context=context, endian=endian):
             result.append(obj)
 
         return result
 
-    def _write(cls, stream: BinaryIO, data: Structure) -> int:
-        bit_buffer = BitBuffer(stream, cls.cs.endian)
+    def _write(cls, stream: BinaryIO, data: Structure, *, endian: Endianness) -> int:
+        bit_buffer = BitBuffer(stream, endian=endian)
         struct_start = stream.tell()
         num = 0
 
         for field in cls.__fields__:
-            field_type = cls.cs.resolve(field.type)
+            field_type = field.type
 
             bit_field_type = (
                 (field_type.type if isinstance(field_type, EnumMetaType) else field_type) if field.bits else None
@@ -322,7 +318,7 @@ class StructureMetaType(MetaType):
             offset = stream.tell()
 
             if field.offset is not None and offset < struct_start + field.offset:
-                # Field is at a specific offset, either alligned or added that way
+                # Field is at a specific offset, either aligned or added that way
                 stream.write(b"\x00" * (struct_start + field.offset - offset))
                 offset = struct_start + field.offset
 
@@ -346,7 +342,7 @@ class StructureMetaType(MetaType):
                 else:
                     bit_buffer.write(field_type, value, field.bits)
             else:
-                field_type._write(stream, value)
+                field_type._write(stream, value, endian=endian)
                 num += stream.tell() - offset
 
         if bit_buffer._type is not None:
@@ -380,6 +376,102 @@ class StructureMetaType(MetaType):
         for key, value in classdict.items():
             setattr(cls, key, value)
 
+    def cdef(cls, *, recursive: bool = False) -> str:
+        """Render this structure (or union) back to its C-style definition.
+
+        When ``recursive=True``, any ``#define`` constants referenced in array sizes are emitted as well, so that the
+        result can be parsed on its own. Note that the result is semantically equivalent to the original definition,
+        but not necessarily identical.
+
+        Args:
+            recursive: Also emit the definitions of any types referenced by this structure.
+
+        Returns:
+            The C-style definition as a string.
+        """
+
+        def _decompose(type_: MetaType) -> tuple[MetaType, int, list[int | Expression | None]]:
+            dimensions = []
+            while issubclass(type_, BaseArray):
+                dimensions.append(type_.num_entries)
+                type_ = type_.type
+
+            stars = 0
+            while issubclass(type_, Pointer):
+                stars += 1
+                type_ = type_.type
+
+            return type_, stars, dimensions
+
+        def _deps(type_: StructureMetaType, seen: set[MetaType]) -> list[MetaType | str]:
+            deps = []
+            for field in type_.__fields__:
+                base, _, dimensions = _decompose(field.type)
+
+                for dim in dimensions:
+                    if isinstance(dim, Expression):
+                        for token in dim._tokens:
+                            if (
+                                token.type in IDENTIFIER_TYPES
+                                and token.value in cls.cs.consts
+                                and token.value not in seen
+                            ):
+                                deps.append(token.value)
+                                seen.add(token.value)
+
+                if isinstance(base, StructureMetaType) and base not in seen:
+                    if base.__anonymous__:
+                        # Anonymous structures are not emitted, but their dependencies are
+                        deps.extend(_deps(base, seen))
+                    else:
+                        seen.add(base)
+                        deps.extend(_deps(base, seen))
+                        deps.append(base)
+
+                elif isinstance(base, EnumMetaType) and base not in seen:
+                    seen.add(base)
+                    deps.append(base)
+
+            return deps
+
+        def _render_struct(type_: StructureMetaType, name: str) -> list[str]:
+            keyword = "union" if isinstance(type_, UnionMetaType) else "struct"
+            title = f"{keyword} {name}" if name else keyword
+
+            lines = [f"{title} {{"]
+            for field in type_.__fields__:
+                base, stars, dimensions = _decompose(field.type)
+
+                declarator = "*" * stars + (field.name or "") + "".join(f"[{dim or ''}]" for dim in dimensions)
+                if field.bits is not None:
+                    declarator = f"{declarator} : {field.bits}" if declarator else f": {field.bits}"
+
+                if isinstance(base, StructureMetaType) and base.__anonymous__:
+                    # Anonymous struct/union: inline the full definition
+                    lines.extend(f"    {line}" for line in _render_struct(base, ""))
+                    lines[-1] = f"{lines[-1]} {declarator};" if declarator else f"{lines[-1]};"
+                else:
+                    prefix = f"{base.__name__} " if declarator else base.__name__
+                    lines.append(f"    {prefix}{declarator};")
+
+            lines.append("}")
+            return lines
+
+        deps = _deps(cls, {cls}) if recursive else []
+        deps.append(cls)
+
+        consts = []
+        blocks = []
+        for type_ in deps:
+            if isinstance(type_, str):
+                consts.append(f"#define {type_} {cls.cs.consts[type_]!r}")
+            elif isinstance(type_, EnumMetaType):
+                blocks.append(type_.cdef())
+            else:
+                blocks.append("\n".join(_render_struct(type_, type_.__name__)) + ";")
+
+        return ("\n".join(consts) + "\n\n" if consts else "") + ("\n\n".join(blocks) if blocks else "")
+
 
 class Structure(BaseType, metaclass=StructureMetaType):
     """Base class for cstruct structure type classes.
@@ -459,6 +551,12 @@ class UnionMetaType(StructureMetaType):
     def __call__(cls, *args, **kwargs) -> Self:  # type: ignore
         obj: Union = super().__call__(*args, **kwargs)
 
+        if not hasattr(obj, "_buf"):
+            # If we don't have a _buf attribute, we haven't read from a stream and are initializing with values
+            # Set default internal attributes
+            object.__setattr__(obj, "_buf", None)
+            object.__setattr__(obj, "_endian", cls.cs.endian)
+
         # Calling with non-stream args or kwargs means we are initializing with values
         if (args and not (len(args) == 1 and (_is_readable_type(args[0]) or _is_buffer_type(args[0])))) or kwargs:
             # We don't support user initialization of dynamic unions yet
@@ -502,7 +600,7 @@ class UnionMetaType(StructureMetaType):
         return size, alignment
 
     def _read_fields(
-        cls, stream: BinaryIO, context: dict[str, Any] | None = None
+        cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness
     ) -> tuple[dict[str, Any], dict[str, int]]:
         result = {}
         sizes = {}
@@ -515,14 +613,14 @@ class UnionMetaType(StructureMetaType):
             buf = io.BytesIO(stream.read(cls.size))
 
         for field in cls.__fields__:
-            field_type = cls.cs.resolve(field.type)
+            field_type = field.type
 
             start = 0
             if field.offset is not None:
                 start = field.offset
 
             buf.seek(offset + start)
-            value = field_type._read(buf, result)
+            value = field_type._read(buf, context=result, endian=endian)
 
             result[field._name] = value
             if field.type.dynamic:
@@ -530,10 +628,10 @@ class UnionMetaType(StructureMetaType):
 
         return result, sizes
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:  # type: ignore
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:  # type: ignore
         if cls.size is None:
             start = stream.tell()
-            result, sizes = cls._read_fields(stream, context)
+            result, sizes = cls._read_fields(stream, context=context, endian=endian)
             size = stream.tell() - start
             stream.seek(start)
             buf = stream.read(size)
@@ -550,6 +648,7 @@ class UnionMetaType(StructureMetaType):
         obj: Union = type.__call__(cls, **result)
         object.__setattr__(obj, "__dynamic_sizes__", sizes)
         object.__setattr__(obj, "_buf", buf)
+        object.__setattr__(obj, "_endian", endian)
 
         if cls.size is not None:
             obj._update()
@@ -559,7 +658,7 @@ class UnionMetaType(StructureMetaType):
 
         return obj
 
-    def _write(cls, stream: BinaryIO, data: Union) -> int:
+    def _write(cls, stream: BinaryIO, data: Union, *, endian: Endianness) -> int:
         if cls.dynamic:
             raise NotImplementedError("Writing dynamic unions is not yet supported")
 
@@ -578,12 +677,12 @@ class UnionMetaType(StructureMetaType):
                 continue
 
             # Write the value
-            field.type._write(stream, getattr(data, field._name))
+            field.type._write(stream, getattr(data, field._name), endian=endian)
             break
 
         # If we haven't written anything yet and we initially skipped an anonymous struct, write it now
         if stream.tell() == offset and anonymous_struct:
-            anonymous_struct._write(stream, data)
+            anonymous_struct._write(stream, data, endian=endian)
 
         # If we haven't filled the union size yet, pad it
         if remaining := expected_offset - stream.tell():
@@ -596,6 +695,7 @@ class Union(Structure, metaclass=UnionMetaType):
     """Base class for cstruct union type classes."""
 
     _buf: bytes
+    _endian: Endianness
 
     def __eq__(self, other: object) -> bool:
         return self.__class__ is other.__class__ and bytes(self) == bytes(other)
@@ -619,7 +719,7 @@ class Union(Structure, metaclass=UnionMetaType):
         if (value := getattr(self, attr)) is None:
             value = field.type.__default__()
 
-        field.type._write(buf, value)
+        field.type._write(buf, value, endian=self._endian)
 
         object.__setattr__(self, "_buf", buf.getvalue())
         self._update()
@@ -628,7 +728,7 @@ class Union(Structure, metaclass=UnionMetaType):
         self._proxify()
 
     def _update(self) -> None:
-        result, sizes = self.__class__._read_fields(io.BytesIO(self._buf))
+        result, sizes = self.__class__._read_fields(io.BytesIO(self._buf), endian=self._endian)
         self.__dict__.update(result)
         object.__setattr__(self, "__dynamic_sizes__", sizes)
 

dissect/cstruct/types/void.py

@@ -7,6 +7,8 @@ from dissect.cstruct.types.base import BaseArray, BaseType
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import Endianness
+
 
 class VoidArray(list, BaseArray):
     """Array type representing void elements, primarily used for no-op reading and writing operations."""
@@ -16,11 +18,11 @@ class VoidArray(list, BaseArray):
         return cls()
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         return cls()
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: bytes) -> int:
+    def _write(cls, stream: BinaryIO, data: bytes, *, endian: Endianness) -> int:
         return 0
 
 
@@ -36,9 +38,9 @@ class Void(BaseType):
         return isinstance(value, Void)
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         return cls.__new__(cls)
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: Void) -> int:
+    def _write(cls, stream: BinaryIO, data: Void, *, endian: Endianness) -> int:
         return 0