fox-it__dissect.cstruct-66

{
  "status": "ok",
  "stdout": "64:        raise NotImplementedError(\"Can't add fields to a compiled structure\")\n67:        return '<Structure {name} +compiled>'\n73:    def compile(self, structure: Structure) -> Structure:\n86:        code_object = compile(\n88:            f\"<compiled {structure_name}>\",\n120:                raise TypeError(f\"Unsupported type for compiler: {field_type}\")\n381:                raise TypeError(f\"Couldn't compile a reader for array {field!r}, {field_type!r}.\")\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "    def compile(self, structure: Structure) -> Structure:\n        if isinstance(structure, Union) or structure.align:\n            return structure\n\n        structure_name = structure.name\n\n        try:\n            # Generate struct class based on provided structure type\n            source = self.gen_struct_class(structure_name, structure)\n        except TypeError:\n            return structure\n\n        # Create code object that can be executed later on\n        code_object = compile(\n            source,\n            f\"<compiled {structure_name}>\",\n            \"exec\",\n        )\n\n        env = {\n            \"OrderedDict\": OrderedDict,\n            \"Structure\": Structure,\n            \"Instance\": Instance,\n            \"Expression\": Expression,\n            \"EnumInstance\": EnumInstance,\n            \"FlagInstance\": FlagInstance,\n            \"PointerInstance\": PointerInstance,\n            \"BytesInteger\": BytesInteger,\n            \"BitBuffer\": BitBuffer,\n            \"struct\": struct,\n            \"range\": range,\n        }\n\n        exec(code_object, env)\n        return env[structure_name](self.cstruct, structure, source)\n\n    def gen_struct_class(self, name: str, structure: Structure) -> str:\n        blocks = []\n        classes = []\n        cur_block = []\n        read_size = 0\n        prev_was_bits = False\n\n        for field in structure.fields:\n            field_type = self.cstruct.resolve(field.type)\n\n            if not isinstance(field_type, self.TYPES):\n                raise TypeError(f\"Unsupported type for compiler: {field_type}\")",
  "start_line": 73,
  "end_line": 120,
  "total_lines": 408,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "\n            if isinstance(field_type, Structure) or (\n                isinstance(field_type, Array) and isinstance(field_type.type, (Structure, Array))\n            ):\n                blocks.append(self.gen_read_block(read_size, cur_block))\n\n                struct_read = \"s = stream.tell()\\n\"\n                if isinstance(field_type, Array):\n                    num = field_type.count\n\n                    if isinstance(num, Expression):\n                        num = f\"max(0, Expression(self.cstruct, '{num.expression}').evaluate(r))\"\n\n                    struct_read += dedent(\n                        f\"\"\"\n                        r['{field.name}'] = []\n                        for _ in range({num}):\n                            r['{field.name}'].append(self.lookup['{field.name}'].type.type._read(stream, context=r))\n                        sizes['{field.name}'] = stream.tell() - s\n                        \"\"\"\n                    )\n                elif isinstance(field_type, Structure) and field_type.anonymous:\n                    struct_read += dedent(\n                        f\"\"\"\n                        v = self.lookup[\"{field.name}\"].type._read(stream, context=r)\n                        r.update(v._values)\n                        sizes.update(v._sizes)\n                        \"\"\"\n                    )\n                else:\n                    struct_read += dedent(\n                        f\"\"\"\n                        r['{field.name}'] = self.lookup['{field.name}'].type._read(stream, context=r)\n                        sizes['{field.name}'] = stream.tell() - s\n                        \"\"\"\n                    )\n\n                blocks.append(struct_read)\n                read_size = 0\n                cur_block = []\n                continue\n\n            if field.bits:\n                blocks.append(self.gen_read_block(read_size, cur_block))\n                if isinstance(field_type, Enum):\n                    bitfield_read = dedent(\n                        f\"\"\"\n                        r['{field.name}'] = self.cstruct.{field.type.name}(\n                            bitreader.read(self.cstruct.{field.type.type.name}, {field.bits})\n                        )\n                        \"\"\"\n                    )\n                else:\n                    bitfield_read = f\"r['{field.name}'] = bitreader.read(self.cstruct.{field.type.name}, {field.bits})\"\n                blocks.append(bitfield_read)\n\n                read_size = 0\n                cur_block = []\n                prev_was_bits = True\n                continue\n\n            if prev_was_bits:\n                blocks.append(\"bitreader.reset()\")\n                prev_was_bits = False\n\n            try:\n                count = len(field_type)\n                read_size += count\n                cur_block.append(field)\n            except TypeError:\n                if cur_block:\n                    blocks.append(self.gen_read_block(read_size, cur_block))\n\n                blocks.append(self.gen_dynamic_block(field))\n                read_size = 0\n                cur_block = []\n\n        if len(cur_block):\n            blocks.append(self.gen_read_block(read_size, cur_block))\n\n        read_code = \"\\n\\n\".join(blocks)\n        read_code = \"\\n\".join([\"    \" * 2 + line for line in read_code.split(\"\\n\")])\n\n        classes.append(self.COMPILE_TEMPLATE.format(name=name, read_code=read_code))\n        return \"\\n\\n\".join(classes)\n\n    def gen_read_block(self, size: int, block: List[str]) -> str:\n        template = dedent(\n            f\"\"\"\n            buf = stream.read({size})\n            if len(buf) != {size}: raise EOFError()\n            data = struct.unpack(self.cstruct.endian + '{{}}', buf)\n            {{}}\n            \"\"\"\n        )\n\n        read_code = []\n        fmt = []\n\n        cur_type = None\n        cur_count = 0\n\n        buf_offset = 0\n        data_offset = 0\n\n        for field in block:\n            field_type = self.cstruct.resolve(field.type)\n            read_type = field_type\n\n            count = 1\n            data_count = 1\n\n            if isinstance(read_type, (Enum, Flag)):\n                read_type = read_type.type\n            elif isinstance(read_type, Pointer):\n                read_type = self.cstruct.pointer\n\n            if isinstance(field_type, Array):\n                count = read_type.count\n                data_count = count\n                read_type = read_type.type\n\n                if isinstance(read_type, (Enum, Flag)):\n                    read_type = read_type.type\n                elif isinstance(read_type, Pointer):\n                    read_type = self.cstruct.pointer\n\n                if isinstance(read_type, (CharType, WcharType, BytesInteger)):\n                    read_slice = f\"{buf_offset}:{buf_offset + + (count * read_type.size)}\"\n                else:",
  "start_line": 121,
  "end_line": 250,
  "total_lines": 408,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "from __future__ import annotations\n\nimport struct\nfrom collections import OrderedDict\nfrom textwrap import dedent\nfrom typing import TYPE_CHECKING, List\n\nfrom dissect.cstruct.bitbuffer import BitBuffer\nfrom dissect.cstruct.expression import Expression\nfrom dissect.cstruct.types import (\n    Array,\n    BytesInteger,\n    CharType,\n    Enum,\n    EnumInstance,\n    Field,\n    Flag,\n    FlagInstance,\n    Instance,\n    PackedType,\n    Pointer,\n    PointerInstance,\n    Structure,\n    Union,\n    WcharType,\n)\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass Compiler:\n    \"\"\"Compiler for cstruct structures. Creates somewhat optimized parsing code.\"\"\"\n\n    TYPES = (\n        Structure,\n        Pointer,\n        Enum,\n        Flag,\n        Array,\n        PackedType,\n        CharType,\n        WcharType,\n        BytesInteger,\n    )\n\n    COMPILE_TEMPLATE = \"\"\"\nclass {name}(Structure):\n    def __init__(self, cstruct, structure, source=None):\n        self.structure = structure\n        self.source = source\n        super().__init__(cstruct, structure.name, structure.fields, anonymous=structure.anonymous)\n\n    def _read(self, stream, context=None):\n        r = OrderedDict()\n        sizes = {{}}\n        bitreader = BitBuffer(stream, self.cstruct.endian)\n\n{read_code}\n\n        return Instance(self, r, sizes)\n\n    def add_field(self, name, type_, offset=None):\n        raise NotImplementedError(\"Can't add fields to a compiled structure\")\n\n    def __repr__(self):\n        return '<Structure {name} +compiled>'\n\"\"\"\n\n    def __init__(self, cstruct: cstruct):\n        self.cstruct = cstruct\n\n    def compile(self, structure: Structure) -> Structure:\n        if isinstance(structure, Union) or structure.align:\n            return structure\n\n        structure_name = structure.name\n\n        try:\n            # Generate struct class based on provided structure type\n            source = self.gen_struct_class(structure_name, structure)\n        except TypeError:\n            return structure\n\n        # Create code object that can be executed later on\n        code_object = compile(\n            source,\n            f\"<compiled {structure_name}>\",\n            \"exec\",\n        )\n\n        env = {\n            \"OrderedDict\": OrderedDict,\n            \"Structure\": Structure,\n            \"Instance\": Instance,\n            \"Expression\": Expression,\n            \"EnumInstance\": EnumInstance,\n            \"FlagInstance\": FlagInstance,\n            \"PointerInstance\": PointerInstance,\n            \"BytesInteger\": BytesInteger,\n            \"BitBuffer\": BitBuffer,\n            \"struct\": struct,\n            \"range\": range,\n        }\n\n        exec(code_object, env)\n        return env[structure_name](self.cstruct, structure, source)\n\n    def gen_struct_class(self, name: str, structure: Structure) -> str:\n        blocks = []\n        classes = []\n        cur_block = []\n        read_size = 0\n        prev_was_bits = False\n\n        for field in structure.fields:\n            field_type = self.cstruct.resolve(field.type)\n\n            if not isinstance(field_type, self.TYPES):\n                raise TypeError(f\"Unsupported type for compiler: {field_type}\")\n\n            if isinstance(field_type, Structure) or (\n                isinstance(field_type, Array) and isinstance(field_type.type, (Structure, Array))\n            ):\n                blocks.append(self.gen_read_block(read_size, cur_block))\n\n                struct_read = \"s = stream.tell()\\n\"\n                if isinstance(field_type, Array):\n                    num = field_type.count\n\n                    if isinstance(num, Expression):\n                        num = f\"max(0, Expression(self.cstruct, '{num.expression}').evaluate(r))\"\n\n                    struct_read += dedent(\n                        f\"\"\"\n                        r['{field.name}'] = []\n                        for _ in range({num}):\n                            r['{field.name}'].append(self.lookup['{field.name}'].type.type._read(stream, context=r))\n                        sizes['{field.name}'] = stream.tell() - s\n                        \"\"\"\n                    )\n                elif isinstance(field_type, Structure) and field_type.anonymous:\n                    struct_read += dedent(\n                        f\"\"\"\n                        v = self.lookup[\"{field.name}\"].type._read(stream, context=r)\n                        r.update(v._values)\n                        sizes.update(v._sizes)\n                        \"\"\"\n                    )\n                else:",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 408,
  "is_truncated": true
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 7, in <module>\nAttributeError: type object 'cstruct' has no attribute 'CStruct'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 7, in <module>\nAttributeError: type object 'cstruct' has no attribute 'CStruct'\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/__init__.py",
  "content": "from dissect.cstruct.bitbuffer import BitBuffer\nfrom dissect.cstruct.compiler import Compiler\nfrom dissect.cstruct.cstruct import cstruct, ctypes, ctypes_type\nfrom dissect.cstruct.exceptions import (\n    Error,\n    NullPointerDereference,\n    ParserError,\n    ResolveError,\n)\nfrom dissect.cstruct.expression import Expression\nfrom dissect.cstruct.types.base import Array, BaseType, RawType\nfrom dissect.cstruct.types.bytesinteger import BytesInteger\nfrom dissect.cstruct.types.chartype import CharType\nfrom dissect.cstruct.types.enum import Enum, EnumInstance\nfrom dissect.cstruct.types.flag import Flag, FlagInstance\nfrom dissect.cstruct.types.instance import Instance\nfrom dissect.cstruct.types.packedtype import PackedType\nfrom dissect.cstruct.types.pointer import Pointer, PointerInstance\nfrom dissect.cstruct.types.structure import Field, Structure, Union\nfrom dissect.cstruct.types.voidtype import VoidType\nfrom dissect.cstruct.types.wchartype import WcharType\nfrom dissect.cstruct.utils import (\n    dumpstruct,\n    hexdump,\n    p8,\n    p16,\n    p32,\n    p64,\n    pack,\n    swap,\n    swap16,\n    swap32,\n    swap64,\n    u8,\n    u16,\n    u32,\n    u64,\n    unpack,\n)\n\n__all__ = [\n    \"Compiler\",\n    \"Array\",\n    \"Union\",\n    \"Field\",\n    \"Instance\",\n    \"Structure\",\n    \"Expression\",\n    \"PackedType\",\n    \"Pointer\",\n    \"PointerInstance\",\n    \"VoidType\",\n    \"WcharType\",\n    \"RawType\",\n    \"BaseType\",\n    \"CharType\",\n    \"Enum\",\n    \"EnumInstance\",\n    \"Flag\",\n    \"FlagInstance\",\n    \"BytesInteger\",\n    \"BitBuffer\",\n    \"cstruct\",\n    \"ctypes\",\n    \"ctypes_type\",\n    \"dumpstruct\",\n    \"hexdump\",\n    \"pack\",\n    \"p8\",\n    \"p16\",\n    \"p32\",\n    \"p64\",\n    \"swap\",\n    \"swap16\",\n    \"swap32\",\n    \"swap64\",\n    \"unpack\",\n    \"u8\",\n    \"u16\",\n    \"u32\",\n    \"u64\",\n    \"Error\",\n    \"ParserError\",\n    \"ResolveError\",\n    \"NullPointerDereference\",\n]",
  "start_line": 1,
  "end_line": 86,
  "total_lines": 86,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/cstruct.py",
  "content": "from __future__ import print_function\n\nimport ctypes as _ctypes\nimport sys\nfrom typing import Any, BinaryIO, Optional\n\nfrom dissect.cstruct.exceptions import ResolveError\nfrom dissect.cstruct.parser import CStyleParser, TokenParser\nfrom dissect.cstruct.types import (\n    Array,\n    BaseType,\n    BytesInteger,\n    CharType,\n    PackedType,\n    Pointer,\n    Structure,\n    VoidType,\n    WcharType,\n)\n\n\nclass cstruct:\n    \"\"\"Main class of cstruct. All types are registered in here.\n\n    Args:\n        endian: The endianness to use when parsing.\n        pointer: The pointer type to use for Pointers.\n    \"\"\"\n\n    DEF_CSTYLE = 1\n    DEF_LEGACY = 2\n\n    def __init__(self, endian: str = \"<\", pointer: Optional[str] = None):\n        self.endian = endian\n\n        self.consts = {}\n        self.lookups = {}\n        # fmt: off\n        self.typedefs = {\n            # Internal types\n            \"int8\": PackedType(self, \"int8\", 1, \"b\"),\n            \"uint8\": PackedType(self, \"uint8\", 1, \"B\"),\n            \"int16\": PackedType(self, \"int16\", 2, \"h\"),\n            \"uint16\": PackedType(self, \"uint16\", 2, \"H\"),\n            \"int32\": PackedType(self, \"int32\", 4, \"i\"),\n            \"uint32\": PackedType(self, \"uint32\", 4, \"I\"),\n            \"int64\": PackedType(self, \"int64\", 8, \"q\"),\n            \"uint64\": PackedType(self, \"uint64\", 8, \"Q\"),\n            \"float16\": PackedType(self, \"float16\", 2, \"e\"),\n            \"float\": PackedType(self, \"float\", 4, \"f\"),\n            \"double\": PackedType(self, \"double\", 8, \"d\"),\n            \"char\": CharType(self),\n            \"wchar\": WcharType(self),\n\n            \"int24\": BytesInteger(self, \"int24\", 3, True, alignment=4),\n            \"uint24\": BytesInteger(self, \"uint24\", 3, False, alignment=4),\n            \"int48\": BytesInteger(self, \"int48\", 6, True, alignment=8),\n            \"uint48\": BytesInteger(self, \"uint48\", 6, False, alignment=8),\n            \"int128\": BytesInteger(self, \"int128\", 16, True, alignment=16),\n            \"uint128\": BytesInteger(self, \"uint128\", 16, False, alignment=16),\n\n            \"void\": VoidType(),\n\n            # Common C types not covered by internal types\n            \"signed char\": \"int8\",\n            \"unsigned char\": \"char\",\n            \"short\": \"int16\",\n            \"signed short\": \"short\",\n            \"unsigned short\": \"uint16\",\n            \"int\": \"int32\",\n            \"signed int\": \"int\",\n            \"unsigned int\": \"uint32\",\n            \"long\": \"int32\",\n            \"signed long\": \"long\",\n            \"unsigned long\": \"uint32\",\n            \"long long\": \"int64\",\n            \"signed long long\": \"long long\",\n            \"unsigned long long\": \"uint64\",\n\n            # Windows types\n            \"BYTE\": \"uint8\",\n            \"CHAR\": \"char\",\n            \"SHORT\": \"int16\",\n            \"WORD\": \"uint16\",\n            \"DWORD\": \"uint32\",\n            \"LONG\": \"int32\",\n            \"LONG32\": \"int32\",\n            \"LONG64\": \"int64\",\n            \"LONGLONG\": \"int64\",\n            \"QWORD\": \"uint64\",\n            \"OWORD\": \"uint128\",\n            \"WCHAR\": \"wchar\",\n\n            \"UCHAR\": \"uint8\",\n            \"USHORT\": \"uint16\",\n            \"ULONG\": \"uint32\",\n            \"ULONG64\": \"uint64\",\n            \"ULONGLONG\": \"uint64\",\n\n            \"INT\": \"int\",\n            \"INT8\": \"int8\",\n            \"INT16\": \"int16\",\n            \"INT32\": \"int32\",\n            \"INT64\": \"int64\",\n            \"INT128\": \"int128\",\n\n            \"UINT\": \"uint\",\n            \"UINT8\": \"uint8\",\n            \"UINT16\": \"uint16\",\n            \"UINT32\": \"uint32\",\n            \"UINT64\": \"uint64\",\n            \"UINT128\": \"uint128\",\n\n            \"__int8\": \"int8\",\n            \"__int16\": \"int16\",\n            \"__int32\": \"int32\",\n            \"__int64\": \"int64\",\n            \"__int128\": \"int128\",\n\n            \"wchar_t\": \"wchar\",\n\n            # GNU C types\n            \"int8_t\": \"int8\",\n            \"int16_t\": \"int16\",\n            \"int32_t\": \"int32\",\n            \"int64_t\": \"int64\",\n            \"int128_t\": \"int128\",\n\n            \"uint8_t\": \"uint8\",\n            \"uint16_t\": \"uint16\",\n            \"uint32_t\": \"uint32\",\n            \"uint64_t\": \"uint64\",\n            \"uint128_t\": \"uint128\",\n            \"unsigned __int128\": \"uint128\",\n\n            # Other convenience types\n            \"u1\": \"uint8\",\n            \"u2\": \"uint16\",\n            \"u4\": \"uint32\",\n            \"u8\": \"uint64\",\n            \"u16\": \"uint128\",\n            \"__u8\": \"uint8\",\n            \"__u16\": \"uint16\",\n            \"__u32\": \"uint32\",\n            \"__u64\": \"uint64\",\n            \"uchar\": \"uint8\",\n            \"ushort\": \"unsigned short\",\n            \"uint\": \"unsigned int\",\n            \"ulong\": \"unsigned long\",\n        }",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 305,
  "is_truncated": true
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 9, in <module>\n  File \"/workspace/dissect/cstruct/types/structure.py\", line 47, in __init__\n    for field in self.fields:\nTypeError: 'NoneType' object is not iterable\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 9, in <module>\n  File \"/workspace/dissect/cstruct/types/structure.py\", line 47, in __init__\n    for field in self.fields:\nTypeError: 'NoneType' object is not iterable\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/types/structure.py",
  "content": "from __future__ import annotations\n\nimport io\nfrom collections import OrderedDict\nfrom typing import TYPE_CHECKING, Any, BinaryIO, List\n\nfrom dissect.cstruct.bitbuffer import BitBuffer\nfrom dissect.cstruct.types import BaseType, Enum, Instance\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass Field:\n    \"\"\"Holds a structure field.\"\"\"\n\n    def __init__(self, name: str, type_: BaseType, bits: int = None, offset: int = None):\n        self.name = name\n        self.type = type_\n        self.bits = bits\n        self.offset = offset\n        self.alignment = type_.alignment\n\n    def __repr__(self):\n        bits_str = f\" : {self.bits}\" if self.bits else \"\"\n        return f\"<Field {self.name} {self.type}{bits_str}>\"\n\n\nclass Structure(BaseType):\n    \"\"\"Type class for structures.\"\"\"\n\n    def __init__(\n        self, cstruct: cstruct, name: str, fields: List[Field] = None, align: bool = False, anonymous: bool = False\n    ):\n        super().__init__(cstruct)\n        self.name = name\n        self.size = None\n        self.alignment = None\n\n        self.lookup = OrderedDict()\n        self.fields = fields\n\n        self.align = align\n        self.anonymous = anonymous\n        self.dynamic = False\n\n        for field in self.fields:\n            self.lookup[field.name] = field\n            if isinstance(field.type, Structure) and field.type.anonymous:\n                self.lookup.update(field.type.lookup)\n\n        self._calc_size_and_offsets()\n\n    def __len__(self) -> int:\n        if self.dynamic:\n            raise TypeError(\"Dynamic size\")\n\n        if self.size is None:\n            self._calc_size_and_offsets()\n\n        return self.size\n\n    def __repr__(self) -> str:\n        return f\"<Structure {self.name}>\"\n\n    def _calc_size_and_offsets(self) -> None:\n        \"\"\"Iterate all fields in this structure to calculate the field offsets and total structure size.\n\n        If a structure has a dynamic field, further field offsets will be set to None and self.dynamic\n        will be set to True.\n        \"\"\"\n        # The current offset, set to None if we become dynamic\n        offset = 0\n        # The current alignment for this structure\n        alignment = 0\n\n        # The current bit field type\n        bits_type = None\n        # The offset of the current bit field, set to None if we become dynamic\n        bits_field_offset = 0\n        # How many bits we have left in the current bit field\n        bits_remaining = 0\n\n        for field in self.fields:\n            if field.offset is not None:\n                # If a field already has an offset, it's leading\n                offset = field.offset\n\n            if self.align and offset is not None:\n                # Round to next alignment\n                offset += -offset & (field.alignment - 1)\n\n            # The alignment of this struct is equal to its largest members' alignment\n            alignment = max(alignment, field.type.alignment)\n\n            if field.bits:\n                field_type = field.type\n\n                if isinstance(field_type, Enum):\n                    field_type = field_type.type\n\n                # Bit fields have special logic\n                if (\n                    # Exhausted a bit field\n                    bits_remaining == 0\n                    # Moved to a bit field of another type, e.g. uint16 f1 : 8, uint32 f2 : 8;\n                    or field_type != bits_type\n                    # Still processing a bit field, but it's at a different offset due to alignment or a manual offset\n                    or (bits_type is not None and offset > bits_field_offset + bits_type.size)\n                ):\n                    # ... if any of this is true, we have to move to the next field\n                    bits_type = field_type\n                    bits_count = bits_type.size * 8\n                    bits_remaining = bits_count\n                    bits_field_offset = offset\n\n                    if offset is not None:\n                        # We're not dynamic, update the structure size and current offset\n                        offset += bits_type.size\n\n                    field.offset = bits_field_offset\n\n                bits_remaining -= field.bits\n\n                if bits_remaining < 0:\n                    raise ValueError(\"Straddled bit fields are unsupported\")\n            else:\n                # Reset bits stuff\n                bits_type = None\n                bits_field_offset = bits_remaining = 0\n\n                field.offset = offset\n\n                if offset is not None:\n                    # We're not dynamic, update the structure size and current offset\n                    try:\n                        field_len = len(field.type)\n                    except TypeError:\n                        # This field is dynamic\n                        offset = None\n                        self.dynamic = True\n                        continue\n\n                    offset += field_len\n\n        if self.align and offset is not None:\n            # Add \"tail padding\" if we need to align\n            # This bit magic rounds up to the next alignment boundary\n            # E.g. offset = 3; alignment = 8; -offset & (alignment - 1) = 5\n            offset += -offset & (alignment - 1)",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 376,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "Compiling structure named 'in'...\nCaught expected SyntaxError: invalid syntax (<compiled in>, line 2)\n",
  "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 21, in <module>\n  File \"/workspace/dissect/cstruct/compiler.py\", line 86, in compile\n    code_object = compile(\n  File \"<compiled in>\", line 2\n    class in(Structure):\n          ^^\nSyntaxError: invalid syntax\n",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/types/enum.py",
  "content": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING, Any, BinaryIO, Dict, List, Union\n\nfrom dissect.cstruct.types import BaseType, RawType\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass Enum(RawType):\n    \"\"\"Implements an Enum type.\n\n    Enums can be made using any type. The API for accessing enums and their\n    values is very similar to Python 3 native enums.\n\n    Example:\n        When using the default C-style parser, the following syntax is supported:\n\n            enum <name> [: <type>] {\n                <values>\n            };\n\n        For example, an enum that has A=1, B=5 and C=6 could be written like so:\n\n            enum Test : uint16 {\n                A, B=5, C\n            };\n    \"\"\"\n\n    def __init__(self, cstruct: cstruct, name: str, type_: BaseType, values: Dict[str, int]):\n        self.type = type_\n        self.values = values\n        self.reverse = {}\n\n        for k, v in values.items():\n            self.reverse[v] = k\n\n        super().__init__(cstruct, name, len(self.type), self.type.alignment)\n\n    def __call__(self, value: Union[int, BinaryIO]) -> EnumInstance:\n        if isinstance(value, int):\n            return EnumInstance(self, value)\n        return super().__call__(value)\n\n    def __getitem__(self, attr: str) -> EnumInstance:\n        return self(self.values[attr])\n\n    def __getattr__(self, attr: str) -> EnumInstance:\n        try:\n            return self(self.values[attr])\n        except KeyError:\n            raise AttributeError(attr)\n\n    def __contains__(self, attr: str) -> bool:\n        return attr in self.values\n\n    def _read(self, stream: BinaryIO, context: dict[str, Any] = None) -> EnumInstance:\n        v = self.type._read(stream, context)\n        return self(v)\n\n    def _read_array(self, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> List[EnumInstance]:\n        return list(map(self, self.type._read_array(stream, count, context)))\n\n    def _read_0(self, stream: BinaryIO, context: dict[str, Any] = None) -> List[EnumInstance]:\n        return list(map(self, self.type._read_0(stream, context)))\n\n    def _write(self, stream: BinaryIO, data: Union[int, EnumInstance]) -> int:\n        data = data.value if isinstance(data, EnumInstance) else data\n        return self.type._write(stream, data)\n\n    def _write_array(self, stream: BinaryIO, data: List[Union[int, EnumInstance]]) -> int:\n        data = [d.value if isinstance(d, EnumInstance) else d for d in data]\n        return self.type._write_array(stream, data)\n\n    def _write_0(self, stream: BinaryIO, data: List[Union[int, EnumInstance]]) -> int:\n        data = [d.value if isinstance(d, EnumInstance) else d for d in data]\n        return self.type._write_0(stream, data)\n\n    def default(self) -> EnumInstance:\n        return self(0)\n\n    def default_array(self, count: int) -> List[EnumInstance]:\n        return [self.default() for _ in range(count)]\n\n\nclass EnumInstance:\n    \"\"\"Implements a value instance of an Enum\"\"\"\n\n    def __init__(self, enum: Enum, value: int):\n        self.enum = enum\n        self.value = value\n\n    def __eq__(self, value: Union[int, EnumInstance]) -> bool:\n        if isinstance(value, EnumInstance) and value.enum is not self.enum:\n            return False\n\n        if hasattr(value, \"value\"):\n            value = value.value\n\n        return self.value == value\n\n    def __ne__(self, value: Union[int, EnumInstance]) -> bool:\n        return self.__eq__(value) is False\n\n    def __hash__(self) -> int:\n        return hash((self.enum, self.value))\n\n    def __str__(self) -> str:\n        return f\"{self.enum.name}.{self.name}\"\n\n    def __int__(self) -> int:\n        return self.value\n\n    def __repr__(self) -> str:\n        name = f\"{self.enum.name}.{self.name}\" if self.enum.name else self.name\n        return f\"<{name}: {self.value}>\"\n\n    @property\n    def name(self) -> str:\n        if self.value not in self.enum.reverse:\n            return f\"{self.enum.name}_{self.value}\"\n\n        return self.enum.reverse[self.value]",
  "start_line": 1,
  "end_line": 124,
  "total_lines": 124,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/cstruct.py",
  "content": "from __future__ import print_function\n\nimport ctypes as _ctypes\nimport sys\nfrom typing import Any, BinaryIO, Optional\n\nfrom dissect.cstruct.exceptions import ResolveError\nfrom dissect.cstruct.parser import CStyleParser, TokenParser\nfrom dissect.cstruct.types import (\n    Array,\n    BaseType,\n    BytesInteger,\n    CharType,\n    PackedType,\n    Pointer,\n    Structure,\n    VoidType,\n    WcharType,\n)\n\n\nclass cstruct:\n    \"\"\"Main class of cstruct. All types are registered in here.\n\n    Args:\n        endian: The endianness to use when parsing.\n        pointer: The pointer type to use for Pointers.\n    \"\"\"\n\n    DEF_CSTYLE = 1\n    DEF_LEGACY = 2\n\n    def __init__(self, endian: str = \"<\", pointer: Optional[str] = None):\n        self.endian = endian\n\n        self.consts = {}\n        self.lookups = {}\n        # fmt: off\n        self.typedefs = {\n            # Internal types\n            \"int8\": PackedType(self, \"int8\", 1, \"b\"),\n            \"uint8\": PackedType(self, \"uint8\", 1, \"B\"),\n            \"int16\": PackedType(self, \"int16\", 2, \"h\"),\n            \"uint16\": PackedType(self, \"uint16\", 2, \"H\"),\n            \"int32\": PackedType(self, \"int32\", 4, \"i\"),\n            \"uint32\": PackedType(self, \"uint32\", 4, \"I\"),\n            \"int64\": PackedType(self, \"int64\", 8, \"q\"),\n            \"uint64\": PackedType(self, \"uint64\", 8, \"Q\"),\n            \"float16\": PackedType(self, \"float16\", 2, \"e\"),\n            \"float\": PackedType(self, \"float\", 4, \"f\"),\n            \"double\": PackedType(self, \"double\", 8, \"d\"),\n            \"char\": CharType(self),\n            \"wchar\": WcharType(self),\n\n            \"int24\": BytesInteger(self, \"int24\", 3, True, alignment=4),\n            \"uint24\": BytesInteger(self, \"uint24\", 3, False, alignment=4),\n            \"int48\": BytesInteger(self, \"int48\", 6, True, alignment=8),\n            \"uint48\": BytesInteger(self, \"uint48\", 6, False, alignment=8),\n            \"int128\": BytesInteger(self, \"int128\", 16, True, alignment=16),\n            \"uint128\": BytesInteger(self, \"uint128\", 16, False, alignment=16),\n\n            \"void\": VoidType(),\n\n            # Common C types not covered by internal types\n            \"signed char\": \"int8\",\n            \"unsigned char\": \"char\",\n            \"short\": \"int16\",\n            \"signed short\": \"short\",\n            \"unsigned short\": \"uint16\",\n            \"int\": \"int32\",\n            \"signed int\": \"int\",\n            \"unsigned int\": \"uint32\",\n            \"long\": \"int32\",\n            \"signed long\": \"long\",\n            \"unsigned long\": \"uint32\",\n            \"long long\": \"int64\",\n            \"signed long long\": \"long long\",\n            \"unsigned long long\": \"uint64\",\n\n            # Windows types\n            \"BYTE\": \"uint8\",\n            \"CHAR\": \"char\",\n            \"SHORT\": \"int16\",\n            \"WORD\": \"uint16\",\n            \"DWORD\": \"uint32\",\n            \"LONG\": \"int32\",\n            \"LONG32\": \"int32\",\n            \"LONG64\": \"int64\",\n            \"LONGLONG\": \"int64\",\n            \"QWORD\": \"uint64\",\n            \"OWORD\": \"uint128\",\n            \"WCHAR\": \"wchar\",\n\n            \"UCHAR\": \"uint8\",\n            \"USHORT\": \"uint16\",\n            \"ULONG\": \"uint32\",\n            \"ULONG64\": \"uint64\",\n            \"ULONGLONG\": \"uint64\",\n\n            \"INT\": \"int\",\n            \"INT8\": \"int8\",\n            \"INT16\": \"int16\",\n            \"INT32\": \"int32\",\n            \"INT64\": \"int64\",\n            \"INT128\": \"int128\",\n\n            \"UINT\": \"uint\",\n            \"UINT8\": \"uint8\",\n            \"UINT16\": \"uint16\",\n            \"UINT32\": \"uint32\",\n            \"UINT64\": \"uint64\",\n            \"UINT128\": \"uint128\",\n\n            \"__int8\": \"int8\",\n            \"__int16\": \"int16\",\n            \"__int32\": \"int32\",\n            \"__int64\": \"int64\",\n            \"__int128\": \"int128\",\n\n            \"wchar_t\": \"wchar\",\n\n            # GNU C types\n            \"int8_t\": \"int8\",\n            \"int16_t\": \"int16\",\n            \"int32_t\": \"int32\",\n            \"int64_t\": \"int64\",\n            \"int128_t\": \"int128\",\n\n            \"uint8_t\": \"uint8\",\n            \"uint16_t\": \"uint16\",\n            \"uint32_t\": \"uint32\",\n            \"uint64_t\": \"uint64\",\n            \"uint128_t\": \"uint128\",\n            \"unsigned __int128\": \"uint128\",\n\n            # Other convenience types\n            \"u1\": \"uint8\",\n            \"u2\": \"uint16\",\n            \"u4\": \"uint32\",\n            \"u8\": \"uint64\",\n            \"u16\": \"uint128\",\n            \"__u8\": \"uint8\",\n            \"__u16\": \"uint16\",\n            \"__u32\": \"uint32\",\n            \"__u64\": \"uint64\",\n            \"uchar\": \"uint8\",\n            \"ushort\": \"unsigned short\",\n            \"uint\": \"unsigned int\",\n            \"ulong\": \"unsigned long\",\n        }",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 305,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "57:        bitreader = BitBuffer(stream, self.cstruct.endian)\n117:            field_type = self.cstruct.resolve(field.type)\n168:                        r['{field.name}'] = self.cstruct.{field.type.name}(\n169:                            bitreader.read(self.cstruct.{field.type.type.name}, {field.bits})\n174:                    bitfield_read = f\"r['{field.name}'] = bitreader.read(self.cstruct.{field.type.name}, {field.bits})\"\n212:            data = struct.unpack(self.cstruct.endian + '{{}}', buf)\n227:            field_type = self.cstruct.resolve(field.type)\n236:                read_type = self.cstruct.pointer\n246:                    read_type = self.cstruct.pointer\n283:                getter = \"BytesInteger.parse(buf[{slice}], {size}, {count}, {signed}, self.cstruct.endian){data_slice}\"\n296:                    getter += \".decode('utf-16-le' if self.cstruct.endian == '<' else 'utf-16-be')\"\n302:                getter = f\"{enum_type}Instance(self.cstruct.{field_type.name}, {getter})\"\n305:                getter = f\"[{enum_type}Instance(self.cstruct.{field_type.type.name}, d) for d in {getter}]\"\n307:                getter = f\"PointerInstance(self.cstruct.{field_type.type.name}, stream, {getter}, r)\"\n309:                getter = f\"[PointerInstance(self.cstruct.{field_type.type.type.name}, stream, d, r) for d in {getter}]\"\n328:        field_type = self.cstruct.resolve(field.type.type)\n342:                        v = struct.unpack(self.cstruct.endian + '{field_type.packchar}', d)[0]\n362:                    reader += \".decode('utf-16-le' if self.cstruct.endian == '<' else 'utf-16-be')\"\n370:                        v = BytesInteger.parse(d, {field_type.size}, 1, {field_type.signed}, self.cstruct.endian)\n378:                reader += f\"\\nt = [{enum_type}Instance(self.cstruct.{field_type.name}, d) for d in t]\"\n396:            reader = f\"list(struct.unpack(self.cstruct.endian + f'{{dynsize}}{field_type.packchar}', buf))\"\n400:                reader += \".decode('utf-16-le' if self.cstruct.endian == '<' else 'utf-16-be')\"\n402:            reader = f\"BytesInteger.parse(buf, {field_type.size}, dynsize, {field_type.signed}, self.cstruct.endian)\"\n406:            reader += f\"[{enum_type}Instance(self.cstruct.{field_type.name}, d) for d in {reader}]\"\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/types/base.py",
  "content": "from __future__ import annotations\n\nfrom io import BytesIO\nfrom typing import TYPE_CHECKING, Any, BinaryIO, List\n\nfrom dissect.cstruct.exceptions import ArraySizeError\nfrom dissect.cstruct.expression import Expression\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass BaseType:\n    \"\"\"Base class for cstruct type classes.\"\"\"\n\n    def __init__(self, cstruct: cstruct):\n        self.cstruct = cstruct\n\n    def __getitem__(self, count: int) -> Array:\n        return Array(self.cstruct, self, count)\n\n    def __call__(self, *args, **kwargs) -> Any:\n        if len(args) > 0:\n            return self.read(*args, **kwargs)\n\n        result = self.default()\n        if kwargs:\n            for k, v in kwargs.items():\n                setattr(result, k, v)\n\n        return result\n\n    def reads(self, data: bytes) -> Any:\n        \"\"\"Parse the given data according to the type that implements this class.\n\n        Args:\n            data: Byte string to parse.\n\n        Returns:\n            The parsed value of this type.\n        \"\"\"\n\n        return self._read(BytesIO(data))\n\n    def dumps(self, data: Any) -> bytes:\n        \"\"\"Dump the given data according to the type that implements this class.\n\n        Args:\n            data: Data to dump.\n\n        Returns:\n            The resulting bytes.\n\n        Raises:\n            ArraySizeError: Raised when ``len(data)`` does not match the size of a statically sized array field.\n        \"\"\"\n        out = BytesIO()\n        self._write(out, data)\n        return out.getvalue()\n\n    def read(self, obj: BinaryIO, *args, **kwargs) -> Any:\n        \"\"\"Parse the given data according to the type that implements this class.\n\n        Args:\n            obj: Data to parse. Can be a (byte) string or a file-like object.\n\n        Returns:\n            The parsed value of this type.\n        \"\"\"\n        if isinstance(obj, (bytes, memoryview, bytearray)):\n            return self.reads(obj)\n\n        return self._read(obj)\n\n    def write(self, stream: BinaryIO, data: Any) -> int:\n        \"\"\"Write the given data to a writable file-like object according to the\n        type that implements this class.\n\n        Args:\n            stream: Writable file-like object to write to.\n            data: Data to write.\n\n        Returns:\n            The amount of bytes written.\n\n        Raises:\n            ArraySizeError: Raised when ``len(data)`` does not match the size of a statically sized array field.\n        \"\"\"\n        return self._write(stream, data)\n\n    def _read(self, stream: BinaryIO, context: dict[str, Any] = None) -> Any:\n        raise NotImplementedError()\n\n    def _read_array(self, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> List[Any]:\n        return [self._read(stream, context) for _ in range(count)]\n\n    def _read_0(self, stream: BinaryIO, context: dict[str, Any] = None) -> List[Any]:\n        raise NotImplementedError()\n\n    def _write(self, stream: BinaryIO, data: Any) -> int:\n        raise NotImplementedError()\n\n    def _write_array(self, stream: BinaryIO, data: Any) -> int:\n        num = 0\n        for i in data:\n            num += self._write(stream, i)\n\n        return num\n\n    def _write_0(self, stream: BinaryIO, data: Any) -> int:\n        raise NotImplementedError()\n\n    def default(self) -> Any:\n        \"\"\"Return a default value of this type.\"\"\"\n        raise NotImplementedError()\n\n    def default_array(self, count: int) -> List[Any]:\n        \"\"\"Return a default array of this type.\"\"\"\n        return [self.default() for _ in range(count)]\n\n\nclass Array(BaseType):\n    \"\"\"Implements a fixed or dynamically sized array type.\n\n    Example:\n        When using the default C-style parser, the following syntax is supported:\n\n            x[3] -> 3 -> static length.\n            x[] -> None -> null-terminated.\n            x[expr] -> expr -> dynamic length.\n    \"\"\"\n\n    def __init__(self, cstruct: cstruct, type_: BaseType, count: int):\n        self.type = type_\n        self.count = count\n        self.null_terminated = self.count is None\n        self.dynamic = isinstance(self.count, Expression)\n        self.alignment = type_.alignment\n        super().__init__(cstruct)\n\n    def __repr__(self) -> str:\n        if self.null_terminated:\n            return f\"{self.type}[]\"\n\n        return f\"{self.type}[{self.count}]\"\n\n    def __len__(self) -> int:\n        if self.dynamic or self.null_terminated:\n            raise TypeError(\"Dynamic size\")\n",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 209,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/types/structure.py",
  "content": "from __future__ import annotations\n\nimport io\nfrom collections import OrderedDict\nfrom typing import TYPE_CHECKING, Any, BinaryIO, List\n\nfrom dissect.cstruct.bitbuffer import BitBuffer\nfrom dissect.cstruct.types import BaseType, Enum, Instance\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass Field:\n    \"\"\"Holds a structure field.\"\"\"\n\n    def __init__(self, name: str, type_: BaseType, bits: int = None, offset: int = None):\n        self.name = name\n        self.type = type_\n        self.bits = bits\n        self.offset = offset\n        self.alignment = type_.alignment\n\n    def __repr__(self):\n        bits_str = f\" : {self.bits}\" if self.bits else \"\"\n        return f\"<Field {self.name} {self.type}{bits_str}>\"\n\n\nclass Structure(BaseType):\n    \"\"\"Type class for structures.\"\"\"\n\n    def __init__(\n        self, cstruct: cstruct, name: str, fields: List[Field] = None, align: bool = False, anonymous: bool = False\n    ):\n        super().__init__(cstruct)\n        self.name = name\n        self.size = None\n        self.alignment = None\n\n        self.lookup = OrderedDict()\n        self.fields = fields\n\n        self.align = align\n        self.anonymous = anonymous\n        self.dynamic = False\n\n        for field in self.fields:\n            self.lookup[field.name] = field\n            if isinstance(field.type, Structure) and field.type.anonymous:\n                self.lookup.update(field.type.lookup)\n\n        self._calc_size_and_offsets()\n\n    def __len__(self) -> int:\n        if self.dynamic:\n            raise TypeError(\"Dynamic size\")\n\n        if self.size is None:\n            self._calc_size_and_offsets()\n\n        return self.size\n\n    def __repr__(self) -> str:\n        return f\"<Structure {self.name}>\"\n\n    def _calc_size_and_offsets(self) -> None:\n        \"\"\"Iterate all fields in this structure to calculate the field offsets and total structure size.\n\n        If a structure has a dynamic field, further field offsets will be set to None and self.dynamic\n        will be set to True.\n        \"\"\"\n        # The current offset, set to None if we become dynamic\n        offset = 0\n        # The current alignment for this structure\n        alignment = 0\n\n        # The current bit field type\n        bits_type = None\n        # The offset of the current bit field, set to None if we become dynamic\n        bits_field_offset = 0\n        # How many bits we have left in the current bit field\n        bits_remaining = 0\n\n        for field in self.fields:\n            if field.offset is not None:\n                # If a field already has an offset, it's leading\n                offset = field.offset\n\n            if self.align and offset is not None:\n                # Round to next alignment\n                offset += -offset & (field.alignment - 1)\n\n            # The alignment of this struct is equal to its largest members' alignment\n            alignment = max(alignment, field.type.alignment)\n\n            if field.bits:\n                field_type = field.type\n\n                if isinstance(field_type, Enum):\n                    field_type = field_type.type\n\n                # Bit fields have special logic\n                if (\n                    # Exhausted a bit field\n                    bits_remaining == 0\n                    # Moved to a bit field of another type, e.g. uint16 f1 : 8, uint32 f2 : 8;\n                    or field_type != bits_type\n                    # Still processing a bit field, but it's at a different offset due to alignment or a manual offset\n                    or (bits_type is not None and offset > bits_field_offset + bits_type.size)\n                ):\n                    # ... if any of this is true, we have to move to the next field\n                    bits_type = field_type\n                    bits_count = bits_type.size * 8\n                    bits_remaining = bits_count\n                    bits_field_offset = offset\n\n                    if offset is not None:\n                        # We're not dynamic, update the structure size and current offset\n                        offset += bits_type.size\n\n                    field.offset = bits_field_offset\n\n                bits_remaining -= field.bits\n\n                if bits_remaining < 0:\n                    raise ValueError(\"Straddled bit fields are unsupported\")\n            else:\n                # Reset bits stuff\n                bits_type = None\n                bits_field_offset = bits_remaining = 0\n\n                field.offset = offset\n\n                if offset is not None:\n                    # We're not dynamic, update the structure size and current offset\n                    try:\n                        field_len = len(field.type)\n                    except TypeError:\n                        # This field is dynamic\n                        offset = None\n                        self.dynamic = True\n                        continue\n\n                    offset += field_len\n\n        if self.align and offset is not None:\n            # Add \"tail padding\" if we need to align\n            # This bit magic rounds up to the next alignment boundary\n            # E.g. offset = 3; alignment = 8; -offset & (alignment - 1) = 5\n            offset += -offset & (alignment - 1)",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 376,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/parser.py",
  "content": "from __future__ import annotations\n\nimport ast\nimport re\nfrom typing import TYPE_CHECKING, Dict, List\n\nfrom dissect.cstruct.compiler import Compiler\nfrom dissect.cstruct.exceptions import ParserError\nfrom dissect.cstruct.expression import Expression\nfrom dissect.cstruct.types import Array, Enum, Field, Flag, Pointer, Structure, Union\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass Parser:\n    \"\"\"Base class for definition parsers.\n\n    Args:\n        cs: An instance of cstruct.\n    \"\"\"\n\n    def __init__(self, cs: cstruct):\n        self.cstruct = cs\n\n    def parse(self, data: str) -> None:\n        \"\"\"This function should parse definitions to cstruct types.\n\n        Args:\n            data: Data to parse definitions from, usually a string.\n        \"\"\"\n        raise NotImplementedError()\n\n\nclass TokenParser(Parser):\n    \"\"\"\n    Args:\n        cs: An instance of cstruct.\n        compiled: Whether structs should be compiled or not.\n    \"\"\"\n\n    def __init__(self, cs: cstruct, compiled: bool = True, align: bool = False):\n        super().__init__(cs)\n\n        self.compiler = Compiler(self.cstruct) if compiled else None\n        self.align = align\n        self.TOK = self._tokencollection()\n\n    @staticmethod\n    def _tokencollection() -> TokenCollection:\n        TOK = TokenCollection()\n        TOK.add(r\"#\\[(?P<values>[^\\]]+)\\](?=\\s*)\", \"CONFIG_FLAG\")\n        TOK.add(r\"#define\\s+(?P<name>[^\\s]+)\\s+(?P<value>[^\\r\\n]+)\\s*\", \"DEFINE\")\n        TOK.add(r\"typedef(?=\\s)\", \"TYPEDEF\")\n        TOK.add(r\"(?:struct|union)(?=\\s|{)\", \"STRUCT\")\n        TOK.add(\n            r\"(?P<enumtype>enum|flag)\\s+(?P<name>[^\\s:{]+)?\\s*(:\\s\"\n            r\"*(?P<type>[^{]+?)\\s*)?\\{(?P<values>[^}]+)\\}\\s*(?=;)\",\n            \"ENUM\",\n        )\n        TOK.add(r\"(?<=})\\s*(?P<defs>(?:[a-zA-Z0-9_]+\\s*,\\s*)+[a-zA-Z0-9_]+)\\s*(?=;)\", \"DEFS\")\n        TOK.add(r\"(?P<name>\\*?[a-zA-Z0-9_]+)(?:\\s*:\\s*(?P<bits>\\d+))?(?:\\[(?P<count>[^;\\n]*)\\])?\\s*(?=;)\", \"NAME\")\n        TOK.add(r\"[a-zA-Z_][a-zA-Z0-9_]*\", \"IDENTIFIER\")\n        TOK.add(r\"[{}]\", \"BLOCK\")\n        TOK.add(r\"\\$(?P<name>[^\\s]+) = (?P<value>{[^}]+})\\w*[\\r\\n]+\", \"LOOKUP\")\n        TOK.add(r\";\", \"EOL\")\n        TOK.add(r\"\\s+\", None)\n        TOK.add(r\".\", None)\n\n        return TOK\n\n    def _identifier(self, tokens: TokenConsumer) -> str:\n        idents = []\n        while tokens.next == self.TOK.IDENTIFIER:\n            idents.append(tokens.consume())\n        return \" \".join([i.value for i in idents])\n\n    def _constant(self, tokens: TokenConsumer) -> None:\n        const = tokens.consume()\n        pattern = self.TOK.patterns[self.TOK.DEFINE]\n        match = pattern.match(const.value).groupdict()\n\n        value = match[\"value\"]\n        try:\n            value = ast.literal_eval(value)\n        except (ValueError, SyntaxError):\n            pass\n\n        try:\n            value = Expression(self.cstruct, value).evaluate()\n        except Exception:\n            pass\n\n        self.cstruct.consts[match[\"name\"]] = value\n\n    def _enum(self, tokens: TokenConsumer) -> None:\n        # We cheat with enums because the entire enum is in the token\n        etok = tokens.consume()\n\n        pattern = self.TOK.patterns[self.TOK.ENUM]\n        # Dirty trick because the regex expects a ; but we don't want it to be part of the value\n        d = pattern.match(etok.value + \";\").groupdict()\n        enumtype = d[\"enumtype\"]\n\n        nextval = 0\n        if enumtype == \"flag\":\n            nextval = 1\n\n        values = {}\n        for line in d[\"values\"].splitlines():\n            for v in line.split(\",\"):\n                key, sep, val = v.partition(\"=\")\n                key = key.strip()\n                val = val.strip()\n                if not key:\n                    continue\n                if not val:\n                    val = nextval\n                else:\n                    val = Expression(self.cstruct, val).evaluate(values)\n\n                if enumtype == \"flag\":\n                    high_bit = val.bit_length() - 1\n                    nextval = 2 ** (high_bit + 1)\n                else:\n                    nextval = val + 1\n\n                values[key] = val\n\n        if not d[\"type\"]:\n            d[\"type\"] = \"uint32\"\n\n        enumcls = Enum\n        if enumtype == \"flag\":\n            enumcls = Flag\n\n        enum = enumcls(self.cstruct, d[\"name\"], self.cstruct.resolve(d[\"type\"]), values)\n\n        if not enum.name:\n            for name, value in enum.values.items():\n                self.cstruct.consts[name] = enum(value)\n        else:\n            self.cstruct.addtype(enum.name, enum)\n\n        tokens.eol()\n\n    def _typedef(self, tokens: TokenConsumer) -> None:\n        tokens.consume()\n        type_ = None\n",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 593,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "175:    def addtype(self, name: str, type_: BaseType, replace: bool = False) -> None:\n",
  "stderr": "",
  "exit_code": 0
}