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

dissect/cstruct/cstruct.py

@@ -8,6 +8,7 @@ import sys
 import types
 import warnings
 from contextlib import contextmanager
+from functools import lru_cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, BinaryIO, Literal, TypeVar, cast
 
@@ -32,7 +33,7 @@ from dissect.cstruct.types import (
 from dissect.cstruct.types.base import normalize_endianness
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Iterator
+    from collections.abc import Generator, Iterable
     from typing import TypeAlias
 
     from dissect.cstruct.types import (
@@ -203,6 +204,9 @@ class cstruct:
         self.pointer: type[BaseType] = self.resolve(pointer)
         self._anonymous_count = 0
 
+        # Array types are frequently created at runtime (e.g. ``cs.uint32[count]``), so cache them per instance
+        self._make_array_cached = lru_cache(maxsize=4096)(self._make_array_cached)
+
         if load:
             self.load(load)
 
@@ -467,7 +471,7 @@ class cstruct:
         return copy.copy(self)
 
     @contextmanager
-    def endianness(self, endian: AllowedEndianness) -> Iterator[cstruct]:
+    def endianness(self, endian: AllowedEndianness) -> Generator[cstruct]:
         """Context manager for temporarily changing the endianness of this cstruct instance."""
         original = self.endian
         self.endian = normalize_endianness(endian)
@@ -477,13 +481,13 @@ class cstruct:
             self.endian = original
 
     @contextmanager
-    def big_endian(self) -> Iterator[cstruct]:
+    def big_endian(self) -> Generator[cstruct]:
         """Context manager for temporarily changing the endianness to big endian."""
         with self.endianness(">") as cs:
             yield cs
 
     @contextmanager
-    def little_endian(self) -> Iterator[cstruct]:
+    def little_endian(self) -> Generator[cstruct]:
         """Context manager for temporarily changing the endianness to little endian."""
         with self.endianness("<") as cs:
             yield cs
@@ -513,6 +517,17 @@ class cstruct:
         return types.new_class(name, bases, {}, lambda ns: ns.update(attrs))
 
     def _make_array(self, type_: T, num_entries: int | Expression | None) -> type[Array[T]]:
+        if isinstance(num_entries, Expression):
+            # Only created when parsing a definition, so no point in caching
+            return self._make_array_type(type_, num_entries)
+
+        # Structures can be dynamically modified, so include the size and alignment in the cache key
+        return self._make_array_cached(type_, num_entries, type_.__size__, type_.__alignment__)
+
+    def _make_array_cached(self, type_: T, num_entries: int | None, size: int | None, alignment: int) -> type[Array[T]]:
+        return self._make_array_type(type_, num_entries)
+
+    def _make_array_type(self, type_: T, num_entries: int | Expression | None) -> type[Array[T]]:
         null_terminated = False
         if num_entries is None:
             null_terminated = True

dissect/cstruct/expression.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from dissect.cstruct.exception import ExpressionParserError
 from dissect.cstruct.lexer import IDENTIFIER_TYPES, Lexer, TokenCursor, TokenType
@@ -34,6 +34,21 @@ UNARY_OPERATORS: dict[TokenType, Callable[[int], int]] = {
 
 OPERATORS = set(BINARY_OPERATORS.keys()) | set(UNARY_OPERATORS.keys())
 
+OPERATOR_SOURCE: dict[TokenType, str] = {
+    TokenType.PIPE: "|",
+    TokenType.CARET: "^",
+    TokenType.AMPERSAND: "&",
+    TokenType.LSHIFT: "<<",
+    TokenType.RSHIFT: ">>",
+    TokenType.PLUS: "+",
+    TokenType.MINUS: "-",
+    TokenType.STAR: "*",
+    TokenType.SLASH: "//",
+    TokenType.PERCENT: "%",
+    TokenType.UNARY_MINUS: "-",
+    TokenType.TILDE: "~",
+}
+
 FUNCTION_TOKENS = {
     TokenType.SIZEOF: 1,
     TokenType.OFFSETOF: 2,
@@ -58,6 +73,100 @@ PRECEDENCE_LEVELS = {
 }
 
 
+def _sizeof(cs: cstruct, name: str) -> int:
+    return sizeof(cs.resolve(name))
+
+
+def _offsetof(cs: cstruct, name: str, field: str) -> int:
+    return offsetof(cs.resolve(name), field)
+
+
+FUNCTIONS: dict[TokenType, Callable[..., int]] = {
+    TokenType.SIZEOF: _sizeof,
+    TokenType.OFFSETOF: _offsetof,
+}
+
+
+def _error(msg: str, line: int) -> ExpressionParserError:
+    return ExpressionParserError(f"line {line}: {msg}")
+
+
+def _identifier(cs: cstruct, context: dict[str, Any], ident: str, line: int) -> int:
+    """Resolve an identifier to an integer value."""
+    obj = None
+    for i, part in enumerate(ident.split(".")):
+        if i == 0:
+            if part in context:
+                obj = context[part]
+            elif part in cs.consts:
+                obj = cs.consts[part]
+            elif part in cs.types:
+                obj = cs.types[part]
+            else:
+                raise _error(f"Unknown identifier: '{ident}'", line)
+        else:
+            obj = obj.get(part, _MISSING) if isinstance(obj, dict) else getattr(obj, part, _MISSING)
+            if obj is _MISSING:
+                raise _error(f"Unknown identifier: '{ident}'", line)
+
+    try:
+        return int(obj)
+    except (ValueError, TypeError):
+        raise _error(f"Identifier '{ident}' does not resolve to an integer", line)
+
+
+# Globals used by the source code of an expression
+SOURCE_GLOBALS = {func.__name__: func for func in (_identifier, *FUNCTIONS.values())}
+
+
+class _Evaluator:
+    """Calculates the value of an expression."""
+
+    def __init__(self, cs: cstruct, context: dict[str, Any]):
+        self.cs = cs
+        self.context = context
+
+    def number(self, value: int) -> int:
+        return value
+
+    def identifier(self, ident: str, token: Token) -> int:
+        return _identifier(self.cs, self.context, ident, token.line)
+
+    def unary(self, operator: TokenType, value: int) -> int:
+        return UNARY_OPERATORS[operator](value)
+
+    def binary(self, operator: TokenType, left: int, right: int) -> int:
+        return BINARY_OPERATORS[operator](left, right)
+
+    def function(self, operator: TokenType, args: list[str]) -> int:
+        return FUNCTIONS[operator](self.cs, *args)
+
+
+class _SourceBuilder:
+    """Builds the Python source code of an expression."""
+
+    def __init__(self, variables: dict[str, str], context: str):
+        self.variables = variables
+        self.context = context
+
+    def number(self, value: int) -> str:
+        return repr(value)
+
+    def identifier(self, ident: str, token: Token) -> str:
+        if ident in self.variables:
+            return self.variables[ident]
+        return f"_identifier(cs, {self.context}, {ident!r}, {token.line})"
+
+    def unary(self, operator: TokenType, value: str) -> str:
+        return f"({OPERATOR_SOURCE[operator]}{value})"
+
+    def binary(self, operator: TokenType, left: str, right: str) -> str:
+        return f"({left} {OPERATOR_SOURCE[operator]} {right})"
+
+    def function(self, operator: TokenType, args: list[str]) -> str:
+        return f"{FUNCTIONS[operator].__name__}(cs, {', '.join(map(repr, args))})"
+
+
 def precedence(o1: TokenType, o2: TokenType) -> bool:
     # Unary (prefix) operators are right-associative, so use strict greater-than
     if o2 in UNARY_OPERATORS:
@@ -86,9 +195,9 @@ class Expression(TokenCursor):
         self._queue = []
 
     def _error(self, msg: str, *, token: Token | None = None) -> ExpressionParserError:
-        return ExpressionParserError(f"line {(token if token is not None else self._current()).line}: {msg}")
+        return _error(msg, (token if token is not None else self._current()).line)
 
-    def _evaluate_expression(self, cs: cstruct) -> None:
+    def _evaluate_expression(self, backend: _Evaluator | _SourceBuilder) -> None:
         operator = self._stack.pop(-1)
         result = 0
 
@@ -96,37 +205,48 @@ class Expression(TokenCursor):
             if len(self._queue) < 1:
                 raise ExpressionParserError("Invalid expression: not enough operands")
 
-            result = UNARY_OPERATORS[operator](self._queue.pop(-1))
+            result = backend.unary(operator, self._queue.pop(-1))
         elif operator in BINARY_OPERATORS:
             if len(self._queue) < 2:
                 raise ExpressionParserError("Invalid expression: not enough operands")
 
             right = self._queue.pop(-1)
             left = self._queue.pop(-1)
-            result = BINARY_OPERATORS[operator](left, right)
+            result = backend.binary(operator, left, right)
         elif operator in FUNCTION_TOKENS:
             num_args = FUNCTION_TOKENS[operator]
             if len(self._queue) < num_args:
                 raise ExpressionParserError("Invalid expression: not enough operands")
 
             args = [self._queue.pop(-1) for _ in range(num_args)][::-1]
-            if operator == TokenType.SIZEOF:
-                type_ = cs.resolve(args[0])
-                result = sizeof(type_)
-            elif operator == TokenType.OFFSETOF:
-                type_ = cs.resolve(args[0])
-                result = offsetof(type_, args[1])
+            result = backend.function(operator, args)
 
         self._queue.append(result)
 
     def evaluate(self, cs: cstruct, context: dict[str, int] | None = None) -> int:
-        """Evaluates an expression using a Shunting-Yard implementation."""
+        """Evaluates an expression using a Shunting-Yard implementation.
+
+        Args:
+            cs: The cstruct instance to evaluate against.
+            context: The context to evaluate against.
+        """
+        return self._evaluate(_Evaluator(cs, context or {}))
+
+    def source(self, variables: dict[str, str] | None = None, context: str = "context") -> str:
+        """Return the Python source code of this expression.
+
+        Args:
+            variables: The source code map for accessing local variables.
+            context: The symbol name of the context.
+        """
+        return self._evaluate(_SourceBuilder(variables or {}, context))
+
+    def _evaluate(self, backend: _Evaluator | _SourceBuilder) -> int | str:
         self._reset()
-        context = context or {}
 
         while (token := self._current()).type != TokenType.EOF:
             if token.type == TokenType.NUMBER:
-                self._queue.append(int(self._take().value, 0))
+                self._queue.append(backend.number(int(self._take().value, 0)))
 
             elif token.type in OPERATORS:
                 while (
@@ -134,7 +254,7 @@ class Expression(TokenCursor):
                     and self._stack[-1] != TokenType.LPAREN
                     and precedence(self._stack[-1], token.type)
                 ):
-                    self._evaluate_expression(cs)
+                    self._evaluate_expression(backend)
 
                 self._stack.append(self._take().type)
 
@@ -154,31 +274,10 @@ class Expression(TokenCursor):
                 self._expect(TokenType.RPAREN)
 
                 # Evaluate immediately
-                self._evaluate_expression(cs)
+                self._evaluate_expression(backend)
 
             elif token.type in IDENTIFIER_TYPES:
-                ident = self._take().value
-
-                obj = None
-                for i, part in enumerate(ident.split(".")):
-                    if i == 0:
-                        if part in context:
-                            obj = context[part]
-                        elif part in cs.consts:
-                            obj = cs.consts[part]
-                        elif part in cs.types:
-                            obj = cs.types[part]
-                        else:
-                            raise self._error(f"Unknown identifier: '{ident}'", token=token)
-                    else:
-                        obj = obj.get(part, _MISSING) if isinstance(obj, dict) else getattr(obj, part, _MISSING)
-                        if obj is _MISSING:
-                            raise self._error(f"Unknown identifier: '{ident}'", token=token)
-
-                try:
-                    self._queue.append(int(obj))
-                except (ValueError, TypeError):
-                    raise self._error(f"Identifier '{ident}' does not resolve to an integer", token=token)
+                self._queue.append(backend.identifier(self._take().value, token))
 
             elif token.type == TokenType.LPAREN:
                 if self._previous().type == TokenType.NUMBER:
@@ -200,7 +299,7 @@ class Expression(TokenCursor):
                     raise self._error("Mismatched parentheses")
 
                 while self._stack[-1] != TokenType.LPAREN:
-                    self._evaluate_expression(cs)
+                    self._evaluate_expression(backend)
                     if len(self._stack) == 0:
                         raise self._error("Mismatched parentheses")
 
@@ -213,7 +312,7 @@ class Expression(TokenCursor):
         while len(self._stack) != 0:
             if TokenType.LPAREN in self._stack:
                 raise self._error("Mismatched parentheses")
-            self._evaluate_expression(cs)
+            self._evaluate_expression(backend)
 
         if len(self._queue) != 1:
             raise self._error("Invalid expression: too many operands")

dissect/cstruct/parser.py

@@ -342,7 +342,7 @@ class CStyleParser(Parser):
                 # Named struct/union, empty pre-register for self-referencing
                 type = factory(name, [], align=self.align)
                 if self.compiled and "nocompile" not in self._flags:
-                    type = compiler.compile(type)
+                    type = compiler.compile_structure(type)
                 self.cs.add_type(name, type)
             else:
                 # struct typename ... (type reference)
@@ -359,7 +359,7 @@ class CStyleParser(Parser):
 
             type = factory(name, fields, align=self.align, anonymous=is_anonymous)
             if self.compiled and "nocompile" not in self._flags:
-                type = compiler.compile(type)
+                type = compiler.compile_structure(type)
         else:
             type.__fields__.extend(fields)
             type.commit()

dissect/cstruct/types/base.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 
 import functools
 import warnings
-from io import BytesIO
+from io import SEEK_CUR, BytesIO
 from typing import TYPE_CHECKING, Any, BinaryIO, ClassVar, TypeVar
 
 from dissect.cstruct.exception import ArraySizeError
-from dissect.cstruct.expression import Expression
 from dissect.cstruct.util import classproperty, normalize_endianness
 
 if TYPE_CHECKING:
@@ -15,6 +14,7 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
     from dissect.cstruct.cstruct import AllowedEndianness, Endianness, cstruct
+    from dissect.cstruct.expression import Expression
 
 
 EOF = -0xE0F  # Negative counts are illegal anyway, so abuse that for our EOF sentinel
@@ -38,22 +38,35 @@ class MetaType(type):
 
     def __call__(cls, *args, **kwargs) -> Self:  # type: ignore
         """Adds support for ``TypeClass(bytes | file-like object)`` parsing syntax."""
-        # TODO: add support for Type(cs) API to create new bounded type classes, similar to the old API?
-        if len(args) == 1 and not isinstance(args[0], cls):
-            stream = args[0]
-
-            if _is_readable_type(stream):
+        if len(args) == 1 and not kwargs:
+            # Fast path for the most common case without keyword arguments
+            obj = args[0]
+            if type(obj) in _BUFFER_TYPES:
+                if len(obj) == cls.__size__ and isinstance(obj, bytes) and issubclass(cls, bytes):
+                    # Shortcut for char/bytes type
+                    return type.__call__(cls, obj)
+                return cls._read(BytesIO(obj), endian=cls.__cs__.endian)
+
+            if hasattr(obj, "read") and not isinstance(obj, cls):
+                return cls._read(obj, endian=cls.__cs__.endian)
+
+            if not _is_buffer_type(obj):
+                # E.g. initializing with a value
+                return type.__call__(cls, obj)
+
+        if len(args) == 1 and not isinstance(obj := args[0], cls):
+            if type(obj) not in _BUFFER_TYPES and hasattr(obj, "read"):
                 endian = (
                     normalize_endianness(endian) if (endian := kwargs.get("endian")) is not None else cls.__cs__.endian
                 )
-                return cls._read(stream, endian=endian)
+                return cls._read(obj, endian=endian)
 
-            if issubclass(cls, bytes) and isinstance(stream, bytes) and len(stream) == cls.__size__:
+            if isinstance(obj, bytes) and len(obj) == cls.__size__ and issubclass(cls, bytes):
                 # Shortcut for char/bytes type
                 return type.__call__(cls, *args, **kwargs)
 
-            if _is_buffer_type(stream):
-                return cls.reads(stream, endian=kwargs.get("endian"))
+            if _is_buffer_type(obj):
+                return cls.reads(obj, endian=kwargs.get("endian"))
 
         return type.__call__(cls, *args, **kwargs)
 
@@ -104,7 +117,7 @@ class MetaType(type):
         if _is_buffer_type(obj):
             return cls.reads(obj, endian=endian)
 
-        if not _is_readable_type(obj):
+        if not hasattr(obj, "read"):
             raise TypeError("Invalid object type")
 
         endian = normalize_endianness(endian) if endian is not None else cls.__cs__.endian
@@ -167,13 +180,18 @@ class MetaType(type):
             context: Optional reading context.
             endian: The endianness to use when parsing (little, big, network, <, >, !, @ or =).
         """
+        result = []
         if count == EOF:
-            result = []
             while not _is_eof(stream):
                 result.append(cls._read(stream, context=context, endian=endian))
             return result
 
-        return [cls._read(stream, context=context, endian=endian) for _ in range(count)]
+        # This is purposefully a simple loop
+        # PyPy will pre-allocate the list for a list comprehension ahead of time, which will cause huge allocations in
+        # case wrong count is read, instead of causing an EOFError when trying to read the type.
+        for _ in range(count):
+            result.append(cls._read(stream, context=context, endian=endian))  # noqa: PERF401
+        return result
 
     def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[Self]:
         """Internal function for reading null-terminated data.
@@ -329,19 +347,23 @@ class BaseArray(BaseType):
         if cls.__null_terminated__:
             return cls.__type__._read_0(stream, context=context, endian=endian)
 
+        return cls.__type__._read_array(stream, cls._num_entries(context), context=context, endian=endian)
+
+    @classmethod
+    def _num_entries(cls, context: dict[str, Any] | None) -> int:
+        """Return the number of entries to read for this (non null-terminated) array type."""
         if isinstance(cls.__num_entries__, int):
-            num = max(0, cls.__num_entries__)
-        elif cls.__num_entries__ is None:
-            num = EOF
-        elif isinstance(cls.__num_entries__, Expression):
-            try:
-                num = max(0, cls.__num_entries__.evaluate(cls.__cs__, context))
-            except Exception:
-                if cls.__num_entries__.expression != "EOF":
-                    raise
-                num = EOF
-
-        return cls.__type__._read_array(stream, num, context=context, endian=endian)
+            return max(0, cls.__num_entries__)
+
+        if cls.__num_entries__ is None:
+            return EOF
+
+        try:
+            return max(0, cls.__num_entries__.evaluate(cls.__cs__, context))
+        except Exception:
+            if cls.__num_entries__.expression != "EOF":
+                raise
+            return EOF
 
     @classmethod
     def _write(cls, stream: BinaryIO, data: list[Any], *, endian: Endianness) -> int:
@@ -389,15 +411,51 @@ class BaseArray(BaseType):
 class Array(list[T], BaseArray):
     @classmethod
     def _read(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> list[T]:
-        return cls(super()._read(stream, context=context, endian=endian))
+        return type.__call__(cls, super()._read(stream, context=context, endian=endian))
 
 
-def _is_readable_type(value: object) -> bool:
-    return hasattr(value, "read")
+_BUFFER_TYPES = (bytes, memoryview, bytearray)
 
 
 def _is_buffer_type(value: object) -> bool:
-    return isinstance(value, (bytes, memoryview, bytearray))
+    return isinstance(value, _BUFFER_TYPES)
+
+
+def _is_seekable(stream: BinaryIO) -> bool:
+    try:
+        return stream.seekable()
+    except Exception:
+        return False
+
+
+def _read_null_terminated(stream: BinaryIO, width: int) -> bytes:
+    """Read data up to a null terminator of the given width from a seekable stream, in chunks.
+
+    Leaves the stream just after the terminator.
+    """
+    terminator = b"\x00" * width
+    buf = []
+    while True:
+        chunk = stream.read(128 * width)
+        if not isinstance(chunk, (bytes, bytearray)):
+            # E.g. a memoryview, which doesn't support find()
+            chunk = bytes(chunk)
+
+        # Find a terminator that is aligned on an item
+        idx = chunk.find(terminator)
+        while idx != -1 and idx % width:
+            idx = chunk.find(terminator, idx + 1)
+
+        if idx != -1:
+            buf.append(chunk[:idx])
+            stream.seek(idx + width - len(chunk), SEEK_CUR)
+            return b"".join(buf)
+
+        if not chunk or len(chunk) % width:
+            # The end of the stream, possibly with a partial item
+            raise EOFError(f"Read {len(chunk) % width} bytes, but expected {width}")
+
+        buf.append(chunk)
 
 
 def _is_eof(stream: BinaryIO) -> bool:

dissect/cstruct/types/char.py

@@ -3,7 +3,7 @@ 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
+from dissect.cstruct.types.base import EOF, BaseArray, BaseType, _is_seekable, _read_null_terminated
 
 if TYPE_CHECKING:
     from typing_extensions import Self
@@ -68,6 +68,9 @@ class Char(bytes, BaseType):
 
     @classmethod
     def _read_0(cls, stream: BinaryIO, *, context: dict[str, Any] | None = None, endian: Endianness) -> Self:
+        if _is_seekable(stream):
+            return type.__call__(cls, _read_null_terminated(stream, 1))
+
         buf = []
         while True:
             byte = stream.read(1)

dissect/cstruct/types/enum.py

@@ -45,6 +45,10 @@ class EnumMetaType(EnumMeta, MetaType):
                 # value is a parsable value
                 value = cls.__type__(value)
 
+            # Fast path for known values
+            if type(value) is not cls and (member := cls._value2member_map_.get(value)) is not None:
+                return member
+
             return super().__call__(value)
 
         # We are constructing a new Enum class
@@ -61,6 +65,7 @@ class EnumMetaType(EnumMeta, MetaType):
         enum_cls.__alignment__ = type_.__alignment__
 
         _fix_alias_members(enum_cls)
+        _fix_flag_operators(enum_cls)
 
         return enum_cls
 
@@ -125,6 +130,14 @@ class EnumMetaType(EnumMeta, MetaType):
         return "\n".join(lines)
 
 
+def _fix_flag_operators(cls: type[Enum]) -> None:
+    # Since Python 3.11, the standard library copies its Flag operators onto every new Flag class
+    # Remove those copies, so that the (faster) operators of our Flag class are used
+    for name in ("__and__", "__or__", "__xor__", "__rand__", "__ror__", "__rxor__"):
+        if name in cls.__dict__:
+            delattr(cls, name)
+
+
 def _fix_alias_members(cls: type[Enum]) -> None:
     # Emulate aenum NoAlias behaviour
     # https://github.com/ethanfurman/aenum/blob/master/aenum/doc/aenum.rst
@@ -204,20 +217,20 @@ class Enum(BaseType, IntEnum, metaclass=EnumMetaType):
             return f"{base}{value}"
 
     def __eq__(self, other: int | Enum) -> bool:
-        if isinstance(other, Enum) and other.__class__ is not self.__class__:
-            return False
-
-        # Python <= 3.10 compatibility
         if isinstance(other, Enum):
-            other = other.value
+            if other.__class__ is not self.__class__:
+                return False
+
+            # Python <= 3.10 compatibility
+            other = other._value_
 
-        return self.value == other
+        return self._value_ == other
 
     def __ne__(self, value: int | Enum) -> bool:
         return not self.__eq__(value)
 
     def __hash__(self) -> int:
-        return hash((self.__class__, self.name, self.value))
+        return hash((self.__class__, self._name_, self._value_))
 
     @classmethod
     def _missing_(cls, value: int) -> Self:

dissect/cstruct/types/flag.py

@@ -1,10 +1,34 @@
 from __future__ import annotations
 
+import operator
+from enum import Flag as _StdFlag
 from enum import IntFlag
+from typing import TYPE_CHECKING
 
 from dissect.cstruct.types.base import BaseType
 from dissect.cstruct.types.enum import PY_311, EnumMetaType
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def _operator(op: Callable[[int, int], int], fallback: Callable[[Flag, int], Flag]) -> Callable[[Flag, int], Flag]:
+    """Create a flag operator with a fast path for integers and flags of the same class."""
+
+    def method(self: Flag, other: int | Flag) -> Flag:
+        if type(other) is self.__class__:
+            value = op(self._value_, other._value_)
+        elif isinstance(other, int) and not isinstance(other, _StdFlag):
+            value = op(self._value_, other)
+        else:
+            return fallback(self, other)
+
+        if (member := self.__class__._value2member_map_.get(value)) is not None:
+            return member
+        return self.__class__(value)
+
+    return method
+
 
 class Flag(BaseType, IntFlag, metaclass=EnumMetaType):
     """Flag type supercharged with cstruct functionality.
@@ -56,17 +80,26 @@ class Flag(BaseType, IntFlag, metaclass=EnumMetaType):
             return result
 
     def __eq__(self, other: int | Flag) -> bool:
-        if isinstance(other, Flag) and other.__class__ is not self.__class__:
-            return False
-
-        # Python <= 3.10 compatibility
         if isinstance(other, Flag):
-            other = other.value
+            if other.__class__ is not self.__class__:
+                return False
+
+            # Python <= 3.10 compatibility
+            other = other._value_
 
-        return self.value == other
+        return self._value_ == other
 
     def __ne__(self, value: int | Flag) -> bool:
         return not self.__eq__(value)
 
     def __hash__(self) -> int:
-        return hash((self.__class__, self.name, self.value))
+        return hash((self.__class__, self._name_, self._value_))
+
+    # Faster implementations of the standard library Flag operators
+    __and__ = _operator(operator.and_, IntFlag.__and__)
+    __or__ = _operator(operator.or_, IntFlag.__or__)
+    __xor__ = _operator(operator.xor, IntFlag.__xor__)
+
+    __rand__ = __and__
+    __ror__ = __or__
+    __rxor__ = __xor__