fox-it__dissect.cstruct-66

{
  "status": "ok",
  "stdout": "73:    def compile(self, structure: Structure) -> Structure:\n86:        code_object = compile(\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "        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 = []",
  "start_line": 50,
  "end_line": 110,
  "total_lines": 408,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "        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:\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",
  "start_line": 111,
  "end_line": 200,
  "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": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "        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:\n                    read_slice = f\"{data_offset}:{data_offset + count}\"\n            elif isinstance(read_type, CharType):\n                read_slice = f\"{buf_offset}:{buf_offset + 1}\"\n            elif isinstance(read_type, (WcharType, BytesInteger)):\n                read_slice = f\"{buf_offset}:{buf_offset + read_type.size}\"\n            else:\n                read_slice = str(data_offset)\n\n            if not cur_type:\n                if isinstance(read_type, PackedType):\n                    cur_type = read_type.packchar\n                else:\n                    cur_type = \"x\"\n\n            if isinstance(read_type, (PackedType, CharType, WcharType, BytesInteger, Enum, Flag)):\n                char_count = count\n\n                if isinstance(read_type, (CharType, WcharType, BytesInteger)):\n                    data_count = 0\n                    pack_char = \"x\"\n                    char_count *= read_type.size\n                else:\n                    pack_char = read_type.packchar\n\n                if cur_type != pack_char:\n                    fmt.append(f\"{cur_count}{cur_type}\")\n                    cur_count = 0\n\n                cur_count += char_count\n                cur_type = pack_char\n\n            if isinstance(read_type, BytesInteger):\n                getter = \"BytesInteger.parse(buf[{slice}], {size}, {count}, {signed}, self.cstruct.endian){data_slice}\"\n\n                getter = getter.format(\n                    slice=read_slice,\n                    size=read_type.size,\n                    count=count,\n                    signed=read_type.signed,\n                    data_slice=\"[0]\" if count == 1 else \"\",\n                )\n            elif isinstance(read_type, (CharType, WcharType)):\n                getter = f\"buf[{read_slice}]\"\n\n                if isinstance(read_type, WcharType):\n                    getter += \".decode('utf-16-le' if self.cstruct.endian == '<' else 'utf-16-be')\"\n            else:\n                getter = f\"data[{read_slice}]\"\n\n            if isinstance(field_type, (Enum, Flag)):\n                enum_type = field_type.__class__.__name__\n                getter = f\"{enum_type}Instance(self.cstruct.{field_type.name}, {getter})\"\n            elif isinstance(field_type, Array) and isinstance(field_type.type, (Enum, Flag)):\n                enum_type = field_type.type.__class__.__name__\n                getter = f\"[{enum_type}Instance(self.cstruct.{field_type.type.name}, d) for d in {getter}]\"\n            elif isinstance(field_type, Pointer):\n                getter = f\"PointerInstance(self.cstruct.{field_type.type.name}, stream, {getter}, r)\"\n            elif isinstance(field_type, Array) and isinstance(field_type.type, Pointer):\n                getter = f\"[PointerInstance(self.cstruct.{field_type.type.type.name}, stream, d, r) for d in {getter}]\"\n            elif isinstance(field_type, Array) and isinstance(read_type, PackedType):\n                getter = f\"list({getter})\"\n\n            read_code.append(f\"r['{field.name}'] = {getter}\")\n            read_code.append(f\"sizes['{field.name}'] = {count * read_type.size}\")\n\n            data_offset += data_count\n            buf_offset += count * read_type.size\n\n        if cur_count:\n            fmt.append(f\"{cur_count}{cur_type}\")\n\n        return template.format(\"\".join(fmt), \"\\n\".join(read_code))\n\n    def gen_dynamic_block(self, field: Field) -> str:\n        if not isinstance(field.type, Array):\n            raise TypeError(f\"Only Array can be dynamic, got {field.type!r}\")\n\n        field_type = self.cstruct.resolve(field.type.type)\n        reader = None\n\n        if isinstance(field_type, (Enum, Flag)):\n            field_type = field_type.type\n\n        if not field.type.count:  # Null terminated\n            if isinstance(field_type, PackedType):\n                reader = dedent(\n                    f\"\"\"\n                    t = []\n                    while True:\n                        d = stream.read({field_type.size})\n                        if len(d) != {field_type.size}: raise EOFError()\n                        v = struct.unpack(self.cstruct.endian + '{field_type.packchar}', d)[0]\n                        if v == 0: break\n                        t.append(v)\n                    \"\"\"\n                )\n\n            elif isinstance(field_type, (CharType, WcharType)):\n                null = \"\\\\x00\" * field_type.size\n                reader = dedent(",
  "start_line": 201,
  "end_line": 350,
  "total_lines": 408,
  "is_truncated": true
}

{
  "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": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 5, in <module>\nTypeError: BytesInteger.__init__() missing 3 required positional arguments: 'name', 'size', and 'signed'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 5, in <module>\nTypeError: BytesInteger.__init__() missing 3 required positional arguments: 'name', 'size', and 'signed'\n",
    "exit_code": 1
  }
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, in <module>\nTypeError: BytesInteger.__init__() missing 1 required positional argument: 'signed'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, in <module>\nTypeError: BytesInteger.__init__() missing 1 required positional argument: 'signed'\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/types/bytesinteger.py",
  "content": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING, Any, BinaryIO, List\n\nfrom dissect.cstruct.types import RawType\n\nif TYPE_CHECKING:\n    from dissect.cstruct import cstruct\n\n\nclass BytesInteger(RawType):\n    \"\"\"Implements an integer type that can span an arbitrary amount of bytes.\"\"\"\n\n    def __init__(self, cstruct: cstruct, name: str, size: int, signed: bool, alignment: int = None):\n        self.signed = signed\n        super().__init__(cstruct, name, size, alignment)\n\n    @staticmethod\n    def parse(buf: BinaryIO, size: int, count: int, signed: bool, endian: str) -> List[int]:\n        nums = []\n\n        for c in range(count):\n            num = 0\n            data = buf[c * size : (c + 1) * size]\n            if endian == \"<\":  # little-endian (LE)\n                data = b\"\".join(data[i : i + 1] for i in reversed(range(len(data))))\n\n            ints = list(data)\n            for i in ints:\n                num = (num << 8) | i\n\n            if signed and (num & (1 << (size * 8 - 1))):\n                bias = 1 << (size * 8 - 1)\n                num -= bias * 2\n\n            nums.append(num)\n\n        return nums\n\n    @staticmethod\n    def pack(data: List[int], size: int, endian: str, signed: bool) -> bytes:\n        buf = []\n\n        bits = size * 8\n        unsigned_min = 0\n        unsigned_max = (2**bits) - 1\n        signed_min = -(2 ** (bits - 1))\n        signed_max = (2 ** (bits - 1)) - 1\n\n        for i in data:\n            if signed and (i < signed_min or i > signed_max):\n                raise OverflowError(f\"{i} exceeds bounds for signed {bits} bits BytesInteger\")\n            elif not signed and (i < unsigned_min or i > unsigned_max):\n                raise OverflowError(f\"{i} exceeds bounds for unsigned {bits} bits BytesInteger\")\n\n            num = int(i)\n            if num < 0:\n                num += 1 << (size * 8)\n\n            d = [b\"\\x00\"] * size\n            i = size - 1\n\n            while i >= 0:\n                b = num & 255\n                d[i] = bytes((b,))\n                num >>= 8\n                i -= 1\n\n            if endian == \"<\":\n                d = b\"\".join(d[i : i + 1][0] for i in reversed(range(len(d))))\n            else:\n                d = b\"\".join(d)\n\n            buf.append(d)\n\n        return b\"\".join(buf)\n\n    def _read(self, stream: BinaryIO, context: dict[str, Any] = None) -> int:\n        return self.parse(stream.read(self.size * 1), self.size, 1, self.signed, self.cstruct.endian)[0]\n\n    def _read_array(self, stream: BinaryIO, count: int, context: dict[str, Any] = None) -> List[int]:\n        return self.parse(\n            stream.read(self.size * count),\n            self.size,\n            count,\n            self.signed,\n            self.cstruct.endian,\n        )\n\n    def _read_0(self, stream: BinaryIO, context: dict[str, Any] = None) -> List[int]:\n        result = []\n\n        while True:\n            v = self._read(stream, context)\n            if v == 0:\n                break\n\n            result.append(v)\n\n        return result\n\n    def _write(self, stream: BinaryIO, data: int) -> int:\n        return stream.write(self.pack([data], self.size, self.cstruct.endian, self.signed))\n\n    def _write_array(self, stream: BinaryIO, data: List[int]) -> int:\n        return stream.write(self.pack(data, self.size, self.cstruct.endian, self.signed))\n\n    def _write_0(self, stream: BinaryIO, data: List[int]) -> int:\n        return self._write_array(stream, data + [0])\n\n    def default(self) -> int:\n        return 0\n\n    def default_array(self, count: int) -> List[int]:\n        return [0] * count",
  "start_line": 1,
  "end_line": 115,
  "total_lines": 115,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 6, 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 6, 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",
  "start_line": 1,
  "end_line": 100,
  "total_lines": 376,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 7, in <module>\n  File \"/workspace/dissect/cstruct/cstruct.py\", line 168, in __getattr__\n    raise AttributeError(f\"Invalid attribute: {attr}\")\nAttributeError: Invalid attribute: add\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 7, in <module>\n  File \"/workspace/dissect/cstruct/cstruct.py\", line 168, in __getattr__\n    raise AttributeError(f\"Invalid attribute: {attr}\")\nAttributeError: Invalid attribute: add\n",
    "exit_code": 1
  }
}

{
  "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": "33:    def __init__(self, endian: str = \"<\", pointer: Optional[str] = None):\n157:    def __getattr__(self, attr: str) -> Any:\n170:    def _next_anonymous(self) -> str:\n175:    def addtype(self, name: str, type_: BaseType, replace: bool = False) -> None:\n191:    def load(self, definition: str, deftype: int = None, **kwargs) -> \"cstruct\":\n217:    def loadfile(self, path: str, deftype: int = None, **kwargs) -> None:\n230:    def read(self, name: str, stream: BinaryIO) -> Any:\n242:    def resolve(self, name: str) -> BaseType:\n273:def ctypes(structure: Structure) -> _ctypes.Structure:\n284:def ctypes_type(type_: BaseType) -> Any:\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "Caught expected SyntaxError: invalid syntax (<compiled in>, line 2)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "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": "ok",
  "stdout": "109:    def gen_struct_class(self, name: str, structure: Structure) -> str:\n207:    def gen_read_block(self, size: int, block: List[str]) -> str:\n324:    def gen_dynamic_block(self, field: Field) -> str:\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "dissect/cstruct/compiler.py",
  "content": "    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:\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:\n                    read_slice = f\"{data_offset}:{data_offset + count}\"\n            elif isinstance(read_type, CharType):\n                read_slice = f\"{buf_offset}:{buf_offset + 1}\"\n            elif isinstance(read_type, (WcharType, BytesInteger)):\n                read_slice = f\"{buf_offset}:{buf_offset + read_type.size}\"\n            else:\n                read_slice = str(data_offset)\n",
  "start_line": 109,
  "end_line": 258,
  "total_lines": 408,
  "is_truncated": true
}

{
  "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",
  "filepath": "dissect/cstruct/cstruct.py",
  "content": "    def __getattr__(self, attr: str) -> Any:\n        try:\n            return self.resolve(self.typedefs[attr])\n        except KeyError:\n            pass\n\n        try:\n            return self.consts[attr]\n        except KeyError:\n            pass\n\n        raise AttributeError(f\"Invalid attribute: {attr}\")\n\n    def _next_anonymous(self) -> str:\n        name = f\"anonymous_{self._anonymous_count}\"\n        self._anonymous_count += 1\n        return name\n\n    def addtype(self, name: str, type_: BaseType, replace: bool = False) -> None:\n        \"\"\"Add a type or type reference.\n\n        Args:\n            name: Name of the type to be added.\n            type_: The type to be added. Can be a str reference to another type\n                or a compatible type class.\n\n        Raises:\n            ValueError: If the type already exists.\n        \"\"\"\n        if not replace and (name in self.typedefs and self.resolve(self.typedefs[name]) != self.resolve(type_)):\n            raise ValueError(f\"Duplicate type: {name}\")\n\n        self.typedefs[name] = type_\n\n    def load(self, definition: str, deftype: int = None, **kwargs) -> \"cstruct\":\n        \"\"\"Parse structures from the given definitions using the given definition type.\n\n        Definitions can be parsed using different parsers. Currently, there's\n        only one supported parser - DEF_CSTYLE. Parsers can add types and\n        modify this cstruct instance. Arguments can be passed to parsers\n        using kwargs.\n\n        The CSTYLE parser was recently replaced with token based parser,\n        instead of a strictly regex based one. The old parser is still available\n        by using DEF_LEGACY.\n\n        Args:\n            definition: The definition to parse.\n            deftype: The definition type to parse the definitions with.\n            **kwargs: Keyword arguments for parsers.\n        \"\"\"\n        deftype = deftype or cstruct.DEF_CSTYLE\n\n        if deftype == cstruct.DEF_CSTYLE:\n            TokenParser(self, **kwargs).parse(definition)\n        elif deftype == cstruct.DEF_LEGACY:\n            CStyleParser(self, **kwargs).parse(definition)\n\n        return self\n\n    def loadfile(self, path: str, deftype: int = None, **kwargs) -> None:\n        \"\"\"Load structure definitions from a file.\n\n        The given path will be read and parsed using the .load() function.\n\n        Args:\n            path: The path to load definitions from.\n            deftype: The definition type to parse the definitions with.\n            **kwargs: Keyword arguments for parsers.\n        \"\"\"\n        with open(path) as fh:\n            self.load(fh.read(), deftype, **kwargs)\n\n    def read(self, name: str, stream: BinaryIO) -> Any:\n        \"\"\"Parse data using a given type.\n\n        Args:\n            name: Type name to read.\n            stream: File-like object or byte string to parse.\n\n        Returns:\n            The parsed data.\n        \"\"\"\n        return self.resolve(name).read(stream)\n\n    def resolve(self, name: str) -> BaseType:\n        \"\"\"Resolve a type name to get the actual type object.\n\n        Types can be referenced using different names. When we want\n        the actual type object, we need to resolve these references.\n\n        Args:\n            name: Type name to resolve.\n\n        Returns:\n            The resolved type object.\n\n        Raises:\n            ResolveError: If the type can't be resolved.\n        \"\"\"\n        type_name = name\n        if not isinstance(type_name, str):\n            return type_name\n\n        for _ in range(10):\n            if type_name not in self.typedefs:\n                raise ResolveError(f\"Unknown type {name}\")\n\n            type_name = self.typedefs[type_name]\n\n            if not isinstance(type_name, str):\n                return type_name\n\n        raise ResolveError(f\"Recursion limit exceeded while resolving type {name}\")\n\n\ndef ctypes(structure: Structure) -> _ctypes.Structure:\n    \"\"\"Create ctypes structures from cstruct structures.\"\"\"\n    fields = []\n    for field in structure.fields:\n        t = ctypes_type(field.type)\n        fields.append((field.name, t))\n\n    tt = type(structure.name, (_ctypes.Structure,), {\"_fields_\": fields})\n    return tt\n\n\ndef ctypes_type(type_: BaseType) -> Any:\n    mapping = {\n        \"I\": _ctypes.c_ulong,\n        \"i\": _ctypes.c_long,\n        \"b\": _ctypes.c_int8,\n    }\n\n    if isinstance(type_, PackedType):\n        return mapping[type_.packchar]\n\n    if isinstance(type_, CharType):\n        return _ctypes.c_char\n\n    if isinstance(type_, Array):\n        subtype = ctypes_type(type_.type)\n        return subtype * type_.count\n\n    if isinstance(type_, Pointer):\n        subtype = ctypes_type(type_.type)\n        return _ctypes.POINTER(subtype)\n\n    raise NotImplementedError(f\"Type not implemented: {type_.__class__.__name__}\")",
  "start_line": 157,
  "end_line": 305,
  "total_lines": 305,
  "is_truncated": false,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "grep: dissect/cstruct/types.py: No such file or directory\n",
  "details": {
    "stdout": "",
    "stderr": "grep: dissect/cstruct/types.py: No such file or directory\n",
    "exit_code": 2
  },
  "budget_warning": "Only 9 tool call(s) remaining (21/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "168:                        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})\"\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}]\"\n378:                reader += f\"\\nt = [{enum_type}Instance(self.cstruct.{field_type.name}, d) for d in t]\"\n406:            reader += f\"[{enum_type}Instance(self.cstruct.{field_type.name}, d) for d in {reader}]\"\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}