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

dissect/cstruct/parser.py

@@ -5,13 +5,13 @@ import re
 from typing import TYPE_CHECKING
 
 from dissect.cstruct import compiler
-from dissect.cstruct.exceptions import (
+from dissect.cstruct.exception import (
     ExpressionParserError,
     LexerError,
     ParserError,
 )
 from dissect.cstruct.expression import Expression
-from dissect.cstruct.lexer import IDENTIFIER_TYPES, TokenCursor, TokenType, tokenize
+from dissect.cstruct.lexer import IDENTIFIER_TYPES, TokenCursor, TokenType, format_error_context, tokenize
 from dissect.cstruct.types import BaseArray, BaseType, Field, Structure
 
 if TYPE_CHECKING:
@@ -58,6 +58,7 @@ class CStyleParser(Parser):
         super().__init__(cs)
         self.compiled = compiled
         self.align = align
+        self._data = None
 
         self._flags: list[str] = []
         self._conditional_stack: list[tuple[Token, bool]] = []
@@ -74,6 +75,8 @@ class CStyleParser(Parser):
 
         data = _join_line_continuations(data)
 
+        # Keep a reference for error messages
+        self._data = data
         self._reset_tokens(tokenize(data))
         self._parse()
 
@@ -88,7 +91,12 @@ class CStyleParser(Parser):
         return self._tokens[self._pos].type in types
 
     def _error(self, msg: str, *, token: Token | None = None) -> ParserError:
-        return ParserError(f"line {(token if token is not None else self._tokens[self._pos]).line}: {msg}")
+        lineno = (token if token is not None else self._tokens[self._pos]).line
+        if self._data is None:
+            return ParserError(f"line {lineno}: {msg}")
+
+        content = format_error_context(self._data, lineno)
+        return ParserError(f"line {lineno}: {msg}\n{content}")
 
     def _in_false_branch(self) -> bool:
         """Return whether we're currently in a false conditional branch."""
@@ -142,7 +150,8 @@ class CStyleParser(Parser):
 
                 # If it's an anonymous enum/flag, add its members to the constants for convenience
                 if not type_.__name__:
-                    self.cs.consts.update(type_.__members__)
+                    for k, v in type_.__members__.items():
+                        self.cs.add_const(k, v)
 
                 self._expect(TokenType.SEMICOLON)
             else:
@@ -177,8 +186,9 @@ class CStyleParser(Parser):
                 if value[-1] != quote:
                     raise self._error("unterminated bytes literal", token=token)
 
-                # Remove the leading b and surrounding quotes
-                value = ast.literal_eval(f"b{value[2:-1]!r}")
+                # Remove the leading b and surrounding quotes and flatten escape sequences
+                value = value[2:-1].encode().decode("unicode_escape")
+                value = ast.literal_eval(f"b{value!r}")
             else:
                 try:
                     # Lazy mode, try to evaluate as a Python literal first (for simple constants)
@@ -192,17 +202,17 @@ class CStyleParser(Parser):
                             # If evaluation fails, just keep it as a string (e.g. for macro-like constants)
                             pass
 
-        self.cs.consts[name_token.value] = value
+        self.cs.add_const(name_token.value, value)
 
     def _parse_undef(self) -> None:
         """Parse an undef directive and remove the constant."""
         self._expect(TokenType.PP_UNDEF)
 
         name_token = self._expect(TokenType.IDENTIFIER)
-        if name_token.value in self.cs.consts:
-            del self.cs.consts[name_token.value]
-        else:
-            raise self._error(f"constant {name_token.value!r} not defined", token=name_token)
+        try:
+            self.cs.del_const(name_token.value)
+        except KeyError:
+            raise self._error(f"constant {name_token.value!r} not defined", token=name_token) from None
 
     def _parse_include(self) -> None:
         """Parse an include directive and add the included file to the includes list."""
@@ -385,7 +395,15 @@ class CStyleParser(Parser):
                 continue
             self._assert_not_eof()
 
-            member_name = self._expect(TokenType.IDENTIFIER).value
+            # For historical reasons, we allow enum/flag member names to start with a digit
+            # E.g. `32BIT`
+            member_name = ""
+            if token := self._match(TokenType.NUMBER):
+                member_name += token.value
+                if token := self._match(TokenType.IDENTIFIER):
+                    member_name += token.value
+            else:
+                member_name = self._expect(TokenType.IDENTIFIER).value
 
             if self._match(TokenType.EQUALS):
                 expression = self._collect_until(TokenType.COMMA, TokenType.RBRACE)
@@ -527,7 +545,7 @@ class CStyleParser(Parser):
             ):
                 # This identifier is followed by a field delimiter, it should be the field name,
                 # UNLESS the current parts don't form a valid type yet.
-                if " ".join(parts) in self.cs.typedefs:
+                if " ".join(parts) in self.cs.types:
                     break
 
                 # Current parts don't resolve, consume and hope this completes the type name

dissect/cstruct/tools/stubgen.py

@@ -79,31 +79,29 @@ def generate_cstruct_stub(cs: cstruct, module_prefix: str = "", cls_name: str =
 
     defined_names = set()
 
-    # Then typedefs
-    for name, typedef in cs.typedefs.items():
-        if name in empty_cs.typedefs:
+    # Then types
+    for name, type_ in cs.types.items():
+        if name in empty_cs.types:
             continue
 
-        if typedef.__name__ in empty_cs.typedefs:
-            stub = f"{name}: TypeAlias = {cs_prefix}{typedef.__name__}"
-        elif typedef.__name__ in defined_names:
+        if type_.__name__ in empty_cs.types:
+            stub = f"{name}: TypeAlias = {cs_prefix}{type_.__name__}"
+        elif type_.__name__ in defined_names:
             # Create an alias to the type if we have already seen it before.
-            stub = f"{name}: TypeAlias = {typedef.__name__}"
-        elif issubclass(typedef, (types.Enum, types.Flag)):
-            stub = generate_enum_stub(typedef, cs_prefix=cs_prefix, module_prefix=module_prefix)
-        elif issubclass(typedef, types.Pointer):
-            typehint = generate_typehint(typedef, prefix=cs_prefix, module_prefix=module_prefix)
+            stub = f"{name}: TypeAlias = {type_.__name__}"
+        elif issubclass(type_, (types.Enum, types.Flag)):
+            stub = generate_enum_stub(type_, cs_prefix=cs_prefix, module_prefix=module_prefix)
+        elif issubclass(type_, types.Pointer):
+            typehint = generate_typehint(type_, prefix=cs_prefix, module_prefix=module_prefix)
             stub = f"{name}: TypeAlias = {typehint}"
-        elif issubclass(typedef, types.Structure):
-            stub = generate_structure_stub(typedef, cs_prefix=cs_prefix, module_prefix=module_prefix)
-        elif issubclass(typedef, types.BaseType):
-            stub = generate_generic_stub(typedef, cs_prefix=cs_prefix, module_prefix=module_prefix)
-        elif isinstance(typedef, str):
-            stub = f"{name}: TypeAlias = {typedef}"
+        elif issubclass(type_, types.Structure):
+            stub = generate_structure_stub(type_, cs_prefix=cs_prefix, module_prefix=module_prefix)
+        elif issubclass(type_, types.BaseType):
+            stub = generate_generic_stub(type_, cs_prefix=cs_prefix, module_prefix=module_prefix)
         else:
-            raise TypeError(f"Unknown typedef: {typedef}")
+            raise TypeError(f"Unknown type: {type_}")
 
-        defined_names.add(typedef.__name__)
+        defined_names.add(type_.__name__)
 
         body.append(textwrap.indent(stub, prefix=indent))
 
@@ -158,12 +156,10 @@ def generate_structure_stub(
     module_prefix: str = "",
 ) -> str:
     result = [f"class {name_prefix}{structure.__name__}({module_prefix}{structure.__base__.__name__}):"]
-
     indent = " " * 4
 
     args = ["self"]
     for field_name, field in structure.fields.items():
-        type_name = field.type.__name__
         inlined = False
 
         # If it's a structure and not globally defined, add an inline stub for it
@@ -171,7 +167,7 @@ def generate_structure_stub(
         while issubclass(nested_type, types.BaseArray):
             nested_type = nested_type.type
 
-        if issubclass(nested_type, types.Structure) and type_name not in structure.cs.typedefs:
+        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)
 

dissect/cstruct/types/base.py

@@ -4,7 +4,7 @@ import functools
 from io import BytesIO
 from typing import TYPE_CHECKING, Any, BinaryIO, ClassVar, TypeVar
 
-from dissect.cstruct.exceptions import ArraySizeError
+from dissect.cstruct.exception import ArraySizeError
 from dissect.cstruct.expression import Expression
 
 if TYPE_CHECKING:
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
 
     from typing_extensions import Self
 
-    from dissect.cstruct.cstruct import cstruct
+    from dissect.cstruct.cstruct import AllowedEndianness, Endianness, cstruct
 
 
 EOF = -0xE0F  # Negative counts are illegal anyway, so abuse that for our EOF sentinel
@@ -41,14 +41,15 @@ class MetaType(type):
             stream = args[0]
 
             if _is_readable_type(stream):
-                return cls._read(stream)
+                endian = normalize_endianness(endian) if (endian := kwargs.get("endian")) is not None else cls.cs.endian
+                return cls._read(stream, endian=endian)
 
             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 _is_buffer_type(stream):
-                return cls.reads(stream)
+                return cls.reads(stream, endian=kwargs.get("endian"))
 
         return type.__call__(cls, *args, **kwargs)
 
@@ -71,60 +72,73 @@ class MetaType(type):
         """Return the default value of this type."""
         return cls()
 
-    def reads(cls, data: bytes | memoryview | bytearray) -> Self:  # type: ignore
+    def reads(cls, data: bytes | memoryview | bytearray, *, endian: AllowedEndianness | None = None) -> Self:  # type: ignore
         """Parse the given data from a bytes-like object.
 
         Args:
             data: Bytes-like object to parse.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
+                    When omitted, the cstruct instance's current endianness is used.
 
         Returns:
             The parsed value of this type.
         """
-        return cls._read(BytesIO(data))
+        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        return cls._read(BytesIO(data), endian=endian)
 
-    def read(cls, obj: BinaryIO | bytes | memoryview | bytearray) -> Self:  # type: ignore
+    def read(cls, obj: BinaryIO | bytes | memoryview | bytearray, *, endian: AllowedEndianness | None = None) -> Self:  # type: ignore
         """Parse the given data.
 
         Args:
             obj: Data to parse. Can be a bytes-like object or a file-like object.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
+                    When omitted, the cstruct instance's current endianness is used.
 
         Returns:
             The parsed value of this type.
         """
         if _is_buffer_type(obj):
-            return cls.reads(obj)
+            return cls.reads(obj, endian=endian)
 
         if not _is_readable_type(obj):
             raise TypeError("Invalid object type")
 
-        return cls._read(obj)
+        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        return cls._read(obj, endian=endian)
 
-    def write(cls, stream: BinaryIO, value: Any) -> int:
+    def write(cls, stream: BinaryIO, value: Any, *, endian: AllowedEndianness | None = None) -> int:
         """Write a value to a writable file-like object.
 
         Args:
             stream: File-like objects that supports writing.
             value: Value to write.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
+                    When omitted, the cstruct instance's current endianness is used.
 
         Returns:
             The amount of bytes written.
         """
-        return cls._write(stream, value)
+        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+        return cls._write(stream, value, endian=endian)
 
-    def dumps(cls, value: Any) -> bytes:
+    def dumps(cls, value: Any, *, endian: AllowedEndianness | None = None) -> bytes:
         """Dump a value to a byte string.
 
         Args:
             value: Value to dump.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
+                    When omitted, the cstruct instance's current endianness is used.
 
         Returns:
             The raw bytes of this type.
         """
+        endian = normalize_endianness(endian) if endian is not None else cls.cs.endian
+
         out = BytesIO()
-        cls._write(out, value)
+        cls._write(out, value, endian=endian)
         return out.getvalue()
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:  # type: ignore
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:  # type: ignore
         """Internal function for reading value.
 
         Must be implemented per type.
@@ -132,10 +146,13 @@ class MetaType(type):
         Args:
             stream: The stream to read from.
             context: Optional reading context.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
         """
         raise NotImplementedError
 
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Self]:  # type: ignore
+    def _read_array(
+        cls, stream: BinaryIO, count: int, *, context: dict[str, Any] | None = None, endian: Endianness
+    ) -> list[Self]:  # type: ignore
         """Internal function for reading array values.
 
         Allows type implementations to do optimized reading for their type.
@@ -144,16 +161,17 @@ class MetaType(type):
             stream: The stream to read from.
             count: The amount of values to read.
             context: Optional reading context.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
         """
         if count == EOF:
             result = []
             while not _is_eof(stream):
-                result.append(cls._read(stream, context))
+                result.append(cls._read(stream, context=context, endian=endian))
             return result
 
-        return [cls._read(stream, context) for _ in range(count)]
+        return [cls._read(stream, context=context, endian=endian) for _ in range(count)]
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:
+    def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[Self]:
         """Internal function for reading null-terminated data.
 
         "Null" is type specific, so must be implemented per type.
@@ -161,13 +179,14 @@ class MetaType(type):
         Args:
             stream: The stream to read from.
             context: Optional reading context.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
         """
         raise NotImplementedError
 
-    def _write(cls, stream: BinaryIO, data: Any) -> int:
+    def _write(cls, stream: BinaryIO, data: Any, *, endian: Endianness) -> int:
         raise NotImplementedError
 
-    def _write_array(cls, stream: BinaryIO, array: list[Self]) -> int:  # type: ignore
+    def _write_array(cls, stream: BinaryIO, array: list[Self], *, endian: Endianness) -> int:  # type: ignore
         """Internal function for writing arrays.
 
         Allows type implementations to do optimized writing for their type.
@@ -175,10 +194,11 @@ class MetaType(type):
         Args:
             stream: The stream to read from.
             array: The array to write.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
         """
-        return sum(cls._write(stream, entry) for entry in array)
+        return sum(cls._write(stream, entry, endian=endian) for entry in array)
 
-    def _write_0(cls, stream: BinaryIO, array: list[Self]) -> int:  # type: ignore
+    def _write_0(cls, stream: BinaryIO, array: list[Self], *, endian: Endianness) -> int:  # type: ignore
         """Internal function for writing null-terminated arrays.
 
         Allows type implementations to do optimized writing for their type.
@@ -186,8 +206,9 @@ class MetaType(type):
         Args:
             stream: The stream to read from.
             array: The array to write.
+            endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
         """
-        return cls._write_array(stream, [*array, cls.__default__()])
+        return cls._write_array(stream, [*array, cls.__default__()], endian=endian)
 
 
 class _overload:
@@ -250,9 +271,9 @@ class BaseArray(BaseType):
         )
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[BaseType]:
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[BaseType]:
         if cls.null_terminated:
-            return cls.type._read_0(stream, context)
+            return cls.type._read_0(stream, context=context, endian=endian)
 
         if isinstance(cls.num_entries, int):
             num = max(0, cls.num_entries)
@@ -266,23 +287,25 @@ class BaseArray(BaseType):
                     raise
                 num = EOF
 
-        return cls.type._read_array(stream, num, context)
+        return cls.type._read_array(stream, num, context=context, endian=endian)
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: list[Any]) -> int:
+    def _write(cls, stream: BinaryIO, data: list[Any], *, endian: Endianness) -> int:
         if cls.null_terminated:
-            return cls.type._write_0(stream, data)
+            return cls.type._write_0(stream, data, endian=endian)
 
-        if not cls.dynamic and cls.num_entries != (actual_size := len(data)):
-            raise ArraySizeError(f"Expected static array size {cls.num_entries}, got {actual_size} instead.")
+        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.")
+            data = data + [cls.type.__default__()] * remaining
 
-        return cls.type._write_array(stream, data)
+        return cls.type._write_array(stream, data, endian=endian)
 
 
 class Array(list[T], BaseArray):
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[T]:
-        return cls(super()._read(stream, context))
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[T]:
+        return cls(super()._read(stream, context=context, endian=endian))
 
 
 def _is_readable_type(value: object) -> bool:
@@ -305,5 +328,27 @@ def _is_eof(stream: BinaryIO) -> bool:
     return False
 
 
+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
+
+
 # As mentioned in the BaseType class, we correctly set the type here
 MetaType.ArrayType = Array

dissect/cstruct/types/char.py

@@ -2,11 +2,14 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, BinaryIO
 
+from dissect.cstruct.exception import ArraySizeError
 from dissect.cstruct.types.base import EOF, BaseArray, BaseType
 
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import Endianness
+
 
 class CharArray(bytes, BaseArray):
     """Character array type for reading and writing byte strings."""
@@ -16,19 +19,24 @@ class CharArray(bytes, BaseArray):
         return type.__call__(cls, b"\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) -> Self:
-        return type.__call__(cls, super()._read(stream, context))
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
+        return type.__call__(cls, super()._read(stream, context=context, endian=endian))
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: bytes) -> int:
-        if isinstance(data, list) and data and isinstance(data[0], int):
+    def _write(cls, stream: BinaryIO, data: bytes | str | list[int], *, endian: Endianness) -> int:
+        if isinstance(data, list):
             data = bytes(data)
-
         elif isinstance(data, str):
             data = data.encode("latin-1")
 
         if cls.null_terminated:
-            return stream.write(data + b"\x00")
+            data += b"\x00"
+
+        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.")
+            data += b"\x00" * remaining
+
         return stream.write(data)
 
 
@@ -42,11 +50,13 @@ class Char(bytes, BaseType):
         return type.__call__(cls, b"\x00")
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
-        return cls._read_array(stream, 1, context)
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
+        return cls._read_array(stream, 1, context=context, endian=endian)
 
     @classmethod
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> Self:
+    def _read_array(
+        cls, stream: BinaryIO, count: int, *, context: dict[str, Any] | None = None, endian: Endianness
+    ) -> Self:
         if count == 0:
             return type.__call__(cls, b"")
 
@@ -57,7 +67,7 @@ class Char(bytes, BaseType):
         return type.__call__(cls, data)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         buf = []
         while True:
             byte = stream.read(1)
@@ -72,7 +82,7 @@ class Char(bytes, BaseType):
         return type.__call__(cls, b"".join(buf))
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: bytes | int | str) -> int:
+    def _write(cls, stream: BinaryIO, data: bytes | int | str, *, endian: Endianness) -> int:
         if isinstance(data, int):
             data = chr(data)
 

dissect/cstruct/types/enum.py

@@ -10,7 +10,7 @@ from dissect.cstruct.types.base import BaseType, MetaType
 if TYPE_CHECKING:
     from typing_extensions import Self
 
-    from dissect.cstruct.cstruct import cstruct
+    from dissect.cstruct.cstruct import Endianness, cstruct
     from dissect.cstruct.types.base import Array
 
 
@@ -84,25 +84,45 @@ class EnumMetaType(EnumMeta, MetaType):
             return True
         return value in cls._value2member_map_
 
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
-        return cls(cls.type._read(stream, context))
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
+        return cls(cls.type._read(stream, context=context, endian=endian))
 
-    def _read_array(cls, stream: BinaryIO, count: int, context: dict[str, Any] | None = None) -> list[Self]:
-        return list(map(cls, cls.type._read_array(stream, count, context)))
+    def _read_array(
+        cls, stream: BinaryIO, count: int, *, context: dict[str, Any] | None = None, endian: Endianness
+    ) -> list[Self]:
+        return list(map(cls, cls.type._read_array(stream, count, context=context, endian=endian)))
 
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> list[Self]:
-        return list(map(cls, cls.type._read_0(stream, context)))
+    def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[Self]:
+        return list(map(cls, cls.type._read_0(stream, context=context, endian=endian)))
 
-    def _write(cls, stream: BinaryIO, data: Enum) -> int:
-        return cls.type._write(stream, data.value)
+    def _write(cls, stream: BinaryIO, data: Enum, *, endian: Endianness) -> int:
+        return cls.type._write(stream, data.value, endian=endian)
 
-    def _write_array(cls, stream: BinaryIO, array: list[BaseType | int]) -> int:
+    def _write_array(cls, stream: BinaryIO, array: list[BaseType | int], *, endian: Endianness) -> int:
         data = [entry.value if isinstance(entry, _Enum) else entry for entry in array]
-        return cls.type._write_array(stream, data)
+        return cls.type._write_array(stream, data, endian=endian)
 
-    def _write_0(cls, stream: BinaryIO, array: list[BaseType | int]) -> int:
+    def _write_0(cls, stream: BinaryIO, array: list[BaseType | int], *, endian: Endianness) -> int:
         data = [entry.value if isinstance(entry, _Enum) else entry for entry in array]
-        return cls._write_array(stream, [*data, cls.type.__default__()])
+        return cls._write_array(stream, [*data, cls.type.__default__()], endian=endian)
+
+    def cdef(cls) -> str:
+        """Render this enum (or flag) back to its C-style definition.
+
+        Returns:
+            The C-style definition as a string.
+        """
+        keyword = "flag" if issubclass(cls, IntFlag) else "enum"
+        underlying = cls.type.__name__
+        title = f"{keyword} {cls.__name__} : {underlying}" if cls.__name__ else f"{keyword} : {underlying}"
+
+        lines = [f"{title} {{"]
+        for member_name, member in cls.__members__.items():
+            value = hex(member.value) if keyword == "flag" else member.value
+            lines.append(f"    {member_name} = {value},")
+        lines.append("};")
+
+        return "\n".join(lines)
 
 
 def _fix_alias_members(cls: type[Enum]) -> None:

dissect/cstruct/types/int.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.cstruct.types.base import BaseType
-from dissect.cstruct.utils import ENDIANNESS_MAP
+from dissect.cstruct.util import ENDIANNESS_TO_BYTEORDER_MAP
 
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+    from dissect.cstruct.cstruct import Endianness
+
 
 class Int(int, BaseType):
     """Integer type that can span an arbitrary amount of bytes."""
@@ -15,20 +17,20 @@ class Int(int, BaseType):
     signed: bool
 
     @classmethod
-    def _read(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         data = stream.read(cls.size)
 
         if len(data) != cls.size:
             raise EOFError(f"Read {len(data)} bytes, but expected {cls.size}")
 
-        return cls.from_bytes(data, ENDIANNESS_MAP[cls.cs.endian], signed=cls.signed)
+        return cls.from_bytes(data, ENDIANNESS_TO_BYTEORDER_MAP[endian], signed=cls.signed)
 
     @classmethod
-    def _read_0(cls, stream: BinaryIO, context: dict[str, Any] | None = None) -> Self:
+    def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
         result = []
 
         while True:
-            if (value := cls._read(stream, context)) == 0:
+            if (value := cls._read(stream, context=context, endian=endian)) == 0:
                 break
 
             result.append(value)
@@ -36,5 +38,5 @@ class Int(int, BaseType):
         return result
 
     @classmethod
-    def _write(cls, stream: BinaryIO, data: int) -> int:
-        return stream.write(data.to_bytes(cls.size, ENDIANNESS_MAP[cls.cs.endian], signed=cls.signed))
+    def _write(cls, stream: BinaryIO, data: int, *, endian: Endianness) -> int:
+        return stream.write(data.to_bytes(cls.size, ENDIANNESS_TO_BYTEORDER_MAP[endian], signed=cls.signed))