fox-it__dissect.cstruct-66

{
  "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": "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": "                    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\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)):",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 408,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "",
  "exit_code": 0
}

{
  "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": "__init__.py\nbase.py\nbytesinteger.py\nchartype.py\nenum.py\nflag.py\ninstance.py\npackedtype.py\npointer.py\nstructure.py\nvoidtype.py\nwchartype.py\n",
  "stderr": "",
  "exit_code": 0
}

{
  "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": "Caught expected SyntaxError: invalid syntax (<compiled in>, line 2)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "stdout": "57:        bitreader = BitBuffer(stream, self.cstruct.endian)\n71:        self.cstruct = cstruct\n107:        return env[structure_name](self.cstruct, structure, source)\n117:            field_type = self.cstruct.resolve(field.type)\n132:                        num = f\"max(0, Expression(self.cstruct, '{num.expression}').evaluate(r))\"\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]\"\n387:            dynsize = max(0, Expression(self.cstruct, \"{field.type.count.expression}\").evaluate(r))\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": "error",
  "error_type": "ValueError",
  "error_message": "start_line (306) cannot be greater than end_line (305)",
  "details": {}
}

{
  "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": "        # fmt: on\n\n        pointer = pointer or (\"uint64\" if sys.maxsize > 2**32 else \"uint32\")\n        self.pointer = self.resolve(pointer)\n        self._anonymous_count = 0\n\n    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",
  "start_line": 151,
  "end_line": 300,
  "total_lines": 305,
  "is_truncated": true
}

{
  "status": "ok",
  "stdout": "57:        bitreader = BitBuffer(stream, self.cstruct.endian)\n71:        self.cstruct = cstruct\n107:        return env[structure_name](self.cstruct, structure, source)\n117:            field_type = self.cstruct.resolve(field.type)\n132:                        num = f\"max(0, Expression(self.cstruct, '{num.expression}').evaluate(r))\"\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]\"\n387:            dynsize = max(0, Expression(self.cstruct, \"{field.type.count.expression}\").evaluate(r))\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
}