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

dissect/cstruct/__init__.py

@@ -30,12 +30,18 @@ from dissect.cstruct.types import (
 )
 from dissect.cstruct.util import (
     dumpstruct,
+    f16,
+    f32,
+    f64,
     hexdump,
     p8,
     p16,
     p32,
     p64,
     pack,
+    pf16,
+    pf32,
+    pf64,
     swap,
     swap16,
     swap32,
@@ -75,12 +81,18 @@ __all__ = [
     "ctypes",
     "ctypes_type",
     "dumpstruct",
+    "f16",
+    "f32",
+    "f64",
     "hexdump",
     "p8",
     "p16",
     "p32",
     "p64",
     "pack",
+    "pf16",
+    "pf32",
+    "pf64",
     "swap",
     "swap16",
     "swap32",

dissect/cstruct/bitbuffer.py

@@ -19,11 +19,11 @@ class BitBuffer:
 
     def read(self, field_type: type[BaseType], bits: int) -> int:
         if self._remaining == 0 or self._type != field_type:
-            if field_type.size is None:
+            if field_type.__size__ is None:
                 raise ValueError("Reading variable-length fields is unsupported")
 
             self._type = field_type
-            self._remaining = field_type.size * 8
+            self._remaining = field_type.__size__ * 8
             self._buffer = field_type._read(self.stream, endian=self.endian)
 
         if isinstance(self._buffer, bytes):
@@ -51,17 +51,17 @@ class BitBuffer:
             if self._type:
                 self.flush()
 
-            if field_type.size is None:
+            if field_type.__size__ is None:
                 raise ValueError("Writing variable-length fields is unsupported")
 
-            self._remaining = field_type.size * 8
+            self._remaining = field_type.__size__ * 8
             self._type = field_type
 
-        if self._type is None or self._type.size is None:
+        if self._type is None or self._type.__size__ is None:
             raise ValueError("Invalid state")
 
         if self.endian == "<":
-            self._buffer |= data << (self._type.size * 8 - self._remaining)
+            self._buffer |= data << (self._type.__size__ * 8 - self._remaining)
         else:
             self._buffer |= data << (self._remaining - bits)
 

dissect/cstruct/compiler.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING
 from dissect.cstruct.bitbuffer import BitBuffer
 from dissect.cstruct.types import (
     Array,
+    BaseArray,
     Char,
     CharArray,
     Flag,
@@ -24,18 +25,15 @@ from dissect.cstruct.types import (
     Wchar,
     WcharArray,
 )
-from dissect.cstruct.types.base import BaseArray
 from dissect.cstruct.types.enum import EnumMetaType
-from dissect.cstruct.types.packed import _struct
+from dissect.cstruct.util import _struct
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
     from types import MethodType
 
     from dissect.cstruct.cstruct import cstruct
-    from dissect.cstruct.types import (
-        BaseType,
-    )
+    from dissect.cstruct.types import BaseType
     from dissect.cstruct.types.structure import Field
 
 SUPPORTED_TYPES = (
@@ -60,7 +58,7 @@ python_compile = compile
 
 
 def compile(structure: type[Structure]) -> type[Structure]:
-    return Compiler(structure.cs).compile(structure)
+    return Compiler(structure.__cs__).compile(structure)
 
 
 class Compiler:
@@ -165,7 +163,7 @@ class _ReadSourceGenerator:
             field_type = field.type
 
             if isinstance(field_type, EnumMetaType):
-                field_type = field_type.type
+                field_type = field_type.__type__
 
             if not issubclass(field_type, SUPPORTED_TYPES):
                 raise TypeError(f"Unsupported type for compiler: {field_type}")
@@ -190,7 +188,7 @@ class _ReadSourceGenerator:
 
             # Array of structures and multi-dimensional arrays
             elif issubclass(field_type, (Array, CharArray, WcharArray)) and (
-                issubclass(field_type.type, Structure) or issubclass(field_type.type, BaseArray) or is_dynamic
+                issubclass(field_type.__type__, Structure) or issubclass(field_type.__type__, BaseArray) or is_dynamic
             ):
                 yield from flush()
                 yield from align_to_field(field)
@@ -224,22 +222,22 @@ class _ReadSourceGenerator:
         yield from flush()
 
         if self.align:
-            yield f"stream.seek(-stream.tell() & (cls.alignment - 1), {io.SEEK_CUR})"
+            yield f"stream.seek(-stream.tell() & (cls.__alignment__ - 1), {io.SEEK_CUR})"
 
     def _generate_structure(self, field: Field) -> Iterator[str]:
         template = f"""
-        {"_s = stream.tell()" if field.type.dynamic else ""}
+        {"_s = stream.tell()" if field.type.__dynamic__ else ""}
         r["{field._name}"] = {self._map_field(field)}._read(stream, context=r, endian=endian)
-        {f's["{field._name}"] = stream.tell() - _s' if field.type.dynamic else ""}
+        {f's["{field._name}"] = stream.tell() - _s' if field.type.__dynamic__ else ""}
         """
 
         yield dedent(template)
 
     def _generate_array(self, field: Field) -> Iterator[str]:
         template = f"""
-        {"_s = stream.tell()" if field.type.dynamic else ""}
+        {"_s = stream.tell()" if field.type.__dynamic__ else ""}
         r["{field._name}"] = {self._map_field(field)}._read(stream, context=r, endian=endian)
-        {f's["{field._name}"] = stream.tell() - _s' if field.type.dynamic else ""}
+        {f's["{field._name}"] = stream.tell() - _s' if field.type.__dynamic__ else ""}
         """
 
         yield dedent(template)
@@ -249,12 +247,12 @@ class _ReadSourceGenerator:
         read_type = "_t"
         field_type = field.type
         if issubclass(field_type, (Enum, Flag)):
-            read_type += ".type"
-            field_type = field_type.type
+            read_type += ".__type__"
+            field_type = field_type.__type__
 
         if issubclass(field_type, Char):
-            field_type = field_type.cs.uint8
-            lookup = "cls.cs.uint8"
+            field_type = field_type.__cs__.uint8
+            lookup = "cls.__cs__.uint8"
 
         template = f"""
         _t = {lookup}
@@ -279,17 +277,17 @@ class _ReadSourceGenerator:
             read_type = _get_read_type(self.cs, field_type)
 
             if issubclass(field_type, (Array, CharArray, WcharArray)):
-                count = field_type.num_entries
-                read_type = _get_read_type(self.cs, field_type.type)
+                count = field_type.__num_entries__
+                read_type = _get_read_type(self.cs, field_type.__type__)
 
                 if issubclass(read_type, (Char, Wchar, Int)):
-                    count *= read_type.size
+                    count *= read_type.__size__
                     getter = f"buf[{size}:{size + count}]"
                 else:
                     getter = f"data[{slice_index}:{slice_index + count}]"
                     slice_index += count
             elif issubclass(read_type, (Char, Wchar, Int)):
-                getter = f"buf[{size}:{size + read_type.size}]"
+                getter = f"buf[{size}:{size + read_type.__size__}]"
             else:
                 getter = f"data[{slice_index}]"
                 slice_index += 1
@@ -304,13 +302,13 @@ class _ReadSourceGenerator:
             # Create the final reading code
             if issubclass(field_type, Array):
                 reads.append(f"_t = {self._map_field(field)}")
-                reads.append("_et = _t.type")
+                reads.append("_et = _t.__type__")
 
-                if issubclass(field_type.type, Int):
+                if issubclass(field_type.__type__, Int):
                     reads.append(f"_b = {getter}")
-                    item_parser = parser_template.format(type="_et", getter=f"_b[i:i + {field_type.type.size}]")
-                    list_comp = f"[{item_parser} for i in range(0, {count}, {field_type.type.size})]"
-                elif issubclass(field_type.type, Pointer):
+                    item_parser = parser_template.format(type="_et", getter=f"_b[i:i + {field_type.__type__.__size__}]")
+                    list_comp = f"[{item_parser} for i in range(0, {count}, {field_type.__type__.__size__})]"
+                elif issubclass(field_type.__type__, Pointer):
                     item_parser = "_et.__new__(_et, e, stream, context=r, endian=endian)"
                     list_comp = f"[{item_parser} for e in {getter}]"
                 else:
@@ -329,7 +327,7 @@ class _ReadSourceGenerator:
             reads.append(f'r["{field._name}"] = {parser}')
             reads.append("")  # Generates a newline in the resulting code
 
-            size += field_type.size
+            size += field_type.__size__
 
         fmt = _optimize_struct_fmt(info)
         if fmt == "x" or (len(fmt) == 2 and fmt[1] == "x"):
@@ -372,19 +370,19 @@ def _generate_struct_info(cs: cstruct, fields: list[Field], align: bool = False)
 
         # Array of more complex types are handled elsewhere
         if issubclass(read_type, (Array, CharArray, WcharArray)):
-            count = read_type.num_entries
-            read_type = _get_read_type(cs, read_type.type)
+            count = read_type.__num_entries__
+            read_type = _get_read_type(cs, read_type.__type__)
 
         # Take the pack char for Packed
         if issubclass(read_type, Packed):
-            yield field, count, read_type.packchar
+            yield field, count, read_type.__fmt__
 
         # Other types are byte based
         # We don't actually unpack anything here but slice directly out of the buffer
         elif issubclass(read_type, (Char, Wchar, Int)):
-            yield field, count * read_type.size, "x"
+            yield field, count * read_type.__size__, "x"
 
-        size = count * read_type.size
+        size = count * read_type.__size__
         imaginary_offset += size
         if current_offset is not None:
             current_offset += size
@@ -418,7 +416,7 @@ def _optimize_struct_fmt(info: Iterator[tuple[Field, int, str]]) -> str:
 
 def _get_read_type(cs: cstruct, type_: type[BaseType]) -> type[BaseType]:
     if issubclass(type_, (Enum, Flag)):
-        type_ = type_.type
+        type_ = type_.__type__
 
     if issubclass(type_, Pointer):
         type_ = cs.pointer

dissect/cstruct/cstruct.py

@@ -206,7 +206,28 @@ class cstruct:
         if load:
             self.load(load)
 
-    def __getattr__(self, attr: str) -> Any:
+    def __getattr__(
+        self, attr: str
+    ) -> (
+        type[
+            LEB128
+            | BaseType
+            | Char
+            | Enum
+            | Flag
+            | Int
+            | Packed[int]
+            | Packed[float]
+            | Pointer
+            | Structure
+            | Union
+            | Void
+            | Wchar
+        ]
+        | int
+        | str
+        | bytes
+    ):
         try:
             return self.consts[attr]
         except KeyError:
@@ -227,7 +248,7 @@ class cstruct:
         # Update types to point to the new cstruct instance
         for name, type_ in self.types.items():
             new_type = copy.copy(type_)
-            new_type.cs = cs
+            new_type.__cs__ = cs
             cs.add_type(name, new_type, replace=True)
 
         for name, value in self.consts.items():
@@ -288,8 +309,10 @@ class cstruct:
         """
         # In cstruct 5.0 we changed the function signature of _read and _write
         # Check if the function signature is compatible, and warn if not
-        for type_to_check in (type_, type_.ArrayType):
-            type_name = type_.__name__ + (f".{type_.ArrayType.__name__}" if type_to_check is type_.ArrayType else "")
+        for type_to_check in (type_, type_.__ArrayType__):
+            type_name = type_.__name__ + (
+                f".{type_.__ArrayType__.__name__}" if type_to_check is type_.__ArrayType__ else ""
+            )
 
             for method in ("_read", "_read_array", "_read_0", "_write", "_write_array", "_write_0"):
                 if not hasattr(type_to_check, method):
@@ -481,10 +504,10 @@ class cstruct:
         attrs = attrs or {}
         attrs.update(
             {
-                "cs": self,
-                "size": size,
-                "dynamic": size is None,
-                "alignment": alignment or size,
+                "__cs__": self,
+                "__size__": size,
+                "__dynamic__": size is None,
+                "__alignment__": alignment or size,
             }
         )
         return types.new_class(name, bases, {}, lambda ns: ns.update(attrs))
@@ -494,37 +517,37 @@ class cstruct:
         if num_entries is None:
             null_terminated = True
             size = None
-        elif isinstance(num_entries, Expression) or type_.dynamic:
+        elif isinstance(num_entries, Expression) or type_.__dynamic__:
             size = None
         else:
-            if type_.size is None:
+            if type_.__size__ is None:
                 raise ValueError(f"Cannot create array of dynamic type: {type_.__name__}")
-            size = num_entries * type_.size
+            size = num_entries * type_.__size__
 
         name = f"{type_.__name__}[]" if null_terminated else f"{type_.__name__}[{num_entries}]"
 
-        bases = (type_.ArrayType,)
+        bases = (type_.__ArrayType__,)
 
         attrs = {
-            "type": type_,
-            "num_entries": num_entries,
-            "null_terminated": null_terminated,
+            "__type__": type_,
+            "__num_entries__": num_entries,
+            "__null_terminated__": null_terminated,
         }
 
-        return cast("type[Array]", self._make_type(name, bases, size, alignment=type_.alignment, attrs=attrs))
+        return cast("type[Array]", self._make_type(name, bases, size, alignment=type_.__alignment__, attrs=attrs))
 
     def _make_int_type(self, name: str, size: int, signed: bool, *, alignment: int | None = None) -> type[Int]:
         return cast("type[Int]", self._make_type(name, (Int,), size, alignment=alignment, attrs={"signed": signed}))
 
-    def _make_packed_type(self, name: str, packchar: str, base: type, *, alignment: int | None = None) -> type[Packed]:
+    def _make_packed_type(self, name: str, fmt: str, base: type, *, alignment: int | None = None) -> type[Packed]:
         return cast(
             "type[Packed]",
             self._make_type(
                 name,
                 (base, Packed),
-                struct.calcsize(packchar),
+                struct.calcsize(fmt),
                 alignment=alignment,
-                attrs={"packchar": packchar},
+                attrs={"__fmt__": fmt},
             ),
         )
 
@@ -538,9 +561,9 @@ class cstruct:
         return self._make_type(
             f"{target.__name__}*",
             (Pointer,),
-            self.pointer.size,
-            alignment=self.pointer.alignment,
-            attrs={"type": target},
+            self.pointer.__size__,
+            alignment=self.pointer.__alignment__,
+            attrs={"__type__": target},
         )
 
     def _make_struct(
@@ -557,7 +580,7 @@ class cstruct:
             (base,),
             None,
             attrs={
-                "fields": fields,
+                "__members__": fields,
                 "__align__": align,
                 "__anonymous__": anonymous,
             },
@@ -568,6 +591,15 @@ class cstruct:
     ) -> type[Structure]:
         return self._make_struct(name, fields, align=align, anonymous=anonymous, base=Union)
 
+    @property
+    def typedefs(self) -> dict[str, type[BaseType]]:
+        warnings.warn(
+            "The 'typedefs' property is deprecated, use 'types' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.types
+
     if TYPE_CHECKING:
         # ruff: noqa: PYI042
         _int = int
@@ -749,8 +781,8 @@ def ctypes_type(type_: type[BaseType]) -> Any:
         "d": _ctypes.c_double,
     }
 
-    if issubclass(type_, Packed) and type_.packchar in mapping:
-        return mapping[type_.packchar]
+    if issubclass(type_, Packed) and type_.__fmt__ in mapping:
+        return mapping[type_.__fmt__]
 
     if issubclass(type_, Char):
         return _ctypes.c_char
@@ -759,11 +791,11 @@ def ctypes_type(type_: type[BaseType]) -> Any:
         return _ctypes.c_wchar
 
     if issubclass(type_, BaseArray):
-        subtype = ctypes_type(type_.type)
-        return subtype * type_.num_entries
+        subtype = ctypes_type(type_.__type__)
+        return subtype * type_.__num_entries__
 
     if issubclass(type_, Pointer):
-        subtype = ctypes_type(type_.type)
+        subtype = ctypes_type(type_.__type__)
         return _ctypes.POINTER(subtype)
 
     if issubclass(type_, Structure):

dissect/cstruct/tools/stubgen.py

@@ -121,9 +121,9 @@ def generate_typehint(
     if issubclass(type_, types.WcharArray):
         return f"{module_prefix}WcharArray"
     if issubclass(type_, types.Pointer):
-        return f"{module_prefix}Pointer[{generate_typehint(type_.type, prefix, module_prefix)}]"
+        return f"{module_prefix}Pointer[{generate_typehint(type_.__type__, prefix, module_prefix)}]"
     if issubclass(type_, types.Array):
-        return f"{module_prefix}Array[{generate_typehint(type_.type, prefix, module_prefix)}]"
+        return f"{module_prefix}Array[{generate_typehint(type_.__type__, prefix, module_prefix)}]"
     return f"{prefix}{type_.__name__}"
 
 
@@ -159,15 +159,15 @@ def generate_structure_stub(
     indent = " " * 4
 
     args = ["self"]
-    for field_name, field in structure.fields.items():
+    for field_name, field in structure.__members__.items():
         inlined = False
 
         # If it's a structure and not globally defined, add an inline stub for it
         nested_type = field.type
         while issubclass(nested_type, types.BaseArray):
-            nested_type = nested_type.type
+            nested_type = nested_type.__type__
 
-        if issubclass(nested_type, types.Structure) and nested_type.__name__ not in structure.cs.types:
+        if issubclass(nested_type, types.Structure) and nested_type.__name__ not in structure.__cs__.types:
             inlined = True
             inline_stub = generate_structure_stub(nested_type, cs_prefix=cs_prefix, module_prefix=module_prefix)