Fix default initialization for various types

Author: Schamper

dissect/cstruct/types/base.py

@@ -36,14 +36,14 @@ def __call__(cls, *args, **kwargs) -> MetaType | BaseType:
         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)
@@ -83,7 +83,7 @@ def read(cls, obj: BinaryIO | bytes) -> BaseType:
         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)
@@ -179,7 +179,7 @@ def _write_0(cls, stream: BinaryIO, array: list[BaseType]) -> int:
             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,6 +225,11 @@ class ArrayMetaType(MetaType):
     num_entries: int | Expression | None
     null_terminated: bool
 
+    def default(cls) -> BaseType:
+        return type.__call__(
+            cls, [cls.type.default() for _ in range(cls.num_entries if isinstance(cls.num_entries, int) else 0)]
+        )
+
     def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Array:
         if cls.null_terminated:
             return cls.type._read_0(stream, context)
@@ -243,11 +248,6 @@ def _read(cls, stream: BinaryIO, context: dict[str, Any] = None) -> Array:
 
         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.
@@ -275,5 +275,13 @@ def _write(cls, stream: BinaryIO, data: list[Any]) -> int:
         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/enum.py

@@ -27,7 +27,7 @@ def __call__(
     ) -> 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
@@ -82,7 +82,7 @@ def _write_array(cls, stream: BinaryIO, array: list[Enum]) -> int:
 
     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/pointer.py

@@ -16,7 +16,7 @@ class Pointer(int, BaseType):
     _context: dict[str, Any]
     _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) -> Pointer:
         obj = super().__new__(cls, value)
         obj._stream = stream
         obj._context = context
@@ -65,6 +65,10 @@ def __xor__(self, other: int) -> Pointer:
     def __or__(self, other: int) -> Pointer:
         return type.__call__(self.__class__, int.__or__(self, other), self._stream, self._context)
 
+    @classmethod
+    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) -> Pointer:
         return cls.__new__(cls, cls.cs.pointer._read(stream, context), stream, context)
@@ -74,7 +78,7 @@ def _write(cls, stream: BinaryIO, data: int) -> int:
         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):