dissect.cstruct 4.2.dev1__py3-none-any.whl → 4.3.dev2__py3-none-any.whl

dissect/cstruct/cstruct.py

@@ -321,7 +321,7 @@ class cstruct:
         size: int | None,
         *,
         alignment: int | None = None,
-        attrs: dict[str, Any] = None,
+        attrs: dict[str, Any] | None = None,
     ) -> type[BaseType]:
         """Create a new type class bound to this cstruct instance.
 

dissect/cstruct/types/base.py

@@ -36,14 +36,14 @@ class MetaType(type):
         if len(args) == 1 and not isinstance(args[0], cls):
             stream = args[0]
 
-            if hasattr(stream, "read"):
+            if _is_readable_type(stream):
                 return cls._read(stream)
 
             if issubclass(cls, bytes) and isinstance(stream, bytes) and len(stream) == cls.size:
                 # Shortcut for char/bytes type
                 return type.__call__(cls, *args, **kwargs)
 
-            if isinstance(stream, (bytes, memoryview, bytearray)):
+            if _is_buffer_type(stream):
                 return cls.reads(stream)
 
         return type.__call__(cls, *args, **kwargs)
@@ -59,7 +59,7 @@ class MetaType(type):
 
         return cls.size
 
-    def default(cls) -> BaseType:
+    def __default__(cls) -> BaseType:
         """Return the default value of this type."""
         return cls()
 
@@ -83,7 +83,7 @@ class MetaType(type):
         Returns:
             The parsed value of this type.
         """
-        if isinstance(obj, (bytes, memoryview, bytearray)):
+        if _is_buffer_type(obj):
             return cls.reads(obj)
 
         return cls._read(obj)
@@ -113,7 +113,7 @@ class MetaType(type):
         cls._write(out, value)
         return out.getvalue()
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> BaseType:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> BaseType:
         """Internal function for reading value.
 
         Must be implemented per type.
@@ -124,7 +124,7 @@ class MetaType(type):
         """
         raise NotImplementedError()
 
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> list[BaseType]:
+    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[BaseType]:
         """Internal function for reading array values.
 
         Allows type implementations to do optimized reading for their type.
@@ -145,7 +145,7 @@ class MetaType(type):
 
         return [cls._read(stream, context) for _ in range(count)]
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> list[BaseType]:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[BaseType]:
         """Internal function for reading null-terminated data.
 
         "Null" is type specific, so must be implemented per type.
@@ -179,7 +179,7 @@ class MetaType(type):
             stream: The stream to read from.
             array: The array to write.
         """
-        return cls._write_array(stream, array + [cls()])
+        return cls._write_array(stream, array + [cls.__default__()])
 
 
 class _overload:
@@ -225,7 +225,12 @@ class ArrayMetaType(MetaType):
     num_entries: int | Expression | None
     null_terminated: bool
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Array:
+    def __default__(cls) -> BaseType:
+        return type.__call__(
+            cls, [cls.type.__default__()] * (cls.num_entries if isinstance(cls.num_entries, int) else 0)
+        )
+
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Array:
         if cls.null_terminated:
             return cls.type._read_0(stream, context)
 
@@ -243,11 +248,6 @@ class ArrayMetaType(MetaType):
 
         return cls.type._read_array(stream, num, context)
 
-    def default(cls) -> BaseType:
-        return type.__call__(
-            cls, [cls.type.default() for _ in range(0 if cls.dynamic or cls.null_terminated else cls.num_entries)]
-        )
-
 
 class Array(list, BaseType, metaclass=ArrayMetaType):
     """Implements a fixed or dynamically sized array type.
@@ -261,7 +261,7 @@ class Array(list, BaseType, metaclass=ArrayMetaType):
     """
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Array:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Array:
         return cls(ArrayMetaType._read(cls, stream, context))
 
     @classmethod
@@ -275,5 +275,13 @@ class Array(list, BaseType, metaclass=ArrayMetaType):
         return cls.type._write_array(stream, data)
 
 
+def _is_readable_type(value: Any) -> bool:
+    return hasattr(value, "read")
+
+
+def _is_buffer_type(value: Any) -> bool:
+    return isinstance(value, (bytes, memoryview, bytearray))
+
+
 # As mentioned in the BaseType class, we correctly set the type here
 MetaType.ArrayType = Array

dissect/cstruct/types/char.py

@@ -9,7 +9,7 @@ class CharArray(bytes, BaseType, metaclass=ArrayMetaType):
     """Character array type for reading and writing byte strings."""
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> CharArray:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> CharArray:
         return type.__call__(cls, ArrayMetaType._read(cls, stream, context))
 
     @classmethod
@@ -25,7 +25,7 @@ class CharArray(bytes, BaseType, metaclass=ArrayMetaType):
         return stream.write(data)
 
     @classmethod
-    def default(cls) -> CharArray:
+    def __default__(cls) -> CharArray:
         return type.__call__(cls, b"\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
 
 
@@ -35,11 +35,11 @@ class Char(bytes, BaseType):
     ArrayType = CharArray
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Char:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Char:
         return cls._read_array(stream, 1, context)
 
     @classmethod
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> Char:
+    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> Char:
         if count == 0:
             return type.__call__(cls, b"")
 
@@ -50,7 +50,7 @@ class Char(bytes, BaseType):
         return type.__call__(cls, data)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Char:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Char:
         buf = []
         while True:
             byte = stream.read(1)
@@ -75,5 +75,5 @@ class Char(bytes, BaseType):
         return stream.write(data)
 
     @classmethod
-    def default(cls) -> Char:
+    def __default__(cls) -> Char:
         return type.__call__(cls, b"\x00")

dissect/cstruct/types/enum.py

@@ -27,7 +27,7 @@ class EnumMetaType(EnumMeta, MetaType):
     ) -> EnumMetaType:
         if name is None:
             if value is None:
-                value = cls.type()
+                value = cls.type.__default__()
 
             if not isinstance(value, int):
                 # value is a parsable value
@@ -64,13 +64,13 @@ class EnumMetaType(EnumMeta, MetaType):
                 return True
             return value in cls._value2member_map_
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Enum:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Enum:
         return cls(cls.type._read(stream, context))
 
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> list[Enum]:
+    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Enum]:
         return list(map(cls, cls.type._read_array(stream, count, context)))
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> list[Enum]:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Enum]:
         return list(map(cls, cls.type._read_0(stream, context)))
 
     def _write(cls, stream: BinaryIO, data: Enum) -> int:
@@ -82,7 +82,7 @@ class EnumMetaType(EnumMeta, MetaType):
 
     def _write_0(cls, stream: BinaryIO, array: list[BaseType]) -> int:
         data = [entry.value if isinstance(entry, Enum) else entry for entry in array]
-        return cls._write_array(stream, data + [cls.type()])
+        return cls._write_array(stream, data + [cls.type.__default__()])
 
 
 def _fix_alias_members(cls: type[Enum]) -> None:

dissect/cstruct/types/int.py

@@ -12,7 +12,7 @@ class Int(int, BaseType):
     signed: bool
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Int:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Int:
         data = stream.read(cls.size)
 
         if len(data) != cls.size:
@@ -21,7 +21,7 @@ class Int(int, BaseType):
         return cls.from_bytes(data, ENDIANNESS_MAP[cls.cs.endian], signed=cls.signed)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Int:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Int:
         result = []
 
         while True:

dissect/cstruct/types/leb128.py

@@ -14,7 +14,7 @@ class LEB128(int, BaseType):
     signed: bool
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> LEB128:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> LEB128:
         result = 0
         shift = 0
         while True:
@@ -35,7 +35,7 @@ class LEB128(int, BaseType):
         return cls.__new__(cls, result)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> LEB128:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> LEB128:
         result = []
 
         while True:

dissect/cstruct/types/packed.py

@@ -18,11 +18,11 @@ class Packed(BaseType):
     packchar: str
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Packed:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Packed:
         return cls._read_array(stream, 1, context)[0]
 
     @classmethod
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> list[Packed]:
+    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Packed]:
         if count == EOF:
             data = stream.read()
             length = len(data)
@@ -39,7 +39,7 @@ class Packed(BaseType):
         return [cls.__new__(cls, value) for value in fmt.unpack(data)]
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Packed:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Packed:
         result = []
 
         fmt = _struct(cls.cs.endian, cls.packchar)

dissect/cstruct/types/pointer.py

@@ -12,11 +12,11 @@ class Pointer(int, BaseType):
     """Pointer to some other type."""
 
     type: MetaType
-    _stream: BinaryIO
-    _context: dict[str, Any]
+    _stream: BinaryIO | None
+    _context: dict[str, Any] | None
     _value: BaseType
 
-    def __new__(cls, value: int, stream: BinaryIO, context: dict[str, Any] = None) -> Pointer:
+    def __new__(cls, value: int, stream: BinaryIO | None, context: dict[str, Any] | None = None) -> Pointer:
         obj = super().__new__(cls, value)
         obj._stream = stream
         obj._context = context
@@ -66,7 +66,11 @@ class Pointer(int, BaseType):
         return type.__call__(self.__class__, int.__or__(self, other), self._stream, self._context)
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Pointer:
+    def __default__(cls) -> Pointer:
+        return cls.__new__(cls, cls.cs.pointer.__default__(), None, None)
+
+    @classmethod
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Pointer:
         return cls.__new__(cls, cls.cs.pointer._read(stream, context), stream, context)
 
     @classmethod
@@ -74,7 +78,7 @@ class Pointer(int, BaseType):
         return cls.cs.pointer._write(stream, data)
 
     def dereference(self) -> Any:
-        if self == 0:
+        if self == 0 or self._stream is None:
             raise NullPointerDereference()
 
         if self._value is None and not issubclass(self.type, Void):

dissect/cstruct/types/structure.py

@@ -4,13 +4,19 @@ import io
 from contextlib import contextmanager
 from enum import Enum
 from functools import lru_cache
+from itertools import chain
 from operator import attrgetter
 from textwrap import dedent
 from types import FunctionType
-from typing import Any, BinaryIO, Callable, ContextManager
+from typing import Any, BinaryIO, Callable, Iterator
 
 from dissect.cstruct.bitbuffer import BitBuffer
-from dissect.cstruct.types.base import BaseType, MetaType
+from dissect.cstruct.types.base import (
+    BaseType,
+    MetaType,
+    _is_buffer_type,
+    _is_readable_type,
+)
 from dissect.cstruct.types.enum import EnumMetaType
 from dissect.cstruct.types.pointer import Pointer
 
@@ -65,7 +71,7 @@ class StructureMetaType(MetaType):
             # Shortcut for single char/bytes type
             return type.__call__(cls, *args, **kwargs)
         elif not args and not kwargs:
-            obj = cls(**{field.name: field.type.default() for field in cls.__fields__})
+            obj = type.__call__(cls)
             object.__setattr__(obj, "_values", {})
             object.__setattr__(obj, "_sizes", {})
             return obj
@@ -77,7 +83,6 @@ class StructureMetaType(MetaType):
 
         lookup = {}
         raw_lookup = {}
-        init_names = []
         field_names = []
         for field in fields:
             if field.name in lookup and field.name != "_":
@@ -94,25 +99,21 @@ class StructureMetaType(MetaType):
 
             raw_lookup[field.name] = field
 
-        num_fields = len(lookup)
         field_names = lookup.keys()
-        init_names = raw_lookup.keys()
         classdict["fields"] = lookup
         classdict["lookup"] = raw_lookup
         classdict["__fields__"] = fields
-        classdict["__bool__"] = _patch_attributes(_make__bool__(num_fields), field_names, 1)
+        classdict["__bool__"] = _generate__bool__(field_names)
 
         if issubclass(cls, UnionMetaType) or isinstance(cls, UnionMetaType):
-            classdict["__init__"] = _patch_setattr_args_and_attributes(
-                _make_setattr__init__(len(init_names)), init_names
-            )
+            classdict["__init__"] = _generate_union__init__(raw_lookup.values())
             # Not a great way to do this but it works for now
             classdict["__eq__"] = Union.__eq__
         else:
-            classdict["__init__"] = _patch_args_and_attributes(_make__init__(len(init_names)), init_names)
-            classdict["__eq__"] = _patch_attributes(_make__eq__(num_fields), field_names, 1)
+            classdict["__init__"] = _generate_structure__init__(raw_lookup.values())
+            classdict["__eq__"] = _generate__eq__(field_names)
 
-        classdict["__hash__"] = _patch_attributes(_make__hash__(num_fields), field_names, 1)
+        classdict["__hash__"] = _generate__hash__(field_names)
 
         # If we're calling this as a class method or a function on the metaclass
         if issubclass(cls, type):
@@ -229,7 +230,7 @@ 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) -> Structure:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Structure:
         bit_buffer = BitBuffer(stream, cls.cs.endian)
         struct_start = stream.tell()
 
@@ -271,12 +272,14 @@ class StructureMetaType(MetaType):
             # Align the stream
             stream.seek(-stream.tell() & (cls.alignment - 1), io.SEEK_CUR)
 
-        obj = cls(**result)
+        # Using type.__call__ directly calls the __init__ method of the class
+        # This is faster than calling cls() and bypasses the metaclass __call__ method
+        obj = type.__call__(cls, **result)
         obj._sizes = sizes
         obj._values = result
         return obj
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> list[Structure]:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Structure]:
         result = []
 
         while obj := cls._read(stream, context):
@@ -322,7 +325,7 @@ class StructureMetaType(MetaType):
 
             value = getattr(data, field.name, None)
             if value is None:
-                value = field_type()
+                value = field_type.__default__()
 
             if field.bits:
                 if isinstance(field_type, EnumMetaType):
@@ -350,7 +353,7 @@ class StructureMetaType(MetaType):
             cls.commit()
 
     @contextmanager
-    def start_update(cls) -> ContextManager:
+    def start_update(cls) -> Iterator[None]:
         try:
             cls.__updating__ = True
             yield
@@ -397,11 +400,27 @@ class UnionMetaType(StructureMetaType):
     """Base metaclass for cstruct union type classes."""
 
     def __call__(cls, *args, **kwargs) -> Union:
-        obj = super().__call__(*args, **kwargs)
-        if kwargs:
-            # Calling with kwargs means we are initializing with values
-            # Proxify all values
+        obj: Union = super().__call__(*args, **kwargs)
+
+        # 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
+            if cls.dynamic:
+                raise NotImplementedError("Initializing a dynamic union is not yet supported")
+
+            # User (partial) initialization, rebuild the union
+            # First user-provided field is the one used to rebuild the union
+            arg_fields = (field.name for _, field in zip(args, cls.__fields__))
+            kwarg_fields = (name for name in kwargs if name in cls.lookup)
+            if (first_field := next(chain(arg_fields, kwarg_fields), None)) is not None:
+                obj._rebuild(first_field)
+        elif not args and not kwargs:
+            # Initialized with default values
+            # Note that we proxify here in case we have a default initialization (cls())
+            # We don't proxify in case we read from a stream, as we do that later on in _read at a more appropriate time
+            # Same with (partial) user initialization, we do that after rebuilding the union
             obj._proxify()
+
         return obj
 
     def _calculate_size_and_offsets(cls, fields: list[Field], align: bool = False) -> tuple[int | None, int]:
@@ -425,7 +444,9 @@ class UnionMetaType(StructureMetaType):
 
         return size, alignment
 
-    def _read_fields(cls, stream: BinaryIO, context: dict[str, Any] = None) -> tuple[dict[str, Any], dict[str, int]]:
+    def _read_fields(
+        cls, stream: BinaryIO, context: dict[str, Any] | None = None
+    ) -> tuple[dict[str, Any], dict[str, int]]:
         result = {}
         sizes = {}
 
@@ -451,7 +472,7 @@ class UnionMetaType(StructureMetaType):
 
         return result, sizes
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Union:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Union:
         if cls.size is None:
             start = stream.tell()
             result, sizes = cls._read_fields(stream, context)
@@ -463,7 +484,12 @@ class UnionMetaType(StructureMetaType):
             sizes = {}
             buf = stream.read(cls.size)
 
-        obj: Union = cls(**result)
+        # Create the object and set the values
+        # Using type.__call__ directly calls the __init__ method of the class
+        # This is faster than calling cls() and bypasses the metaclass __call__ method
+        # It also makes it easier to differentiate between user-initialization of the class
+        # and initialization from a stream read
+        obj: Union = type.__call__(cls, **result)
         object.__setattr__(obj, "_values", result)
         object.__setattr__(obj, "_sizes", sizes)
         object.__setattr__(obj, "_buf", buf)
@@ -471,14 +497,20 @@ class UnionMetaType(StructureMetaType):
         if cls.size is not None:
             obj._update()
 
+        # Proxify any nested structures
+        obj._proxify()
+
         return obj
 
     def _write(cls, stream: BinaryIO, data: Union) -> int:
+        if cls.dynamic:
+            raise NotImplementedError("Writing dynamic unions is not yet supported")
+
         offset = stream.tell()
         expected_offset = offset + len(cls)
 
         # Sort by largest field
-        fields = sorted(cls.__fields__, key=lambda e: len(e.type), reverse=True)
+        fields = sorted(cls.__fields__, key=lambda e: e.type.size or 0, reverse=True)
         anonymous_struct = False
 
         # Try to write by largest field
@@ -488,12 +520,8 @@ class UnionMetaType(StructureMetaType):
                 anonymous_struct = field.type
                 continue
 
-            # Skip empty values
-            if (value := getattr(data, field.name)) is None:
-                continue
-
-            # We have a value, write it
-            field.type._write(stream, value)
+            # Write the value
+            field.type._write(stream, getattr(data, field.name))
             break
 
         # If we haven't written anything yet and we initially skipped an anonymous struct, write it now
@@ -527,14 +555,21 @@ class Union(Structure, metaclass=UnionMetaType):
             cur_buf = b"\x00" * self.__class__.size
 
         buf = io.BytesIO(cur_buf)
-        field = self.__class__.fields[attr]
+        field = self.__class__.lookup[attr]
         if field.offset:
             buf.seek(field.offset)
-        field.type._write(buf, getattr(self, attr))
+
+        if (value := getattr(self, attr)) is None:
+            value = field.type.__default__()
+
+        field.type._write(buf, value)
 
         object.__setattr__(self, "_buf", buf.getvalue())
         self._update()
 
+        # (Re-)proxify all values
+        self._proxify()
+
     def _update(self) -> None:
         result, sizes = self.__class__._read_fields(io.BytesIO(self._buf))
         self.__dict__.update(result)
@@ -596,65 +631,71 @@ def attrsetter(path: str) -> Callable[[Any], Any]:
 
 
 def _codegen(func: FunctionType) -> FunctionType:
-    # Inspired by https://github.com/dabeaz/dataklasses
-    @lru_cache
-    def make_func_code(num_fields: int) -> FunctionType:
-        names = [f"_{n}" for n in range(num_fields)]
-        exec(func(names), {}, d := {})
-        return d.popitem()[1]
+    """Decorator that generates a template function with a specified number of fields.
 
-    return make_func_code
+    This code is a little complex but allows use to cache generated functions for a specific number of fields.
+    For example, if we generate a structure with 10 fields, we can cache the generated code for that structure.
+    We can then reuse that code and patch it with the correct field names when we create a new structure with 10 fields.
 
+    The functions that are decorated with this decorator should take a list of field names and return a string of code.
+    The decorated function is needs to be called with the number of fields, instead of the field names.
+    The confusing part is that that the original function takes field names, but you then call it with
+    the number of fields instead.
 
-def _patch_args_and_attributes(func: FunctionType, fields: list[str], start: int = 0) -> FunctionType:
-    return type(func)(
-        func.__code__.replace(
-            co_names=(*func.__code__.co_names[:start], *fields),
-            co_varnames=("self", *fields),
-        ),
-        func.__globals__,
-        argdefs=func.__defaults__,
-    )
+    Inspired by https://github.com/dabeaz/dataklasses.
 
+    Args:
+        func: The decorated function that takes a list of field names and returns a string of code.
 
-def _patch_setattr_args_and_attributes(func: FunctionType, fields: list[str], start: int = 0) -> FunctionType:
-    return type(func)(
-        func.__code__.replace(
-            co_consts=(None, *fields),
-            co_varnames=("self", *fields),
-        ),
-        func.__globals__,
-        argdefs=func.__defaults__,
-    )
+    Returns:
+        A cached function that generates the desired function code, to be called with the number of fields.
+    """
 
+    def make_func_code(num_fields: int) -> FunctionType:
+        exec(func([f"_{n}" for n in range(num_fields)]), {}, d := {})
+        return d.popitem()[1]
 
-def _patch_attributes(func: FunctionType, fields: list[str], start: int = 0) -> FunctionType:
-    return type(func)(
-        func.__code__.replace(co_names=(*func.__code__.co_names[:start], *fields)),
-        func.__globals__,
-    )
+    make_func_code.__wrapped__ = func
+    return lru_cache(make_func_code)
 
 
 @_codegen
-def _make__init__(fields: list[str]) -> str:
+def _make_structure__init__(fields: list[str]) -> str:
+    """Generates an ``__init__`` method for a structure with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
     field_args = ", ".join(f"{field} = None" for field in fields)
-    field_init = "\n".join(f" self.{name} = {name}" for name in fields)
+    field_init = "\n".join(f" self.{name} = {name} if {name} is not None else {i}" for i, name in enumerate(fields))
 
-    code = f"def __init__(self{', ' + field_args if field_args else ''}):\n"
+    code = f"def __init__(self{', ' + field_args or ''}):\n"
     return code + (field_init or " pass")
 
 
 @_codegen
-def _make_setattr__init__(fields: list[str]) -> str:
+def _make_union__init__(fields: list[str]) -> str:
+    """Generates an ``__init__`` method for a class with the specified fields using setattr.
+
+    Args:
+        fields: List of field names.
+    """
     field_args = ", ".join(f"{field} = None" for field in fields)
-    field_init = "\n".join(f" object.__setattr__(self, {name!r}, {name})" for name in fields)
+    field_init = "\n".join(
+        f" object.__setattr__(self, '{name}', {name} if {name} is not None else {i})" for i, name in enumerate(fields)
+    )
 
-    code = f"def __init__(self{', ' + field_args if field_args else ''}):\n"
+    code = f"def __init__(self{', ' + field_args or ''}):\n"
     return code + (field_init or " pass")
 
 
 @_codegen
 def _make__eq__(fields: list[str]) -> str:
+    """Generates an ``__eq__`` method for a class with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
     self_vals = ",".join(f"self.{name}" for name in fields)
     other_vals = ",".join(f"other.{name}" for name in fields)
 
@@ -676,6 +717,11 @@ def _make__eq__(fields: list[str]) -> str:
 
 @_codegen
 def _make__bool__(fields: list[str]) -> str:
+    """Generates a ``__bool__`` method for a class with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
     vals = ", ".join(f"self.{name}" for name in fields)
 
     code = f"""
@@ -688,6 +734,11 @@ def _make__bool__(fields: list[str]) -> str:
 
 @_codegen
 def _make__hash__(fields: list[str]) -> str:
+    """Generates a ``__hash__`` method for a class with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
     vals = ", ".join(f"self.{name}" for name in fields)
 
     code = f"""
@@ -696,3 +747,83 @@ def _make__hash__(fields: list[str]) -> str:
     """
 
     return dedent(code)
+
+
+def _patch_attributes(func: FunctionType, fields: list[str], start: int = 0) -> FunctionType:
+    """Patches a function's attributes.
+
+    Args:
+        func: The function to patch.
+        fields: List of field names to add.
+        start: The starting index for patching. Defaults to 0.
+    """
+    return type(func)(
+        func.__code__.replace(co_names=(*func.__code__.co_names[:start], *fields)),
+        func.__globals__,
+    )
+
+
+def _generate_structure__init__(fields: list[Field]) -> FunctionType:
+    """Generates an ``__init__`` method for a structure with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
+    field_names = [field.name for field in fields]
+
+    template: FunctionType = _make_structure__init__(len(field_names))
+    return type(template)(
+        template.__code__.replace(
+            co_consts=(None, *[field.type.__default__() for field in fields]),
+            co_names=(*field_names,),
+            co_varnames=("self", *field_names),
+        ),
+        template.__globals__,
+        argdefs=template.__defaults__,
+    )
+
+
+def _generate_union__init__(fields: list[Field]) -> FunctionType:
+    """Generates an ``__init__`` method for a union with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
+    field_names = [field.name for field in fields]
+
+    template: FunctionType = _make_union__init__(len(field_names))
+    return type(template)(
+        template.__code__.replace(
+            co_consts=(None, *sum([(field.name, field.type.__default__()) for field in fields], ())),
+            co_varnames=("self", *field_names),
+        ),
+        template.__globals__,
+        argdefs=template.__defaults__,
+    )
+
+
+def _generate__eq__(fields: list[str]) -> FunctionType:
+    """Generates an ``__eq__`` method for a class with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
+    return _patch_attributes(_make__eq__(len(fields)), fields, 1)
+
+
+def _generate__bool__(fields: list[str]) -> FunctionType:
+    """Generates a ``__bool__`` method for a class with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
+    return _patch_attributes(_make__bool__(len(fields)), fields, 1)
+
+
+def _generate__hash__(fields: list[str]) -> FunctionType:
+    """Generates a ``__hash__`` method for a class with the specified fields.
+
+    Args:
+        fields: List of field names.
+    """
+    return _patch_attributes(_make__hash__(len(fields)), fields, 1)

dissect/cstruct/types/void.py

@@ -11,10 +11,17 @@ class Void(BaseType):
     def __bool__(self) -> bool:
         return False
 
+    def __eq__(self, value: object) -> bool:
+        return isinstance(value, Void)
+
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Void:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Void:
         return cls.__new__(cls)
 
+    @classmethod
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Void:
+        return [cls.__new__(cls)]
+
     @classmethod
     def _write(cls, stream: BinaryIO, data: Void) -> int:
         return 0

dissect/cstruct/types/wchar.py

@@ -10,7 +10,7 @@ class WcharArray(str, BaseType, metaclass=ArrayMetaType):
     """Wide-character array type for reading and writing UTF-16 strings."""
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> WcharArray:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> WcharArray:
         return type.__call__(cls, ArrayMetaType._read(cls, stream, context))
 
     @classmethod
@@ -20,7 +20,7 @@ class WcharArray(str, BaseType, metaclass=ArrayMetaType):
         return stream.write(data.encode(Wchar.__encoding_map__[cls.cs.endian]))
 
     @classmethod
-    def default(cls) -> WcharArray:
+    def __default__(cls) -> WcharArray:
         return type.__call__(cls, "\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
 
 
@@ -38,11 +38,11 @@ class Wchar(str, BaseType):
     }
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Wchar:
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Wchar:
         return cls._read_array(stream, 1, context)
 
     @classmethod
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> Wchar:
+    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> Wchar:
         if count == 0:
             return type.__call__(cls, "")
 
@@ -56,7 +56,7 @@ class Wchar(str, BaseType):
         return type.__call__(cls, data.decode(cls.__encoding_map__[cls.cs.endian]))
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Wchar:
+    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Wchar:
         buf = []
         while True:
             point = stream.read(2)
@@ -75,5 +75,5 @@ class Wchar(str, BaseType):
         return stream.write(data.encode(cls.__encoding_map__[cls.cs.endian]))
 
     @classmethod
-    def default(cls) -> Wchar:
+    def __default__(cls) -> Wchar:
         return type.__call__(cls, "\x00")

{dissect.cstruct-4.2.dev1.dist-info → dissect.cstruct-4.3.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.cstruct
-Version: 4.2.dev1
+Version: 4.3.dev2
 Summary: A Dissect module implementing a parser for C-like structures: structure parsing in Python made easy
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Apache License 2.0

dissect.cstruct-4.3.dev2.dist-info/RECORD

@@ -0,0 +1,26 @@
+dissect/cstruct/__init__.py,sha256=E8HT9kh67nPR6cnUmTmTJIdGANNfInG_htxb8mPjSik,1344
+dissect/cstruct/bitbuffer.py,sha256=phqKSE-BS8crZ_sdzssF3E831bD5Gk8LOXIE7iQJXa8,2218
+dissect/cstruct/compiler.py,sha256=dB7Wi1GC0pYoVe5x3olZDmAT3ypbyV-1h-BMefJk5dU,13991
+dissect/cstruct/cstruct.py,sha256=2Hu0HSFucV1pY2QAnteqHnpob9jmqPr_glfnGZigfjo,14858
+dissect/cstruct/exceptions.py,sha256=WqsUW4OiIpRLQLvixfLrfKl0rtvU1qx7pvfBrz9Sz-I,293
+dissect/cstruct/expression.py,sha256=giBNkbFgsbsw2K2EvQi42GRlm9Z97UvhDhcHnNMG2dg,10763
+dissect/cstruct/parser.py,sha256=kL9caswfpm6ltXoJfetf5UjEfOLIqj7WGMqdID8C2W4,20893
+dissect/cstruct/utils.py,sha256=ze_i59PRxQ1q0xl-wsV_ZLKSnBirT71fvxfKEshgc18,10386
+dissect/cstruct/types/__init__.py,sha256=basF3huZ-jOg4FqGQGW7-SmYDN2GuMuCQN21asLtelQ,855
+dissect/cstruct/types/base.py,sha256=PB_H7PRt0pLehThnQQVNFBmKIfQRnlfXYfw7pNZdBaQ,9120
+dissect/cstruct/types/char.py,sha256=XWBtODCWKYtZYml5MKlvxrnRyH2emiGa_To7RrwJc_Y,2433
+dissect/cstruct/types/enum.py,sha256=OyW1HmdTg7B1_FNMckez1vOTlwAfPKj6cfM9ITAxEkw,6746
+dissect/cstruct/types/flag.py,sha256=EOJVk-5G7aUtD6plg7_Y6yxoAcrAQCNMjxoUePEQukk,2345
+dissect/cstruct/types/int.py,sha256=ihV8v6eR1k2Pnc7dAroxQOGhjQ0Um1coiJMAVHYqWn4,1081
+dissect/cstruct/types/leb128.py,sha256=OYwwwGSTU2npHZVZxMV9PTseug7hBoy1A44Uj_dhtNs,2182
+dissect/cstruct/types/packed.py,sha256=V0rEpxHJ3GOlUv9rzi94U8GyN6ArxW7CSPhBPk90qSc,1994
+dissect/cstruct/types/pointer.py,sha256=2Ve0b6VxGpckK2CtHtTzQyU5tSSotnPZFu7ZoP9WqMI,3832
+dissect/cstruct/types/structure.py,sha256=_9JCSjj_BsHr16HYwv6IAXHLt1B4yH0n3S8D2WclBmU,29481
+dissect/cstruct/types/void.py,sha256=VL2qJ86rq-oBUnkBprNsPPgPGgHV6UENRJTQ2jw0rxc,669
+dissect/cstruct/types/wchar.py,sha256=ZL54AuYndQLj46-QgxSFbmd18saRgYwyJaNTwxZCsqU,2572
+dissect.cstruct-4.3.dev2.dist-info/COPYRIGHT,sha256=H-18RXfshdH9AdHwW2eO1Xa-5s6tY5eipHh5c0whDu4,316
+dissect.cstruct-4.3.dev2.dist-info/LICENSE,sha256=PhUqiw6jAh2KbBdVRPBq_hfAvfcTBin7nZ3CK7NQbTM,11341
+dissect.cstruct-4.3.dev2.dist-info/METADATA,sha256=jyWC9013BoKf9h7vS1EAeFY1pHdV3GlhH6ATVA9MaOw,8558
+dissect.cstruct-4.3.dev2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+dissect.cstruct-4.3.dev2.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
+dissect.cstruct-4.3.dev2.dist-info/RECORD,,

{dissect.cstruct-4.2.dev1.dist-info → dissect.cstruct-4.3.dev2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dissect.cstruct-4.2.dev1.dist-info/RECORD

@@ -1,26 +0,0 @@
-dissect/cstruct/__init__.py,sha256=E8HT9kh67nPR6cnUmTmTJIdGANNfInG_htxb8mPjSik,1344
-dissect/cstruct/bitbuffer.py,sha256=phqKSE-BS8crZ_sdzssF3E831bD5Gk8LOXIE7iQJXa8,2218
-dissect/cstruct/compiler.py,sha256=dB7Wi1GC0pYoVe5x3olZDmAT3ypbyV-1h-BMefJk5dU,13991
-dissect/cstruct/cstruct.py,sha256=W-17FFc8OM2je7VTMMVQc-hivCAjaRj9qSdf4cEDrCY,14851
-dissect/cstruct/exceptions.py,sha256=WqsUW4OiIpRLQLvixfLrfKl0rtvU1qx7pvfBrz9Sz-I,293
-dissect/cstruct/expression.py,sha256=giBNkbFgsbsw2K2EvQi42GRlm9Z97UvhDhcHnNMG2dg,10763
-dissect/cstruct/parser.py,sha256=kL9caswfpm6ltXoJfetf5UjEfOLIqj7WGMqdID8C2W4,20893
-dissect/cstruct/utils.py,sha256=ze_i59PRxQ1q0xl-wsV_ZLKSnBirT71fvxfKEshgc18,10386
-dissect/cstruct/types/__init__.py,sha256=basF3huZ-jOg4FqGQGW7-SmYDN2GuMuCQN21asLtelQ,855
-dissect/cstruct/types/base.py,sha256=qZeXn1MAEb-vOlF4HdeqbMHx4-Mr5lTcHYt_s0lhu9g,8944
-dissect/cstruct/types/char.py,sha256=M_QmYL8c96bIO8r2nxHC26zXoPjO2dMtehoWtZJL2M8,2397
-dissect/cstruct/types/enum.py,sha256=1P-GUSRLWAKRcn55XhPYvK9KVMdX3x7GdmdDUy2HuEQ,6701
-dissect/cstruct/types/flag.py,sha256=EOJVk-5G7aUtD6plg7_Y6yxoAcrAQCNMjxoUePEQukk,2345
-dissect/cstruct/types/int.py,sha256=pBdr9InRY3EMHlULBmzBZCI2Qdh2XygsUelDWBrIRhc,1067
-dissect/cstruct/types/leb128.py,sha256=yHkWqcGEWkf-8ZzfLv_5p937fzrMRvlZXwxowEl36CU,2168
-dissect/cstruct/types/packed.py,sha256=gmNxtNRf9feY8k_7UYMGADe31dtXkw5fQYG1CtyvJBo,1973
-dissect/cstruct/types/pointer.py,sha256=kWfEBCgW7TDnJihZiDGUlldD3QSxVY19r8LGz7olswk,3644
-dissect/cstruct/types/structure.py,sha256=3pdEg_Jc4py7xzkcp06r4LtH-L_uhdlFhuhdP-zX3ww,24426
-dissect/cstruct/types/void.py,sha256=RGBlM1yBYCFUM9yLyOETMZBd_nEp9-6vH5xFXaphK8o,438
-dissect/cstruct/types/wchar.py,sha256=5kap4GDypRmt5IoLhMnREbWaWTEMhY_xVLCFginbwFo,2536
-dissect.cstruct-4.2.dev1.dist-info/COPYRIGHT,sha256=H-18RXfshdH9AdHwW2eO1Xa-5s6tY5eipHh5c0whDu4,316
-dissect.cstruct-4.2.dev1.dist-info/LICENSE,sha256=PhUqiw6jAh2KbBdVRPBq_hfAvfcTBin7nZ3CK7NQbTM,11341
-dissect.cstruct-4.2.dev1.dist-info/METADATA,sha256=93eUYeGsSm9i_1aKIm5qc_tEV5RRTkJJTduscjrFZic,8558
-dissect.cstruct-4.2.dev1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-dissect.cstruct-4.2.dev1.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
-dissect.cstruct-4.2.dev1.dist-info/RECORD,,