docvortex 0.2.1__py3-none-any.whl

docvortex/analyzers/native/office/doc/pieces.py

@@ -0,0 +1,256 @@
+"""解析 DOC CLX piece table 并恢复全局 UTF-16 CP 文本流。"""
+
+from __future__ import annotations
+
+from bisect import bisect_left
+from dataclasses import dataclass
+import struct
+
+from ..errors import LegacyOfficeMalformedError
+from ..legacy.binary import bounded_slice, get_u16, get_u32
+
+from .records import DocBudget
+
+
+@dataclass(frozen=True, slots=True)
+class Piece:
+    """一个把逻辑 CP 范围映射到 WordDocument FC 的 piece。"""
+
+    cp_start: int
+    cp_end: int
+    fc: int
+    compressed: bool
+    prm: bytes = b""
+
+
+@dataclass(slots=True)
+class TextStream:
+    """字符标量及其 CP、FC 和 piece 映射。"""
+
+    chars: list[str]
+    cps: list[int]
+    fcs: list[int]
+    piece_indexes: list[int]
+
+    def index_of_cp(self, cp: int) -> int:
+        """返回首个 CP 不小于目标值的字符索引。"""
+
+        return bisect_left(self.cps, max(cp, 0))
+
+    def text_between(self, cp_start: int, cp_end: int) -> str:
+        """返回指定 CP 半开区间的 Unicode 文本。"""
+
+        return "".join(self.chars[self.index_of_cp(cp_start) : self.index_of_cp(cp_end)])
+
+
+def _prm0_grpprl(prm: int) -> bytes:
+    """把 Prm0 中已支持的单个属性还原为 grpprl。"""
+
+    isprm = (prm >> 1) & 0x7F
+    value = (prm >> 8) & 0xFF
+    opcode = {
+        0x0C: 0x260A,  # sprmPIlvl
+        0x18: 0x2416,  # sprmPFInTable
+        0x19: 0x2417,  # sprmPFTtp
+        0x55: 0x0835,  # sprmCFBold
+        0x56: 0x0836,  # sprmCFItalic
+        0x57: 0x0837,  # sprmCFStrike
+        0x78: 0x2640,  # sprmPOutLvl
+    }.get(isprm)
+    if opcode is None:
+        return b""
+    return struct.pack("<HB", opcode, value)
+
+
+def _parse_plc_pcd(plc: bytes, prcs: list[bytes], budget: DocBudget) -> list[Piece]:
+    """解析 Pcdt 内的 PlcPcd 并绑定 piece Prm。"""
+
+    if len(plc) < 16 or (len(plc) - 4) % 12:
+        raise LegacyOfficeMalformedError("DOC piece table is empty or malformed")
+    count = (len(plc) - 4) // 12
+    budget.charge(count)
+    cp_bytes = (count + 1) * 4
+    pieces: list[Piece] = []
+    previous_cp = -1
+    for index in range(count):
+        cp_start = get_u32(plc, index * 4)
+        cp_end = get_u32(plc, (index + 1) * 4)
+        pcd_offset = cp_bytes + index * 8
+        fc_raw = get_u32(plc, pcd_offset + 2)
+        prm = get_u16(plc, pcd_offset + 6) or 0
+        if cp_start is None or cp_end is None or fc_raw is None:
+            raise LegacyOfficeMalformedError("DOC piece table is truncated")
+        if cp_start < previous_cp or cp_end < cp_start:
+            raise LegacyOfficeMalformedError("DOC piece CP values are not ordered")
+        previous_cp = cp_end
+        compressed = bool(fc_raw & 0x4000_0000)
+        fc = fc_raw & 0x3FFF_FFFF
+        if compressed:
+            fc //= 2
+        grpprl = b""
+        if prm & 1:
+            prc_index = prm >> 1
+            if prc_index < len(prcs):
+                grpprl = prcs[prc_index]
+        elif prm:
+            grpprl = _prm0_grpprl(prm)
+        pieces.append(
+            Piece(
+                cp_start=int(cp_start),
+                cp_end=int(cp_end),
+                fc=int(fc),
+                compressed=compressed,
+                prm=grpprl,
+            )
+        )
+    return pieces
+
+
+def parse_clx(table_stream: bytes, *, offset: int, size: int, budget: DocBudget) -> list[Piece]:
+    """解析 CLX 中的 Prc 数组和最终 Pcdt。"""
+
+    clx = bounded_slice(table_stream, offset, size)
+    if clx is None:
+        raise LegacyOfficeMalformedError("DOC CLX range is out of bounds")
+    prcs: list[bytes] = []
+    cursor = 0
+    while cursor < len(clx):
+        kind = clx[cursor]
+        if kind == 1:
+            length = get_u16(clx, cursor + 1)
+            if length is None:
+                raise LegacyOfficeMalformedError("DOC CLX Prc is truncated")
+            payload = bounded_slice(clx, cursor + 3, length)
+            if payload is None:
+                raise LegacyOfficeMalformedError("DOC CLX Prc exceeds its range")
+            budget.charge()
+            prcs.append(payload)
+            cursor += 3 + length
+            continue
+        if kind == 2:
+            length = get_u32(clx, cursor + 1)
+            if length is None:
+                raise LegacyOfficeMalformedError("DOC CLX Pcdt is truncated")
+            plc = bounded_slice(clx, cursor + 5, length)
+            if plc is None:
+                raise LegacyOfficeMalformedError("DOC PlcPcd exceeds CLX")
+            return _parse_plc_pcd(plc, prcs, budget)
+        raise LegacyOfficeMalformedError("DOC CLX contains an unknown record")
+    raise LegacyOfficeMalformedError("DOC CLX does not contain a Pcdt")
+
+
+def legacy_single_piece(*, fc_min: int, fc_mac: int, ccp_text: int) -> list[Piece]:
+    """为没有 CLX 的非 complex 文档构造保守单 piece。"""
+
+    if fc_min < 0 or fc_mac <= fc_min:
+        return []
+    length = min(fc_mac - fc_min, max(ccp_text, 0))
+    if length <= 0:
+        return []
+    return [Piece(cp_start=0, cp_end=length, fc=fc_min, compressed=True)]
+
+
+def codec_for_lid(lid: int) -> str:
+    """把 Word LID 映射为 Python 可用的 ANSI/DBCS codec。"""
+
+    primary = lid & 0x03FF
+    if primary == 0x11:
+        return "cp932"
+    if primary == 0x12:
+        return "cp949"
+    if primary == 0x04:
+        return "cp950" if lid in {0x0404, 0x0C04, 0x1404, 0x7C04} else "cp936"
+    if primary in {0x01, 0x20, 0x29}:
+        return "cp1256"
+    if primary in {0x02, 0x19, 0x22, 0x23}:
+        return "cp1251"
+    if primary in {0x05, 0x0E, 0x15, 0x18, 0x1A, 0x1B, 0x24}:
+        return "cp1250"
+    if primary == 0x08:
+        return "cp1253"
+    if primary == 0x0D:
+        return "cp1255"
+    if primary == 0x1E:
+        return "cp874"
+    if primary in {0x1F, 0x2C}:
+        return "cp1254"
+    if primary in {0x25, 0x26, 0x27}:
+        return "cp1257"
+    if primary == 0x2A:
+        return "cp1258"
+    return "cp1252"
+
+
+def _lead_byte(codec: str, value: int) -> bool:
+    """判断一个压缩 piece 字节是否为 DBCS 首字节。"""
+
+    if codec == "cp932":
+        return 0x81 <= value <= 0x9F or 0xE0 <= value <= 0xFC
+    if codec in {"cp936", "cp949", "cp950"}:
+        return 0x81 <= value <= 0xFE
+    return False
+
+
+def extract_text(
+    word_document: bytes,
+    pieces: list[Piece],
+    *,
+    total_cp: int,
+    codec: str,
+    budget: DocBudget,
+) -> TextStream:
+    """按 piece 顺序恢复字符，并保留字符到 CP/FC 的反向映射。"""
+
+    chars: list[str] = []
+    cps: list[int] = []
+    fcs: list[int] = []
+    piece_indexes: list[int] = []
+    for piece_index, piece in enumerate(pieces):
+        if piece.cp_start >= total_cp:
+            break
+        cp_cursor = piece.cp_start
+        logical_length = min(piece.cp_end, total_cp) - piece.cp_start
+        if logical_length <= 0:
+            continue
+        if piece.compressed:
+            payload = bounded_slice(word_document, piece.fc, logical_length)
+            if payload is None:
+                continue
+            cursor = 0
+            while cursor < len(payload):
+                width = 2 if _lead_byte(codec, payload[cursor]) and cursor + 1 < len(payload) else 1
+                decoded = payload[cursor : cursor + width].decode(codec, errors="replace")
+                for char in decoded:
+                    chars.append(char)
+                    cps.append(cp_cursor)
+                    fcs.append(piece.fc + cursor)
+                    piece_indexes.append(piece_index)
+                cp_cursor += width
+                cursor += width
+                budget.charge(width)
+        else:
+            byte_length = logical_length * 2
+            payload = bounded_slice(word_document, piece.fc, byte_length)
+            if payload is None:
+                continue
+            cursor = 0
+            while cursor + 2 <= len(payload):
+                first = int(struct.unpack_from("<H", payload, cursor)[0])
+                width = 2
+                units = [first]
+                if 0xD800 <= first <= 0xDBFF and cursor + 4 <= len(payload):
+                    second = int(struct.unpack_from("<H", payload, cursor + 2)[0])
+                    if 0xDC00 <= second <= 0xDFFF:
+                        units.append(second)
+                        width = 4
+                raw = struct.pack(f"<{len(units)}H", *units)
+                char = raw.decode("utf-16le", errors="replace")
+                chars.append(char)
+                cps.append(cp_cursor)
+                fcs.append(piece.fc + cursor)
+                piece_indexes.append(piece_index)
+                unit_count = width // 2
+                cp_cursor += unit_count
+                cursor += width
+                budget.charge(unit_count)
+    return TextStream(chars=chars, cps=cps, fcs=fcs, piece_indexes=piece_indexes)

docvortex/analyzers/native/office/doc/records.py

@@ -0,0 +1,40 @@
+"""DOC 二进制结构使用的有界整数、PLC 和记录预算工具。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import struct
+
+from ..errors import LegacyOfficeResourceLimitError
+from ..limits import MAX_RECORDS
+
+
+@dataclass(slots=True)
+class DocBudget:
+    """限制 DOC 解析累计访问的记录和文本单元数。"""
+
+    visited: int = 0
+
+    def charge(self, amount: int = 1) -> None:
+        """计入本次访问量，超过统一上限时稳定失败。"""
+
+        if amount < 0 or self.visited + amount > MAX_RECORDS:
+            raise LegacyOfficeResourceLimitError(f"DOC records exceed max_records={MAX_RECORDS}")
+        self.visited += amount
+
+
+def parse_plc(data: bytes, *, item_size: int, budget: DocBudget) -> tuple[list[int], list[bytes]]:
+    """解析由 CP 数组和定长数据项组成的通用 PLC。"""
+
+    if item_size < 0 or len(data) < 4:
+        return [], []
+    denominator = 4 + item_size
+    payload = len(data) - 4
+    if denominator <= 0 or payload % denominator:
+        return [], []
+    count = payload // denominator
+    budget.charge(count + 1)
+    cp_bytes = (count + 1) * 4
+    cps = [int(struct.unpack_from("<I", data, index * 4)[0]) for index in range(count + 1)]
+    items = [data[cp_bytes + index * item_size : cp_bytes + (index + 1) * item_size] for index in range(count)]
+    return cps, items

docvortex/analyzers/native/office/doc/sprm.py

@@ -0,0 +1,269 @@
+"""遍历并应用 Word 二进制单属性修饰符 SPRM。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+import struct
+from typing import Callable
+
+from ..legacy.binary import get_i16, get_u16, get_u32
+from .models import DocCharStyle, DocTableCellFormat, DocTableFormat
+from .records import DocBudget
+
+
+def _operand_length(opcode: int, operand: bytes) -> int:
+    """根据 SPRM 的 spra 字段计算 operand 字节数。"""
+
+    spra = opcode >> 13
+    if spra in {0, 1}:
+        return 1
+    if spra in {2, 4, 5}:
+        return 2
+    if spra == 3:
+        return 4
+    if spra == 7:
+        return 3
+    if opcode == 0xD608:
+        return (get_u16(operand, 0) or -1) + 1
+    return (operand[0] + 1) if operand else 0
+
+
+def walk_sprms(
+    grpprl: bytes,
+    callback: Callable[[int, bytes], None],
+    *,
+    budget: DocBudget | None = None,
+) -> None:
+    """有界顺序遍历 grpprl，截断尾部按可恢复内容处理。"""
+
+    cursor = 0
+    while cursor + 2 <= len(grpprl):
+        opcode = int(struct.unpack_from("<H", grpprl, cursor)[0])
+        cursor += 2
+        length = _operand_length(opcode, grpprl[cursor:])
+        if length <= 0 or cursor + length > len(grpprl):
+            return
+        if budget is not None:
+            budget.charge()
+        callback(opcode, grpprl[cursor : cursor + length])
+        cursor += length
+
+
+def _toggle(operand: bytes, base: bool) -> bool | None:
+    """把 Word ToggleOperand 解析为相对样式基值。"""
+
+    if not operand:
+        return None
+    return {0: False, 1: True, 0x80: base, 0x81: not base}.get(operand[0])
+
+
+def chpx_style_id(grpprl: bytes) -> int | None:
+    """读取 CHPX 指定的字符样式 istd。"""
+
+    result: int | None = None
+
+    def consume(opcode: int, operand: bytes) -> None:
+        """记录最后一个有效 sprmCIstd。"""
+
+        nonlocal result
+        if opcode == 0x4A30:
+            result = get_u16(operand, 0)
+
+    walk_sprms(grpprl, consume)
+    return result
+
+
+def chpx_picture_location(grpprl: bytes) -> int | None:
+    """读取 CHPX 中的 sprmCPicLocation。"""
+
+    result: int | None = None
+
+    def consume(opcode: int, operand: bytes) -> None:
+        """记录最后一个有效图片偏移。"""
+
+        nonlocal result
+        if opcode == 0x6A03:
+            result = get_u32(operand, 0)
+
+    walk_sprms(grpprl, consume)
+    return result
+
+
+def apply_character_sprms(
+    grpprl: bytes,
+    current: DocCharStyle,
+    style_base: DocCharStyle,
+    *,
+    budget: DocBudget | None = None,
+) -> DocCharStyle:
+    """按 Word 样式覆盖顺序把 CHPX 应用到字符样式。"""
+
+    style = current
+
+    def consume(opcode: int, operand: bytes) -> None:
+        """应用当前可表达的字符属性。"""
+
+        nonlocal style
+        toggle_field = {
+            0x0800: "deleted",  # sprmCFRMarkDel
+            0x0802: "hidden",  # sprmCFFldVanish
+            0x0835: "bold",
+            0x0836: "italic",
+            0x0837: "strike",
+            0x083C: "hidden",  # sprmCFVanish
+        }.get(opcode)
+        if toggle_field is not None:
+            value = _toggle(operand, bool(getattr(style_base, toggle_field)))
+            if value is not None:
+                style = replace(style, **{toggle_field: value})
+            return
+        if opcode == 0x2A3E and operand:  # sprmCKul
+            style = replace(style, underline=operand[0] not in {0, 5})
+        elif opcode == 0x2A48 and operand:  # sprmCIss
+            style = replace(
+                style,
+                superscript=operand[0] == 1,
+                subscript=operand[0] == 2,
+            )
+        elif opcode == 0x2A53 and operand:  # sprmCFDStrike
+            style = replace(style, strike=operand[0] != 0)
+        elif opcode == 0x2A54 and operand:  # sprmCEm
+            style = replace(style, emphasis=operand[0] != 0)
+
+    walk_sprms(grpprl, consume, budget=budget)
+    return style
+
+
+@dataclass(frozen=True, slots=True)
+class PapDelta:
+    """PAPX 或段落样式对可见段落属性的增量。"""
+
+    in_table: bool | None = None
+    row_mark: bool | None = None
+    outline_level: int | None | object = None
+    ilfo: int | None = None
+    ilvl: int | None = None
+    table_depth: int | None = None
+    inner_cell: bool | None = None
+    inner_row: bool | None = None
+    table: DocTableFormat | None = None
+
+    def merge(self, over: PapDelta) -> PapDelta:
+        """让后应用的段落属性覆盖当前增量。"""
+
+        return PapDelta(
+            in_table=over.in_table if over.in_table is not None else self.in_table,
+            row_mark=over.row_mark if over.row_mark is not None else self.row_mark,
+            outline_level=(over.outline_level if over.outline_level is not None else self.outline_level),
+            ilfo=over.ilfo if over.ilfo is not None else self.ilfo,
+            ilvl=over.ilvl if over.ilvl is not None else self.ilvl,
+            table_depth=over.table_depth if over.table_depth is not None else self.table_depth,
+            inner_cell=over.inner_cell if over.inner_cell is not None else self.inner_cell,
+            inner_row=over.inner_row if over.inner_row is not None else self.inner_row,
+            table=over.table if over.table is not None else self.table,
+        )
+
+
+def _parse_tdef_table(operand: bytes) -> DocTableFormat | None:
+    """解析 TDefTableOperand 中的边界和横纵向合并标志。"""
+
+    if len(operand) < 3:
+        return None
+    columns = operand[2]
+    if columns > 63:
+        return None
+    boundaries: list[int] = []
+    for index in range(columns + 1):
+        value = get_i16(operand, 3 + index * 2)
+        if value is None:
+            return None
+        boundaries.append(value)
+    cells: list[DocTableCellFormat] = []
+    tc_base = 3 + (columns + 1) * 2
+    for index in range(columns):
+        flags = get_u16(operand, tc_base + index * 20) or 0
+        horizontal = flags & 0x3
+        vertical = (flags >> 5) & 0x3
+        right = boundaries[index + 1]
+        cells.append(
+            DocTableCellFormat(
+                right=right,
+                horizontal_first=horizontal >= 2,
+                horizontal_continue=horizontal == 1,
+                vertical_first=vertical == 3,
+                vertical_continue=vertical == 1,
+            )
+        )
+    return DocTableFormat(boundaries=tuple(boundaries), cells=tuple(cells))
+
+
+def apply_paragraph_sprms(
+    grpprl: bytes,
+    data_stream: bytes,
+    initial: PapDelta | None = None,
+    *,
+    budget: DocBudget | None = None,
+) -> PapDelta:
+    """应用 PAPX SPRM，并解析 huge PAPX 与表格行属性。"""
+
+    delta = initial or PapDelta()
+
+    def consume(opcode: int, operand: bytes) -> None:
+        """应用一个段落或表格属性。"""
+
+        nonlocal delta
+        if opcode == 0x2416 and operand:
+            delta = replace(delta, in_table=operand[0] != 0)
+        elif opcode == 0x2417 and operand:
+            delta = replace(delta, row_mark=operand[0] != 0)
+        elif opcode == 0x6646:
+            offset = get_u32(operand, 0)
+            length = get_u16(data_stream, offset) if offset is not None else None
+            if offset is not None and length is not None and offset + 2 + length <= len(data_stream):
+                delta = apply_paragraph_sprms(
+                    data_stream[offset + 2 : offset + 2 + length],
+                    b"",
+                    delta,
+                    budget=budget,
+                )
+        elif opcode == 0x2640 and operand:
+            delta = replace(delta, outline_level=operand[0] + 1 if operand[0] < 9 else -1)
+        elif opcode == 0x260A and operand:
+            delta = replace(delta, ilvl=int(operand[0]))
+        elif opcode == 0x460B:
+            delta = replace(delta, ilfo=get_u16(operand, 0))
+        elif opcode == 0x6649:
+            depth = get_u32(operand, 0)
+            if depth is not None:
+                delta = replace(delta, table_depth=int(depth))
+        elif opcode == 0x664A:
+            raw = get_u32(operand, 0)
+            if raw is not None:
+                signed = struct.unpack("<i", struct.pack("<I", raw))[0]
+                delta = replace(delta, table_depth=max(0, (delta.table_depth or 0) + signed))
+        elif opcode == 0x244B and operand:
+            delta = replace(delta, inner_cell=operand[0] != 0)
+        elif opcode == 0x244C and operand:
+            delta = replace(delta, inner_row=operand[0] != 0)
+        elif opcode == 0xD608:
+            table = _parse_tdef_table(operand)
+            if table is not None:
+                header = delta.table.header if delta.table is not None else False
+                delta = replace(delta, table=replace(table, header=header))
+        elif opcode == 0x3404 and operand:
+            table = delta.table or DocTableFormat()
+            delta = replace(delta, table=replace(table, header=operand[0] != 0))
+        elif opcode == 0xD62B and len(operand) >= 3 and delta.table is not None:
+            cell_index = operand[1]
+            flag = operand[2]
+            cells = list(delta.table.cells)
+            if cell_index < len(cells):
+                cells[cell_index] = replace(
+                    cells[cell_index],
+                    vertical_continue=flag == 1,
+                    vertical_first=flag == 3,
+                )
+                delta = replace(delta, table=replace(delta.table, cells=tuple(cells)))
+
+    walk_sprms(grpprl, consume, budget=budget)
+    return delta