dissect.cstruct 4.5.dev4__tar.gz → 4.6.dev1__tar.gz

dissect_cstruct-4.6.dev1/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased]
+
+### Changed
+
+- Optimize storage of field sizes.
+- Rename `_sizes` property of `Structure` to `__sizes__`.
+- Rename `_values` property of `Structure` to `__values__`.
+
+## [4.5] - 20-05-2025
+
+### Added 
+
+- Introduce experimental tool `cstruct-stubgen` to generate type stubs for cstruct definitions.
+
+### Fixed
+
+- Generated classes are now hashable.
+- Suppress spurious `TypeError: Dynamic size` errors when using cstruct interactively.
+
+## [4.4] - 03-10-2025
+
+### Fixed
+
+- Resolve documentation warnings.
+
+### Changed
+
+- Use the Ruff linter.
+
+## [4.3] - 11-18-2024
+
+### Fixed
+
+- All cstruct types are now correctly default-initialized using the `__default__` member.
+
+## [4.2] - 10-10-2024
+
+### Fixed
+
+- The string representation of enums now outputs the name of the constants. 
+
+## [4.1] - 10-09-2024
+
+### Fixed
+
+- Declaring an array of a nested struct type now works as intended.
+

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.5.dev4
+Version: 4.6.dev1
 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
 Project-URL: homepage, https://dissect.tools
 Project-URL: documentation, https://docs.dissect.tools/en/latest/projects/dissect.cstruct
 Project-URL: repository, https://github.com/fox-it/dissect.cstruct
+Project-URL: changelog, https://github.com/fox-it/dissect.cstruct/blob/main/CHANGELOG.md
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/compiler.py

@@ -21,6 +21,7 @@ from dissect.cstruct.types import (
     Structure,
     Union,
     Void,
+    VoidArray,
     Wchar,
     WcharArray,
 )
@@ -48,6 +49,7 @@ SUPPORTED_TYPES = (
     Void,
     Wchar,
     WcharArray,
+    VoidArray,
 )
 
 log = logging.getLogger(__name__)
@@ -121,8 +123,7 @@ class _ReadSourceGenerator:
 
         outro = """
         obj = type.__call__(cls, **r)
-        obj._sizes = s
-        obj._values = r
+        obj.__dynamic_sizes__ = s
 
         return obj
         """
@@ -225,18 +226,18 @@ class _ReadSourceGenerator:
 
     def _generate_structure(self, field: Field) -> Iterator[str]:
         template = f"""
-        _s = stream.tell()
+        {'_s = stream.tell()' if field.type.dynamic else ''}
         r["{field._name}"] = {self._map_field(field)}._read(stream, context=r)
-        s["{field._name}"] = stream.tell() - _s
+        {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()
+        {'_s = stream.tell()' if field.type.dynamic else ''}
         r["{field._name}"] = {self._map_field(field)}._read(stream, context=r)
-        s["{field._name}"] = stream.tell() - _s
+        {f's["{field._name}"] = stream.tell() - _s' if field.type.dynamic else ''}
         """
 
         yield dedent(template)
@@ -324,7 +325,6 @@ class _ReadSourceGenerator:
                 parser = parser_template.format(type=self._map_field(field), getter=getter)
 
             reads.append(f'r["{field._name}"] = {parser}')
-            reads.append(f's["{field._name}"] = {field_type.size}')
             reads.append("")  # Generates a newline in the resulting code
 
             size += field_type.size
@@ -365,7 +365,7 @@ def _generate_struct_info(cs: cstruct, fields: list[Field], align: bool = False)
         read_type = _get_read_type(cs, field.type)
 
         # Drop voids
-        if issubclass(read_type, Void):
+        if issubclass(read_type, (Void, VoidArray)):
             continue
 
         # Array of more complex types are handled elsewhere

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/expression.py

@@ -187,8 +187,7 @@ class Expression:
         "sizeof": 6,
     }
 
-    def __init__(self, cstruct: cstruct, expression: str):
-        self.cstruct = cstruct
+    def __init__(self, expression: str):
         self.expression = expression
         self.tokens = ExpressionTokenizer(expression).tokenize()
         self.stack = []
@@ -222,7 +221,7 @@ class Expression:
     def is_number(self, token: str) -> bool:
         return token.isnumeric() or (len(token) > 2 and token[0] == "0" and token[1] in ("x", "X", "b", "B", "o", "O"))
 
-    def evaluate(self, context: dict[str, int] | None = None) -> int:
+    def evaluate(self, cs: cstruct, context: dict[str, int] | None = None) -> int:
         """Evaluates an expression using a Shunting-Yard implementation."""
 
         self.stack = []
@@ -249,14 +248,14 @@ class Expression:
                 self.queue.append(int(current_token, 0))
             elif current_token in context:
                 self.queue.append(int(context[current_token]))
-            elif current_token in self.cstruct.consts:
-                self.queue.append(int(self.cstruct.consts[current_token]))
+            elif current_token in cs.consts:
+                self.queue.append(int(cs.consts[current_token]))
             elif current_token in self.unary_operators:
                 self.stack.append(current_token)
             elif current_token == "sizeof":
                 if len(tmp_expression) < i + 3 or (tmp_expression[i + 1] != "(" or tmp_expression[i + 3] != ")"):
                     raise ExpressionParserError("Invalid sizeof operation")
-                self.queue.append(len(self.cstruct.resolve(tmp_expression[i + 2])))
+                self.queue.append(len(cs.resolve(tmp_expression[i + 2])))
                 i += 3
             elif current_token in operators:
                 while (

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/parser.py

@@ -92,7 +92,7 @@ class TokenParser(Parser):
 
         if isinstance(value, str):
             try:
-                value = Expression(self.cstruct, value).evaluate()
+                value = Expression(value).evaluate(self.cstruct)
             except (ExpressionParserError, ExpressionTokenizerError):
                 pass
 
@@ -120,7 +120,7 @@ class TokenParser(Parser):
                 if not key:
                     continue
 
-                val = nextval if not val else Expression(self.cstruct, val).evaluate(values)
+                val = nextval if not val else Expression(val).evaluate(self.cstruct, values)
 
                 if enumtype == "flag":
                     high_bit = val.bit_length() - 1
@@ -293,9 +293,9 @@ class TokenParser(Parser):
                 if count == "":
                     count = None
                 else:
-                    count = Expression(self.cstruct, count)
+                    count = Expression(count)
                     try:
-                        count = count.evaluate()
+                        count = count.evaluate(self.cstruct)
                     except Exception:
                         pass
 
@@ -434,7 +434,7 @@ class CStyleParser(Parser):
                     if not key:
                         continue
 
-                    val = nextval if not val else Expression(self.cstruct, val).evaluate()
+                    val = nextval if not val else Expression(val).evaluate(self.cstruct)
 
                     if enumtype == "flag":
                         high_bit = val.bit_length() - 1
@@ -515,9 +515,9 @@ class CStyleParser(Parser):
                 if d["count"] == "":
                     count = None
                 else:
-                    count = Expression(self.cstruct, d["count"])
+                    count = Expression(d["count"])
                     try:
-                        count = count.evaluate()
+                        count = count.evaluate(self.cstruct)
                     except Exception:
                         pass
 

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/types/__init__.py

@@ -7,7 +7,7 @@ from dissect.cstruct.types.leb128 import LEB128
 from dissect.cstruct.types.packed import Packed
 from dissect.cstruct.types.pointer import Pointer
 from dissect.cstruct.types.structure import Field, Structure, Union
-from dissect.cstruct.types.void import Void
+from dissect.cstruct.types.void import Void, VoidArray
 from dissect.cstruct.types.wchar import Wchar, WcharArray
 
 __all__ = [
@@ -27,6 +27,7 @@ __all__ = [
     "Structure",
     "Union",
     "Void",
+    "VoidArray",
     "Wchar",
     "WcharArray",
 ]

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/types/base.py

@@ -54,6 +54,10 @@ class MetaType(type):
         """Create a new array with the given number of entries."""
         return cls.cs._make_array(cls, num_entries)
 
+    def __bool__(cls) -> bool:
+        """Type class is always truthy."""
+        return True
+
     def __len__(cls) -> int:
         """Return the byte size of the type."""
         # Python 3.9 compat thing for bound type vars
@@ -258,7 +262,7 @@ class BaseArray(BaseType):
             num = EOF
         elif isinstance(cls.num_entries, Expression):
             try:
-                num = max(0, cls.num_entries.evaluate(context))
+                num = max(0, cls.num_entries.evaluate(cls.cs, context))
             except Exception:
                 if cls.num_entries.expression != "EOF":
                     raise

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/types/structure.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import io
+from collections import ChainMap
+from collections.abc import MutableMapping
 from contextlib import contextmanager
 from enum import Enum
 from functools import lru_cache
@@ -21,7 +23,7 @@ from dissect.cstruct.types.enum import EnumMetaType
 from dissect.cstruct.types.pointer import Pointer
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Mapping
     from types import FunctionType
 
     from typing_extensions import Self
@@ -60,6 +62,7 @@ class StructureMetaType(MetaType):
     __anonymous__: bool
     __updating__ = False
     __compiled__ = False
+    __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:
@@ -79,8 +82,7 @@ class StructureMetaType(MetaType):
             return type.__call__(cls, *args, **kwargs)
         if not args and not kwargs:
             obj = type.__call__(cls)
-            object.__setattr__(obj, "_values", {})
-            object.__setattr__(obj, "_sizes", {})
+            object.__setattr__(obj, "__dynamic_sizes__", {})
             return obj
 
         return super().__call__(*args, **kwargs)
@@ -93,10 +95,14 @@ class StructureMetaType(MetaType):
         lookup = {}
         raw_lookup = {}
         field_names = []
+        static_sizes = {}
         for field in fields:
             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 isinstance(field.type, StructureMetaType) and field.name is None:
                 for anon_field in field.type.fields.values():
                     attr = f"{field._name}.{anon_field.name}"
@@ -112,6 +118,7 @@ class StructureMetaType(MetaType):
         classdict["fields"] = lookup
         classdict["lookup"] = raw_lookup
         classdict["__fields__"] = fields
+        classdict["__static_sizes__"] = static_sizes
         classdict["__bool__"] = _generate__bool__(field_names)
 
         if issubclass(cls, UnionMetaType) or isinstance(cls, UnionMetaType):
@@ -271,8 +278,9 @@ class StructureMetaType(MetaType):
 
             value = field.type._read(stream, result)
 
-            sizes[field._name] = stream.tell() - offset
             result[field._name] = value
+            if field.type.dynamic:
+                sizes[field._name] = stream.tell() - offset
 
         if cls.__align__:
             # Align the stream
@@ -281,8 +289,7 @@ class StructureMetaType(MetaType):
         # 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
+        obj.__dynamic_sizes__ = sizes
         return obj
 
     def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:  # type: ignore
@@ -375,10 +382,13 @@ class StructureMetaType(MetaType):
 
 
 class Structure(BaseType, metaclass=StructureMetaType):
-    """Base class for cstruct structure type classes."""
+    """Base class for cstruct structure type classes.
+
+    Note that setting attributes which do not correspond to a field in the structure results in undefined behavior.
+    For performance reasons, the structure does not check if the field exists when writing to an attribute.
+    """
 
-    _values: dict[str, Any]
-    _sizes: dict[str, int]
+    __dynamic_sizes__: dict[str, int]
 
     def __len__(self) -> int:
         return len(self.dumps())
@@ -401,6 +411,47 @@ class Structure(BaseType, metaclass=StructureMetaType):
 
         return f"<{self.__class__.__name__} {' '.join(values)}>"
 
+    @property
+    def __values__(self) -> MutableMapping[str, Any]:
+        return StructureValuesProxy(self)
+
+    @property
+    def __sizes__(self) -> Mapping[str, int | None]:
+        return ChainMap(self.__class__.__static_sizes__, self.__dynamic_sizes__)
+
+
+class StructureValuesProxy(MutableMapping):
+    """A proxy for the values of fields of a Structure."""
+
+    def __init__(self, struct: Structure):
+        self._struct: Structure = struct
+
+    def __getitem__(self, key: str) -> Any:
+        if key in self:
+            return getattr(self._struct, key)
+        raise KeyError(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        if key in self:
+            return setattr(self._struct, key, value)
+        raise KeyError(key)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._struct.__class__.fields
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._struct.__class__.fields)
+
+    def __len__(self) -> int:
+        return len(self._struct.__class__.fields)
+
+    def __repr__(self) -> str:
+        return repr(dict(self))
+
+    def __delitem__(self, _: str):
+        # Is abstract in base, but deleting is not supported.
+        raise NotImplementedError("Cannot delete fields from a Structure")
+
 
 class UnionMetaType(StructureMetaType):
     """Base metaclass for cstruct union type classes."""
@@ -473,8 +524,9 @@ class UnionMetaType(StructureMetaType):
             buf.seek(offset + start)
             value = field_type._read(buf, result)
 
-            sizes[field._name] = buf.tell() - start
             result[field._name] = value
+            if field.type.dynamic:
+                sizes[field._name] = buf.tell() - start
 
         return result, sizes
 
@@ -496,8 +548,7 @@ class UnionMetaType(StructureMetaType):
         # 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, "__dynamic_sizes__", sizes)
         object.__setattr__(obj, "_buf", buf)
 
         if cls.size is not None:
@@ -579,8 +630,7 @@ class Union(Structure, metaclass=UnionMetaType):
     def _update(self) -> None:
         result, sizes = self.__class__._read_fields(io.BytesIO(self._buf))
         self.__dict__.update(result)
-        object.__setattr__(self, "_values", result)
-        object.__setattr__(self, "_sizes", sizes)
+        object.__setattr__(self, "__dynamic_sizes__", sizes)
 
     def _proxify(self) -> None:
         def _proxy_structure(value: Structure) -> None:

dissect_cstruct-4.6.dev1/dissect/cstruct/types/void.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, BinaryIO
+
+from dissect.cstruct.types.base import BaseArray, BaseType
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+
+class VoidArray(list, BaseArray):
+    """Array type representing void elements, primarily used for no-op reading and writing operations."""
+
+    @classmethod
+    def __default__(cls) -> Self:
+        return cls()
+
+    @classmethod
+    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+        return cls()
+
+    @classmethod
+    def _write(cls, stream: BinaryIO, data: bytes) -> int:
+        return 0
+
+
+class Void(BaseType):
+    """Void type."""
+
+    ArrayType = VoidArray
+
+    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 = None) -> Self:
+        return cls.__new__(cls)
+
+    @classmethod
+    def _write(cls, stream: BinaryIO, data: Void) -> int:
+        return 0

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect/cstruct/utils.py

@@ -157,11 +157,6 @@ def _dumpstruct(
         if getattr(field.type, "anonymous", False):
             continue
 
-        if color:
-            foreground, background = colors[ci % len(colors)]
-            palette.append((structure._sizes[field._name], background))
-        ci += 1
-
         value = getattr(structure, field._name)
         if isinstance(value, (str, Pointer, Enum)):
             value = repr(value)
@@ -173,6 +168,10 @@ def _dumpstruct(
                 value = value.replace("\n", f"\n{' ' * (len(field._name) + 4)}")
 
         if color:
+            foreground, background = colors[ci % len(colors)]
+            size = structure.__sizes__[field._name]
+            palette.append((size, background))
+            ci += 1
             out.append(f"- {foreground}{field._name}{COLOR_NORMAL}: {value}")
         else:
             out.append(f"- {field._name}: {value}")

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect.cstruct.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: dissect.cstruct
-Version: 4.5.dev4
+Version: 4.6.dev1
 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
 Project-URL: homepage, https://dissect.tools
 Project-URL: documentation, https://docs.dissect.tools/en/latest/projects/dissect.cstruct
 Project-URL: repository, https://github.com/fox-it/dissect.cstruct
+Project-URL: changelog, https://github.com/fox-it/dissect.cstruct/blob/main/CHANGELOG.md
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/dissect.cstruct.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 .git-blame-ignore-revs
 .gitattributes
+CHANGELOG.md
 COPYRIGHT
 LICENSE
 MANIFEST.in

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/pyproject.toml

@@ -30,6 +30,7 @@ dynamic = ["version"]
 homepage = "https://dissect.tools"
 documentation = "https://docs.dissect.tools/en/latest/projects/dissect.cstruct"
 repository = "https://github.com/fox-it/dissect.cstruct"
+changelog = "https://github.com/fox-it/dissect.cstruct/blob/main/CHANGELOG.md"
 
 [project.optional-dependencies]
 dev = [

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/tests/test_align.py

@@ -45,7 +45,7 @@ def test_align_struct(cs: cstruct, compiled: bool) -> None:
     obj = cs.test(fh)
     assert fh.tell() == 32
 
-    for name, value in obj._values.items():
+    for name, value in obj.__values__.items():
         assert cs.test.fields[name].offset == value
 
     assert obj.dumps() == buf

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/tests/test_compiler.py

@@ -8,6 +8,7 @@ from unittest.mock import Mock
 import pytest
 
 from dissect.cstruct import compiler
+from dissect.cstruct.expression import Expression
 from dissect.cstruct.types.structure import Field
 
 if TYPE_CHECKING:
@@ -111,16 +112,12 @@ def test_generate_packed_read(cs: cstruct) -> None:
     data = _struct(cls.cs.endian, "BhIq").unpack(buf)
 
     r["a"] = type.__call__(_0, data[0])
-    s["a"] = 1
 
     r["b"] = type.__call__(_1, data[1])
-    s["b"] = 2
 
     r["c"] = type.__call__(_2, data[2])
-    s["c"] = 4
 
     r["d"] = type.__call__(_3, data[3])
-    s["d"] = 8
     """
 
     assert code == dedent(expected)
@@ -143,22 +140,18 @@ def test_generate_packed_read_array(cs: cstruct) -> None:
     _t = _0
     _et = _t.type
     r["a"] = type.__call__(_t, [type.__call__(_et, e) for e in data[0:2]])
-    s["a"] = 2
 
     _t = _1
     _et = _t.type
     r["b"] = type.__call__(_t, [type.__call__(_et, e) for e in data[2:5]])
-    s["b"] = 6
 
     _t = _2
     _et = _t.type
     r["c"] = type.__call__(_t, [type.__call__(_et, e) for e in data[5:9]])
-    s["c"] = 16
 
     _t = _3
     _et = _t.type
     r["d"] = type.__call__(_t, [type.__call__(_et, e) for e in data[9:14]])
-    s["d"] = 40
     """
 
     assert code == dedent(expected)
@@ -181,25 +174,19 @@ def test_generate_packed_read_byte_types(cs: cstruct) -> None:
     data = _struct(cls.cs.endian, "18x").unpack(buf)
 
     r["a"] = type.__call__(_0, buf[0:1])
-    s["a"] = 1
 
     r["b"] = type.__call__(_1, buf[1:3])
-    s["b"] = 2
 
     r["c"] = _2(buf[3:5])
-    s["c"] = 2
 
     r["d"] = _3(buf[5:9])
-    s["d"] = 4
 
     r["e"] = _4(buf[9:12])
-    s["e"] = 3
 
     _t = _5
     _et = _t.type
     _b = buf[12:18]
     r["f"] = type.__call__(_t, [_et(_b[i:i + 3]) for i in range(0, 6, 3)])
-    s["f"] = 6
     """
 
     assert code == dedent(expected)
@@ -223,16 +210,13 @@ def test_generate_packed_read_composite_types(cs: cstruct, TestEnum: type[Enum])
     data = _struct(cls.cs.endian, "BQ2B").unpack(buf)
 
     r["a"] = type.__call__(_0, data[0])
-    s["a"] = 1
 
     _pt = _1
     r["b"] = _pt.__new__(_pt, data[1], stream, r)
-    s["b"] = 8
 
     _t = _2
     _et = _t.type
     r["c"] = type.__call__(_t, [type.__call__(_et, e) for e in data[2:4]])
-    s["c"] = 2
     """
 
     assert code == dedent(expected)
@@ -251,10 +235,8 @@ def test_generate_packed_read_offsets(cs: cstruct) -> None:
     data = _struct(cls.cs.endian, "B7xB").unpack(buf)
 
     r["a"] = type.__call__(_0, data[0])
-    s["a"] = 1
 
     r["b"] = type.__call__(_1, data[1])
-    s["b"] = 1
     """
 
     assert code == dedent(expected)
@@ -335,7 +317,7 @@ def test_generate_fields_dynamic_after_bitfield(cs: cstruct, TestEnum: Enum, oth
         Field("size", cs.uint16, offset=0),
         Field("a", TestEnum, 4, offset=2),
         Field("b", _type, 4),
-        Field("c", cs.char["size"], offset=3),
+        Field("c", cs.char[Expression("size")], offset=3),
     ]
 
     output = "\n".join(compiler._ReadSourceGenerator(cs, fields)._generate_fields())
@@ -346,7 +328,6 @@ def test_generate_fields_dynamic_after_bitfield(cs: cstruct, TestEnum: Enum, oth
     data = _struct(cls.cs.endian, "H").unpack(buf)
 
     r["size"] = type.__call__(_0, data[0])
-    s["size"] = 2
 
 
     _t = _1
@@ -375,7 +356,7 @@ def test_generate_fields_dynamic_before_bitfield(cs: cstruct, TestEnum: Enum, ot
         Field("size", cs.uint16, offset=0),
         Field("a", _type, 4, offset=2),
         Field("b", TestEnum, 4),
-        Field("c", cs.char["size"], offset=3),
+        Field("c", cs.char[Expression("size")], offset=3),
     ]
 
     output = "\n".join(compiler._ReadSourceGenerator(cs, fields)._generate_fields())
@@ -386,7 +367,6 @@ def test_generate_fields_dynamic_before_bitfield(cs: cstruct, TestEnum: Enum, ot
     data = _struct(cls.cs.endian, "H").unpack(buf)
 
     r["size"] = type.__call__(_0, data[0])
-    s["size"] = 2
 
 
     _t = _1

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/tests/test_expression.py

@@ -88,8 +88,8 @@ def id_fn(val: Any) -> str | None:
 
 @pytest.mark.parametrize(("expression", "answer"), testdata, ids=id_fn)
 def test_expression(expression: str, answer: int) -> None:
-    parser = Expression(Consts(), expression)
-    assert parser.evaluate() == answer
+    parser = Expression(expression)
+    assert parser.evaluate(Consts()) == answer
 
 
 @pytest.mark.parametrize(
@@ -110,7 +110,7 @@ def test_expression(expression: str, answer: int) -> None:
 )
 def test_expression_failure(expression: str, exception: type, message: str) -> None:
     with pytest.raises(exception, match=message):
-        Expression(Consts(), expression).evaluate()
+        Expression(expression).evaluate(Consts())
 
 
 def test_sizeof(cs: cstruct) -> None:

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/tests/test_types_base.py

@@ -137,3 +137,12 @@ def test_custom_array_type(cs: cstruct, compiled: bool) -> None:
     assert isinstance(result.b, CustomType)
     assert result.a.value == b"ASDF"
     assert result.b.value == b"asdf"
+
+
+def test_truthy_type(cs: cstruct) -> None:
+    static_type = cs.uint32
+    dynamic_type = cs.uint32[None]
+
+    assert static_type
+    # Should not raise a TypeError: Dynamic size
+    assert dynamic_type

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/tests/test_types_structure.py

@@ -265,7 +265,8 @@ def test_structure_definition_simple(cs: cstruct, compiled: bool) -> None:
     with pytest.raises(AttributeError):
         obj.nope  # noqa: B018
 
-    assert obj._sizes["magic"] == 4
+    assert obj.__dynamic_sizes__ == { "string": 7, "wstring": 10 }
+    assert obj.__sizes__ == { "magic": 4, "wmagic": 8, "a": 1, "b": 2, "c": 4, "string": 7, "wstring": 10 }
     assert len(obj) == len(buf)
     assert obj.dumps() == buf
 
@@ -275,6 +276,39 @@ def test_structure_definition_simple(cs: cstruct, compiled: bool) -> None:
     obj.write(fh)
     assert fh.getvalue() == buf
 
+def test_structure_values_dict(cs: cstruct, compiled: bool) -> None:
+    cdef = """
+    struct test {
+        char    magic[4];
+        wchar   wmagic[4];
+        uint8   a;
+        uint16  b;
+        uint32  c;
+        char    string[];
+        wchar   wstring[];
+    };
+    """
+    cs.load(cdef, compiled=compiled)
+    buf = b"testt\x00e\x00s\x00t\x00\x01\x02\x03\x04\x05\x06\x07lalala\x00t\x00e\x00s\x00t\x00\x00\x00"
+    obj = cs.test(buf)
+
+    # Test reading all values
+    values = obj.__values__
+    assert values["magic"] == b"test"
+    assert values["wmagic"] == "test"
+    assert values["a"] == 0x01
+    assert values["b"] == 0x0302
+    assert values["c"] == 0x07060504
+    assert values["string"] == b"lalala"
+    assert values["wstring"] == "test"
+
+    # Test writing a single field through the proxy
+    values["a"] = 0xFF
+    assert obj.a == 0xFF
+
+    # Test dictionary methods
+    assert values.keys() == {"magic", "wmagic", "a", "b", "c", "string", "wstring"}
+
 
 def test_structure_definition_simple_be(cs: cstruct, compiled: bool) -> None:
     cdef = """

{dissect_cstruct-4.5.dev4 → dissect_cstruct-4.6.dev1}/tests/test_types_void.py

@@ -10,7 +10,9 @@ if TYPE_CHECKING:
 
 
 def test_void_read(cs: cstruct) -> None:
-    assert not cs.void
+    # The type itself is truthy, but an instance is not
+    assert cs.void
+    assert not cs.void()
 
     stream = io.BytesIO(b"AAAA")
     assert not cs.void(stream)
@@ -23,11 +25,11 @@ def test_void_write(cs: cstruct) -> None:
 
 
 def test_void_array_read(cs: cstruct) -> None:
-    assert not cs.void[4]
+    assert not cs.void[4]()
 
     stream = io.BytesIO(b"AAAA")
-    assert not any(cs.void[4](stream))
-    assert not any(cs.void[None](stream))
+    assert not cs.void[4](stream)
+    assert not cs.void[None](stream)
     assert stream.tell() == 0
 
 
@@ -41,7 +43,7 @@ def test_void_default(cs: cstruct) -> None:
     assert not cs.void()
     assert not cs.void.__default__()
 
-    assert cs.void[1].__default__() == [cs.void()]
+    assert cs.void[1].__default__() == []
     assert cs.void[None].__default__() == []
 
 
@@ -61,8 +63,8 @@ def test_void_struct(cs: cstruct, compiled: bool) -> None:
 
     obj = cs.test(stream)
     assert not obj.a
-    assert not any(obj.b)
-    assert not any(obj.c)
+    assert not obj.b
+    assert not obj.c
 
     assert stream.tell() == 0
 

dissect_cstruct-4.5.dev4/dissect/cstruct/types/void.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, BinaryIO
-
-from dissect.cstruct.types.base import BaseType
-
-
-class Void(BaseType):
-    """Void type."""
-
-    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 = 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