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

dissect/cstruct/types/structure.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import io
+import warnings
 from collections import ChainMap
 from collections.abc import MutableMapping
 from contextlib import contextmanager
@@ -43,7 +44,7 @@ class Field:
         self.type = type_
         self.bits = bits
         self.offset = offset
-        self.alignment = type_.alignment or 1
+        self.alignment = type_.__alignment__ or 1
 
     def __repr__(self) -> str:
         bits_str = f" : {self.bits}" if self.bits else ""
@@ -53,11 +54,9 @@ class Field:
 class StructureMetaType(MetaType):
     """Base metaclass for cstruct structure type classes."""
 
-    # TODO: resolve field types in _update_fields, remove resolves elsewhere?
-
-    fields: dict[str, Field]
+    __members__: dict[str, Field]
     """Mapping of field names to :class:`Field` objects, including "folded" fields from anonymous structures."""
-    lookup: dict[str, Field]
+    __lookup__: dict[str, Field]
     """Mapping of "raw" field names to :class:`Field` objects. E.g. holds the anonymous struct and not its fields."""
     __fields__: list[Field]
     """List of :class:`Field` objects for this structure. This is the structures' Single Source Of Truth."""
@@ -70,7 +69,7 @@ class StructureMetaType(MetaType):
     __static_sizes__: dict[str, int]  # Cache of static sizes by field name
 
     def __new__(metacls, name: str, bases: tuple[type, ...], classdict: dict[str, Any]) -> Self:  # type: ignore
-        if (fields := classdict.pop("fields", None)) is not None:
+        if (fields := classdict.pop("__members__", None)) is not None:
             metacls._update_fields(metacls, fields, align=classdict.get("__align__", False), classdict=classdict)
 
         return super().__new__(metacls, name, bases, classdict)
@@ -96,23 +95,23 @@ class StructureMetaType(MetaType):
             if field._name in lookup and field._name != "_":
                 raise ValueError(f"Duplicate field name: {field._name}")
 
-            if not field.type.dynamic:
-                static_sizes[field._name] = field.type.size
+            if not field.type.__dynamic__:
+                static_sizes[field._name] = field.type.__size__
 
             if isinstance(field.type, StructureMetaType) and field.name is None:
-                for anon_field in field.type.fields.values():
+                for anon_field in field.type.__members__.values():
                     attr = f"{field._name}.{anon_field.name}"
                     classdict[anon_field.name] = property(attrgetter(attr), attrsetter(attr))
 
-                lookup.update(field.type.fields)
+                lookup.update(field.type.__members__)
             else:
                 lookup[field._name] = field
 
             raw_lookup[field._name] = field
 
         field_names = lookup.keys()
-        classdict["fields"] = lookup
-        classdict["lookup"] = raw_lookup
+        classdict["__members__"] = lookup
+        classdict["__lookup__"] = raw_lookup
         classdict["__fields__"] = fields
         classdict["__static_sizes__"] = static_sizes
         classdict["__bool__"] = _generate__bool__(field_names)
@@ -138,7 +137,9 @@ class StructureMetaType(MetaType):
             from dissect.cstruct import compiler
 
             try:
-                classdict["_read"] = compiler.Compiler(cls.cs).compile_read(fields, cls.__name__, align=cls.__align__)
+                classdict["_read"] = compiler.Compiler(cls.__cs__).compile_read(
+                    fields, cls.__name__, align=cls.__align__
+                )
                 classdict["__compiled__"] = True
             except Exception:
                 # Revert _read to the slower loop based method
@@ -148,17 +149,17 @@ class StructureMetaType(MetaType):
         # TODO: compile _write
         # TODO: generate cached_property for lazy reading
 
-        classdict["size"] = size
-        classdict["alignment"] = alignment
-        classdict["dynamic"] = size is None
+        classdict["__size__"] = size
+        classdict["__alignment__"] = alignment
+        classdict["__dynamic__"] = size is None
 
         return classdict
 
     def _calculate_size_and_offsets(cls, fields: list[Field], align: bool = False) -> tuple[int | None, int]:
         """Iterate all fields in this structure to calculate the field offsets and total structure size.
 
-        If a structure has a dynamic field, further field offsets will be set to None and self.dynamic
-        will be set to True.
+        If a structure has a dynamic field, further field offsets will be set to None and ``self.__dynamic__``
+        will be set to ``True``.
         """
         # The current offset, set to None if we become dynamic
         offset = 0
@@ -188,7 +189,7 @@ class StructureMetaType(MetaType):
                 field_type = field.type
 
                 if isinstance(field_type, EnumMetaType):
-                    field_type = field_type.type
+                    field_type = field_type.__type__
 
                 # Bit fields have special logic
                 if (
@@ -197,17 +198,17 @@ class StructureMetaType(MetaType):
                     # Moved to a bit field of another type, e.g. uint16 f1 : 8, uint32 f2 : 8;
                     or field_type != bits_type
                     # Still processing a bit field, but it's at a different offset due to alignment or a manual offset
-                    or (bits_type is not None and offset > bits_field_offset + bits_type.size)
+                    or (bits_type is not None and offset > bits_field_offset + bits_type.__size__)
                 ):
                     # ... if any of this is true, we have to move to the next field
                     bits_type = field_type
-                    bits_count = bits_type.size * 8
+                    bits_count = bits_type.__size__ * 8
                     bits_remaining = bits_count
                     bits_field_offset = offset
 
                     if offset is not None:
                         # We're not dynamic, update the structure size and current offset
-                        offset += bits_type.size
+                        offset += bits_type.__size__
 
                     field.offset = bits_field_offset
 
@@ -263,7 +264,7 @@ class StructureMetaType(MetaType):
 
             if field.bits:
                 if isinstance(field.type, EnumMetaType):
-                    value = field.type(bit_buffer.read(field.type.type, field.bits))
+                    value = field.type(bit_buffer.read(field.type.__type__, field.bits))
                 else:
                     value = bit_buffer.read(field.type, field.bits)
 
@@ -275,12 +276,12 @@ class StructureMetaType(MetaType):
             value = field.type._read(stream, context=result, endian=endian)
 
             result[field._name] = value
-            if field.type.dynamic:
+            if field.type.__dynamic__:
                 sizes[field._name] = stream.tell() - offset
 
         if cls.__align__:
             # Align the stream
-            stream.seek(-stream.tell() & (cls.alignment - 1), io.SEEK_CUR)
+            stream.seek(-stream.tell() & (cls.__alignment__ - 1), io.SEEK_CUR)
 
         # Using type.__call__ directly calls the __init__ method of the class
         # This is faster than calling cls() and bypasses the metaclass __call__ method
@@ -305,7 +306,7 @@ class StructureMetaType(MetaType):
             field_type = field.type
 
             bit_field_type = (
-                (field_type.type if isinstance(field_type, EnumMetaType) else field_type) if field.bits else None
+                (field_type.__type__ if isinstance(field_type, EnumMetaType) else field_type) if field.bits else None
             )
             # Current field is not a bit field, but previous was
             # Or, moved to a bit field of another type, e.g. uint16 f1 : 8, uint32 f2 : 8;
@@ -338,7 +339,7 @@ class StructureMetaType(MetaType):
 
             if field.bits:
                 if isinstance(field_type, EnumMetaType):
-                    bit_buffer.write(field_type.type, value.value, field.bits)
+                    bit_buffer.write(field_type.__type__, value.value, field.bits)
                 else:
                     bit_buffer.write(field_type, value, field.bits)
             else:
@@ -350,7 +351,7 @@ class StructureMetaType(MetaType):
 
         if cls.__align__:
             # Align the stream
-            stream.write(b"\x00" * (-stream.tell() & (cls.alignment - 1)))
+            stream.write(b"\x00" * (-stream.tell() & (cls.__alignment__ - 1)))
 
         return num
 
@@ -393,13 +394,13 @@ class StructureMetaType(MetaType):
         def _decompose(type_: MetaType) -> tuple[MetaType, int, list[int | Expression | None]]:
             dimensions = []
             while issubclass(type_, BaseArray):
-                dimensions.append(type_.num_entries)
-                type_ = type_.type
+                dimensions.append(type_.__num_entries__)
+                type_ = type_.__type__
 
             stars = 0
             while issubclass(type_, Pointer):
                 stars += 1
-                type_ = type_.type
+                type_ = type_.__type__
 
             return type_, stars, dimensions
 
@@ -413,7 +414,7 @@ class StructureMetaType(MetaType):
                         for token in dim._tokens:
                             if (
                                 token.type in IDENTIFIER_TYPES
-                                and token.value in cls.cs.consts
+                                and token.value in cls.__cs__.consts
                                 and token.value not in seen
                             ):
                                 deps.append(token.value)
@@ -464,7 +465,7 @@ class StructureMetaType(MetaType):
         blocks = []
         for type_ in deps:
             if isinstance(type_, str):
-                consts.append(f"#define {type_} {cls.cs.consts[type_]!r}")
+                consts.append(f"#define {type_} {cls.__cs__.consts[type_]!r}")
             elif isinstance(type_, EnumMetaType):
                 blocks.append(type_.cdef())
             else:
@@ -472,6 +473,26 @@ class StructureMetaType(MetaType):
 
         return ("\n".join(consts) + "\n\n" if consts else "") + ("\n\n".join(blocks) if blocks else "")
 
+    @property
+    def fields(cls) -> dict[str, Field]:
+        """List of :class:`Field` objects for this structure."""
+        warnings.warn(
+            "The 'fields' property is deprecated, use '__members__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__members__
+
+    @property
+    def lookup(cls) -> dict[str, Field]:
+        """Mapping of "raw" field names to :class:`Field` objects."""
+        warnings.warn(
+            "The 'lookup' property is deprecated, use '__lookup__' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls.__lookup__
+
 
 class Structure(BaseType, metaclass=StructureMetaType):
     """Base class for cstruct structure type classes.
@@ -493,7 +514,7 @@ class Structure(BaseType, metaclass=StructureMetaType):
 
     def __repr__(self) -> str:
         values = []
-        for name, field in self.__class__.fields.items():
+        for name, field in self.__class__.__members__.items():
             value = self[name]
             if issubclass(field.type, int) and not issubclass(field.type, (Pointer, Enum)):
                 value = hex(value)
@@ -529,13 +550,13 @@ class StructureValuesProxy(MutableMapping):
         raise KeyError(key)
 
     def __contains__(self, key: str) -> bool:
-        return key in self._struct.__class__.fields
+        return key in self._struct.__class__.__members__
 
     def __iter__(self) -> Iterator[str]:
-        return iter(self._struct.__class__.fields)
+        return iter(self._struct.__class__.__members__)
 
     def __len__(self) -> int:
-        return len(self._struct.__class__.fields)
+        return len(self._struct.__class__.__members__)
 
     def __repr__(self) -> str:
         return repr(dict(self))
@@ -555,18 +576,18 @@ class UnionMetaType(StructureMetaType):
             # 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)
+            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
-            if cls.dynamic:
+            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__, strict=False))
-            kwarg_fields = (name for name in kwargs if name in cls.lookup)
+            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:
@@ -605,12 +626,12 @@ class UnionMetaType(StructureMetaType):
         result = {}
         sizes = {}
 
-        if cls.size is None:
+        if cls.__size__ is None:
             offset = stream.tell()
             buf = stream
         else:
             offset = 0
-            buf = io.BytesIO(stream.read(cls.size))
+            buf = io.BytesIO(stream.read(cls.__size__))
 
         for field in cls.__fields__:
             field_type = field.type
@@ -623,13 +644,13 @@ class UnionMetaType(StructureMetaType):
             value = field_type._read(buf, context=result, endian=endian)
 
             result[field._name] = value
-            if field.type.dynamic:
+            if field.type.__dynamic__:
                 sizes[field._name] = buf.tell() - start
 
         return result, sizes
 
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:  # type: ignore
-        if cls.size is None:
+        if cls.__size__ is None:
             start = stream.tell()
             result, sizes = cls._read_fields(stream, context=context, endian=endian)
             size = stream.tell() - start
@@ -638,7 +659,7 @@ class UnionMetaType(StructureMetaType):
         else:
             result = {}
             sizes = {}
-            buf = stream.read(cls.size)
+            buf = stream.read(cls.__size__)
 
         # Create the object and set the values
         # Using type.__call__ directly calls the __init__ method of the class
@@ -650,7 +671,7 @@ class UnionMetaType(StructureMetaType):
         object.__setattr__(obj, "_buf", buf)
         object.__setattr__(obj, "_endian", endian)
 
-        if cls.size is not None:
+        if cls.__size__ is not None:
             obj._update()
 
         # Proxify any nested structures
@@ -659,14 +680,14 @@ class UnionMetaType(StructureMetaType):
         return obj
 
     def _write(cls, stream: BinaryIO, data: Union, *, endian: Endianness) -> int:
-        if cls.dynamic:
+        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: e.type.size or 0, 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
@@ -701,7 +722,7 @@ class Union(Structure, metaclass=UnionMetaType):
         return self.__class__ is other.__class__ and bytes(self) == bytes(other)
 
     def __setattr__(self, attr: str, value: Any) -> None:
-        if self.__class__.dynamic:
+        if self.__class__.__dynamic__:
             raise NotImplementedError("Modifying a dynamic union is not yet supported")
 
         super().__setattr__(attr, value)
@@ -709,10 +730,10 @@ class Union(Structure, metaclass=UnionMetaType):
 
     def _rebuild(self, attr: str) -> None:
         if (cur_buf := getattr(self, "_buf", None)) is None:
-            cur_buf = b"\x00" * self.__class__.size
+            cur_buf = b"\x00" * self.__class__.__size__
 
         buf = io.BytesIO(cur_buf)
-        field = self.__class__.lookup[attr]
+        field = self.__class__.__lookup__[attr]
         if field.offset:
             buf.seek(field.offset)
 

dissect/cstruct/types/void.py

@@ -29,7 +29,7 @@ class VoidArray(list, BaseArray):
 class Void(BaseType):
     """Void type."""
 
-    ArrayType = VoidArray
+    __ArrayType__ = VoidArray
 
     def __bool__(self) -> bool:
         return False

dissect/cstruct/types/wchar.py

@@ -17,7 +17,7 @@ class WcharArray(str, BaseArray):
 
     @classmethod
     def __default__(cls) -> WcharArray:
-        return type.__call__(cls, "\x00" * (0 if cls.dynamic or cls.null_terminated else cls.num_entries))
+        return type.__call__(cls, "\x00" * (0 if cls.__dynamic__ or cls.__null_terminated__ else cls.__num_entries__))
 
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> WcharArray:
@@ -25,12 +25,12 @@ class WcharArray(str, BaseArray):
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: str, *, endian: Endianness) -> int:
-        if cls.null_terminated:
+        if cls.__null_terminated__:
             data += "\x00"
 
-        if not cls.dynamic and (remaining := cls.num_entries - (actual_size := len(data))):
+        if not cls.__dynamic__ and (remaining := cls.__num_entries__ - (actual_size := len(data))):
             if remaining < 0:
-                raise ArraySizeError(f"Expected static array size {cls.num_entries}, got {actual_size} instead.")
+                raise ArraySizeError(f"Expected static array size {cls.__num_entries__}, got {actual_size} instead.")
             data += "\x00" * remaining
 
         return stream.write(data.encode(Wchar.__encoding_map__[endian]))
@@ -39,7 +39,7 @@ class WcharArray(str, BaseArray):
 class Wchar(str, BaseType):
     """Wide-character type for reading and writing UTF-16 characters."""
 
-    ArrayType = WcharArray
+    __ArrayType__ = WcharArray
 
     __slots__ = ()
     __encoding_map__: ClassVar[dict[Endianness, str]] = {

dissect/cstruct/util.py

@@ -3,15 +3,17 @@ from __future__ import annotations
 import os
 import pprint
 import string
+import struct
 import sys
 from enum import Enum
-from typing import TYPE_CHECKING
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
     from typing import Literal
 
-    from dissect.cstruct.cstruct import AllowedEndianness
+    from dissect.cstruct.cstruct import AllowedEndianness, Endianness
     from dissect.cstruct.types.base import BaseType
     from dissect.cstruct.types.structure import Structure
 
@@ -64,6 +66,36 @@ ENDIANNESS_TO_BYTEORDER_MAP: dict[AllowedEndianness, Literal["big", "little"]] =
     "big": "big",
 }
 
+ENDIANNESS_MAP: dict[AllowedEndianness, Endianness] = {
+    "<": "<",
+    ">": ">",
+    "!": "!",
+    "@": "@",
+    "=": "=",
+    "network": "!",
+    "little": "<",
+    "big": ">",
+}
+
+
+def normalize_endianness(endian: AllowedEndianness) -> Endianness:
+    """Normalize an endianness string to one of the standard format characters."""
+    try:
+        return ENDIANNESS_MAP[endian]
+    except KeyError:
+        raise ValueError(
+            f"Invalid endianness: {endian!r}, expected one of {', '.join(ENDIANNESS_MAP.keys())}"
+        ) from None
+
+
+class classproperty:
+    def __init__(self, fget: classmethod) -> None:
+        self.fget = fget
+
+    def __get__(self, obj: object | None, owner: type) -> Any:
+        return self.fget(owner)
+
+
 Palette = list[tuple[int, str]]
 
 
@@ -327,6 +359,11 @@ def dumpstruct(
     return _dumpstruct(obj, obj.dumps(), offset, color, output, autoskip)
 
 
+@lru_cache(1024)
+def _struct(endian: str, fmt: str) -> struct.Struct:
+    return struct.Struct(f"{endian}{fmt}")
+
+
 def pack(value: int, size: int | None = None, endian: AllowedEndianness = "little") -> bytes:
     """Pack an integer value to a given bit size, endianness.
 
@@ -400,6 +437,36 @@ def p64(value: int, endian: AllowedEndianness = "little") -> bytes:
     return pack(value, 64, endian)
 
 
+def pf16(value: float, endian: AllowedEndianness = "little") -> bytes:
+    """Pack a 16 bit float.
+
+    Arguments:
+        value: Value to pack.
+        endian: Endianness to use (little, big, network, <, >, !, @ or =).
+    """
+    return _struct(normalize_endianness(endian), "e").pack(value)
+
+
+def pf32(value: float, endian: AllowedEndianness = "little") -> bytes:
+    """Pack a 32 bit float.
+
+    Arguments:
+        value: Value to pack.
+        endian: Endianness to use (little, big, network, <, >, !, @ or =).
+    """
+    return _struct(normalize_endianness(endian), "f").pack(value)
+
+
+def pf64(value: float, endian: AllowedEndianness = "little") -> bytes:
+    """Pack a 64 bit float.
+
+    Arguments:
+        value: Value to pack.
+        endian: Endianness to use (little, big, network, <, >, !, @ or =).
+    """
+    return _struct(normalize_endianness(endian), "d").pack(value)
+
+
 def u8(value: bytes, endian: AllowedEndianness = "little", sign: bool = False) -> int:
     """Unpack an 8 bit integer.
 
@@ -444,6 +511,36 @@ def u64(value: bytes, endian: AllowedEndianness = "little", sign: bool = False)
     return unpack(value, 64, endian, sign)
 
 
+def f16(value: bytes, endian: AllowedEndianness = "little") -> float:
+    """Unpack a 16 bit float.
+
+    Arguments:
+        value: Value to unpack.
+        endian: Endianness to use (little, big, network, <, >, !, @ or =).
+    """
+    return _struct(normalize_endianness(endian), "e").unpack(value)[0]
+
+
+def f32(value: bytes, endian: AllowedEndianness = "little") -> float:
+    """Unpack a 32 bit float.
+
+    Arguments:
+        value: Value to unpack.
+        endian: Endianness to use (little, big, network, <, >, !, @ or =).
+    """
+    return _struct(normalize_endianness(endian), "f").unpack(value)[0]
+
+
+def f64(value: bytes, endian: AllowedEndianness = "little") -> float:
+    """Unpack a 64 bit float.
+
+    Arguments:
+        value: Value to unpack.
+        endian: Endianness to use (little, big, network, <, >, !, @ or =).
+    """
+    return _struct(normalize_endianness(endian), "d").unpack(value)[0]
+
+
 def swap(value: int, size: int) -> int:
     """Swap the endianness of an integer with a given bit size.
 
@@ -488,7 +585,7 @@ def sizeof(type_: type[BaseType] | BaseType) -> int:
 
 def offsetof(type_: type[Structure], name: str) -> int:
     """Get the offset of a field in a structure."""
-    if (field := type_.fields.get(name)) is None:
+    if (field := type_.__members__.get(name)) is None:
         raise ValueError(f"Structure '{type_.__name__}' does not have a field named '{name}'")
     if (offset := field.offset) is None:
         raise ValueError(f"Field '{field._name}' of structure '{type_.__name__}' does not have a known offset")

{dissect_cstruct-5.0.dev7.dist-info → dissect_cstruct-5.0.dev9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 5.0.dev7
+Version: 5.0.dev9
 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-Expression: Apache-2.0

dissect_cstruct-5.0.dev9.dist-info/RECORD

@@ -0,0 +1,30 @@
+dissect/cstruct/__init__.py,sha256=KOyNeUvu4c0JaAiyOfj7iftGwUIjTmD8MwHtFsLPLSU,1504
+dissect/cstruct/bitbuffer.py,sha256=aNzY4lkWe8ffAc8j7FODXzwZc8gZwbey77UosyoYCsw,2711
+dissect/cstruct/compiler.py,sha256=zcrO5CWCF2vWo2es-pFGn-Mvt-RTMh8W9bntK-hn85k,14343
+dissect/cstruct/cstruct.py,sha256=wC4Xd8MBxTCyl-IC1I2c3etI8M6C6D5yXVfELbfQk6c,25656
+dissect/cstruct/exception.py,sha256=RqD08LuBkbMqa3iQ1A05DNN8XgEmQR_SUnguwe9LGo8,316
+dissect/cstruct/expression.py,sha256=MEwqHGgqA2fUk4kYk4lRLDWNTAMhB4-saJ5BgTxl7OA,7956
+dissect/cstruct/lexer.py,sha256=NDUfAWgyxgRNRuVO8ExXQ51LqQXS2mv9bywVa_M7tFQ,19665
+dissect/cstruct/parser.py,sha256=xCK-1O8c86sVFvjaXXSRgTsJWWd0ncKM6KJf2wbyGG8,21348
+dissect/cstruct/util.py,sha256=vAf-kdOkk3zprW_gD6QmQeN3VIRgQqhPS4B_ha1jEpQ,18040
+dissect/cstruct/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dissect/cstruct/tools/stubgen.py,sha256=MeZkLmSeNSLNcAEwlAdIGv1lKvlvK3UQ4WN85ovsxTM,7672
+dissect/cstruct/types/__init__.py,sha256=6P71Pu94Dv7RNjZpDZ19pqzx-G0QzmQw4q0-3zWALso,911
+dissect/cstruct/types/base.py,sha256=vJUgrnsPg2ZA9Mel2P9JBBstI9z9oMxqi5Pnx9FlBIA,15023
+dissect/cstruct/types/char.py,sha256=zsRMlcZGW1cHYH_xQBNORDnM_a5CXcuZLGly1N1i_Ms,3029
+dissect/cstruct/types/enum.py,sha256=j2U6oE_80c4H2505YMddHPnF99az2K5IuDhX40Q7OEI,8590
+dissect/cstruct/types/flag.py,sha256=7xxQjFEDPHSQOxBHgcc75WzPiAxflOquwr7Z7c3erLE,2347
+dissect/cstruct/types/int.py,sha256=RCT3YjrajqRqh8cyeM-zaqzCmBfeJrXkD5W1FcRzXag,1340
+dissect/cstruct/types/leb128.py,sha256=V97XTJT_Xbw1LpTwTN1OkjPHuQQAQUxd8OGuA6yEDmE,2387
+dissect/cstruct/types/packed.py,sha256=QF1mAqgxLbgiibRZLhn6cp6SnuH2IxjGr9DsQdXCCSE,2713
+dissect/cstruct/types/pointer.py,sha256=FNuB9bfENWRebbKX-R6Vs6xWPMHepjvOhhomeUhr7I8,3985
+dissect/cstruct/types/structure.py,sha256=QZBVCCERu9eoXLqrumF7Kqy0gudywl12-cSZx6n3tPI,38402
+dissect/cstruct/types/void.py,sha256=fV4hKk50uop_EKbR1nfy1cdtAzvUYrSymXsdakCyFk8,1222
+dissect/cstruct/types/wchar.py,sha256=X-dRu6ujjQIIsBfzKbujwMO5skKdARtptF6P7R5v8Jo,3232
+dissect_cstruct-5.0.dev9.dist-info/licenses/COPYRIGHT,sha256=H-18RXfshdH9AdHwW2eO1Xa-5s6tY5eipHh5c0whDu4,316
+dissect_cstruct-5.0.dev9.dist-info/licenses/LICENSE,sha256=PhUqiw6jAh2KbBdVRPBq_hfAvfcTBin7nZ3CK7NQbTM,11341
+dissect_cstruct-5.0.dev9.dist-info/METADATA,sha256=1TPbiY0D5dnQscZ0QDgEJvsSjlguJxBNXgqM3_Xf0V4,9255
+dissect_cstruct-5.0.dev9.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+dissect_cstruct-5.0.dev9.dist-info/entry_points.txt,sha256=z53zqZqwD2OLrAkRwrP4wTeiU9CQe7xrMly0T2c0_wQ,71
+dissect_cstruct-5.0.dev9.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
+dissect_cstruct-5.0.dev9.dist-info/RECORD,,

dissect_cstruct-5.0.dev7.dist-info/RECORD

@@ -1,32 +0,0 @@
-dissect/cstruct/__init__.py,sha256=8VNVQfPH4aH5V_kD-jvtLPwQ-ag9ppKHTy3dbxIR6ik,1378
-dissect/cstruct/bitbuffer.py,sha256=lZuLUOluHx4mzFGRp62_FO45_iJwXayyzv9-v8b0Q08,2687
-dissect/cstruct/compiler.py,sha256=vVg2H-pi9ugQ8Xvhs1JQ--4BjA5gtO2tW-1W8jr36V4,14283
-dissect/cstruct/cstruct.py,sha256=bsCesSpbE0H4MUsHwb2iEbeadOBlOSAVENwyoP-UkP8,24929
-dissect/cstruct/exception.py,sha256=RqD08LuBkbMqa3iQ1A05DNN8XgEmQR_SUnguwe9LGo8,316
-dissect/cstruct/expression.py,sha256=MEwqHGgqA2fUk4kYk4lRLDWNTAMhB4-saJ5BgTxl7OA,7956
-dissect/cstruct/lexer.py,sha256=NDUfAWgyxgRNRuVO8ExXQ51LqQXS2mv9bywVa_M7tFQ,19665
-dissect/cstruct/parser.py,sha256=xCK-1O8c86sVFvjaXXSRgTsJWWd0ncKM6KJf2wbyGG8,21348
-dissect/cstruct/util.py,sha256=S__kLEb9HKZg_WZR4CGtXDxkIkERLKbzFTHoU8FT8tU,15313
-dissect/cstruct/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dissect/cstruct/tools/stubgen.py,sha256=FLQieYE-MeKK31DcrDzwNUropUYHPjwdfcDb1X2L6j4,7651
-dissect/cstruct/types/__init__.py,sha256=6P71Pu94Dv7RNjZpDZ19pqzx-G0QzmQw4q0-3zWALso,911
-dissect/cstruct/types/base.py,sha256=rU1S2FQllx7X7BQG7qMOwNa7waxAJyuTHTNwtkiAz0g,12763
-dissect/cstruct/types/char.py,sha256=s4zDmnbuOjwHgcsnEihjSqgC6H3t1jsfBTYH2ykwvHU,2997
-dissect/cstruct/types/enum.py,sha256=YIWyP3H0tdxmuSI82enoULiN0YevpnU0UaY5ioBCYfI,8518
-dissect/cstruct/types/flag.py,sha256=7xxQjFEDPHSQOxBHgcc75WzPiAxflOquwr7Z7c3erLE,2347
-dissect/cstruct/types/int.py,sha256=Ewejng5pBYnQHPtzL5W0wQMJVUPYyrY8ALES8mFaabI,1324
-dissect/cstruct/types/leb128.py,sha256=V97XTJT_Xbw1LpTwTN1OkjPHuQQAQUxd8OGuA6yEDmE,2387
-dissect/cstruct/types/packed.py,sha256=78nQWm-yylgfK3858nN-XZhO5jiqyO-piGNEyPD2ps4,2458
-dissect/cstruct/types/pointer.py,sha256=eGMrB_tTnKXKmYrcqyA_12IdukXcxRG3WOeQ1dgt7lk,3927
-dissect/cstruct/types/structure.py,sha256=7pBg0moZbszeRomFEp5CbAHZcd1J8IVTmEG9Mo2eKS0,37571
-dissect/cstruct/types/void.py,sha256=LCYnTcxsFPaxln36QEUxWuCZVioHRRckMuqtlm6tH54,1218
-dissect/cstruct/types/wchar.py,sha256=YCYlu91D9AMVpWOLbVMdpvDDURH-EqyppM5UMDU5UQw,3200
-dissect_cstruct-5.0.dev7.dist-info/licenses/COPYRIGHT,sha256=H-18RXfshdH9AdHwW2eO1Xa-5s6tY5eipHh5c0whDu4,316
-dissect_cstruct-5.0.dev7.dist-info/licenses/LICENSE,sha256=PhUqiw6jAh2KbBdVRPBq_hfAvfcTBin7nZ3CK7NQbTM,11341
-dissect_cstruct-5.0.dev7.dist-info/METADATA,sha256=IUF-_jFf7_GABYqAww23JWUTr-f73OKwmaICtDcOGc8,9255
-dissect_cstruct-5.0.dev7.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-dissect_cstruct-5.0.dev7.dist-info/entry_points.txt,sha256=z53zqZqwD2OLrAkRwrP4wTeiU9CQe7xrMly0T2c0_wQ,71
-dissect_cstruct-5.0.dev7.dist-info/scm_file_list.json,sha256=nuFWhDGL6VmjcwOB94CSfjNBblnsa9imUy8X4BLyvhw,2306
-dissect_cstruct-5.0.dev7.dist-info/scm_version.json,sha256=wMGNV4ui6dgAUOW0hK23797wTuOlVvhVvvLFz_dXXFk,162
-dissect_cstruct-5.0.dev7.dist-info/top_level.txt,sha256=Mn-CQzEYsAbkxrUI0TnplHuXnGVKzxpDw_po_sXpvv4,8
-dissect_cstruct-5.0.dev7.dist-info/RECORD,,