Мост .doc: PAPX-свойства из PrcData (sprmPHugePapx/sprmPTableProps) #78

Merged
pjandro merged 1 commits from fix/doc-prcdata-huge-papx into main 2026-11-01 01:29:53 +03:00
6 changed files with 418 additions and 8 deletions
+8 -7
View File
File diff suppressed because one or more lines are too long
@@ -264,7 +264,10 @@ public final class DocToDocx {
while (cp < to) {
int paraStart = cp;
long paraFc = pieces.fcOf(paraStart);
byte[] direct = papx.grpprlFor(paraFc);
// grpprl абзаца может быть вынесен Word в PrcData (Data-поток)
// через sprmPHugePapx/sprmPTableProps — разворачиваем до
// потребления: InTable/TTP/TAP видят автомат и paraProps (§2.9.210)
byte[] direct = PrcData.resolve(dataStream, papx.grpprlFor(paraFc));
int istd = istdOf(direct, papx.istdFor(paraFc));
byte[] styleChpx = styles.chpxChain(istd);
StringBuilder runs = new StringBuilder();
@@ -83,6 +83,20 @@ final class Grpprl {
* отрицание индекса (список тот же, отступы абзаца сохраняются).
*/
static final int SPRM_P_ILFO = 0x460B;
/**
* sprmPHugePapx (§2.6.2, 4 байта): смещение PrcData (§2.9.210) в
* Data-потоке — настоящие свойства абзаца, которые Word выносит в
* grpprl вне FKP-страницы PAPX. В grpprl структуры GrpPrlAndIstd —
* единственный Prl при istd=0 (§2.6.2); разрешение — {@link PrcData#resolve}.
*/
static final int SPRM_P_HUGE_PAPX = 0x6646;
/**
* sprmPTableProps (§2.6.2, 4 байта): смещение следующего PrcData в
* цепочке (свойства строки таблицы). Разбор текущего grpprl на нём
* обрывается (§2.6.2: «MUST NOT process any more Prl elements in the
* array that contained the sprmPTableProps»).
*/
static final int SPRM_P_TABLE_PROPS = 0x646B;
// Table Properties (§2.6.3, sgc 5)
static final int SPRM_T_TABLE_BORDERS_80 = 0xD605;
@@ -0,0 +1,110 @@
package ru.pjandro.wordpdf.internal.doc;
import java.io.ByteArrayOutputStream;
/**
* Разворачивание grpprl абзаца через PrcData — цепочку grpprl внутри
* Data-потока, [MS-DOC] §2.9.210 (PrcData = {@code [cbGrpprl:2][grpprl]},
* поля {@code next} нет) и §2.6.2 (sprmPHugePapx/sprmPTableProps).
*
* <p>Настоящий Word хранит свойства абзаца не только в FKP-страницах PAPX:
* grpprl абзаца может состоять из единственного Prl
* {@code sprmPHugePapx (0x6646) + u32} (в GrpPrlAndIstd — единственный Prl
* при istd=0), а сами свойства — с {@code sprmPFInTable}/{@code sprmPFTtp}/
* {@code sprmTDefTable}/бордюрами — лежат в PrcData в Data-потоке. Внутри
* PrcData цепочка продолжается через {@code sprmPTableProps (0x646B)}.
* Оба указателя разворачиваются <b>на позиции указателя без обрыва</b>
* текущего массива; цепочка обязана завершиться PrcData без обоих
* спец-спрмов (§2.6.2).</p>
*
* <p>Отступление от spec: §2.6.2 велит массив, содержащий PTableProps,
* «не читать дальше» — Word так и делает, потому что потребляет из PrcData
* полный TAP (включая {@code sprmTInsert}), а хвост массива — легаси-зеркало
* для Word 97/2000 (Appendix A &lt;9&gt;). Конвертер {@code sprmTInsert}
* не читает и живёт на этом зеркале: в {@code samples/ru-table-image.doc}
* единственный {@code sprmTDefTable} (сетка) стоит именно ПОСЛЕ
* {@code sprmPTableProps} в PAPX-массиве, а в PrcData его нет вовсе.
* Поэтому свойства объединяются (union), а не замещаются: без цепочки
* теряются её sprm'ы, без зеркал — сетка.</p>
*
* <p>Снисходительность — по образцу {@link Styles}/{@link Lists}: любой
* брак (ptr за Data, битый cbGrpprl, цикл A→B→A) останавливает цепочку,
* накопленное возвращается — без {@code ValidationException}. Спец-спрмы
* из результата всегда вырезаются (потребители {@code Grpprl.scan} их всё
* равно не понимают); прочие Prl исходного массива сохраняются в исходном
* порядке (при многосprl-массиве с HugePapx — сверхспецификацией: валидный
* Word пишет HugePapx единственным Prl).</p>
*/
final class PrcData {
/** Капа cbGrpprl: §2.9.210 «MUST be less than or equal to 0x3FA2». */
private static final int MAX_CB_GRPPRL = 0x3FA2;
/** Максимум разобранных PrcData на абзац — защита от цикла A→B→A. */
private static final int MAX_HOPS = 32;
private PrcData() {
}
/**
* Grpprl абзаца с развёрнутой цепочкой PrcData. Без указателей
* (0x6646/0x646B нет) возвращается <em>тот же массив</em>; иначе —
* новый: не-спец-спрмы исходника дословно, спец-спрмы заменены
* содержимым цепочки по их указателям.
*/
static byte[] resolve(byte[] dataStream, byte[] grpprl) {
if (!hasPointer(grpprl)) {
return grpprl;
}
ByteArrayOutputStream out = new ByteArrayOutputStream(grpprl.length + 64);
int[] hops = new int[1];
copyPrls(grpprl, 0, grpprl.length, dataStream, out, hops);
return out.toByteArray();
}
/** Есть ли в массиве указатель на PrcData. */
private static boolean hasPointer(byte[] grpprl) {
boolean[] found = new boolean[1];
Grpprl.scan(grpprl, 0, grpprl.length, (sprm, buf, off, len) -> {
if (sprm == Grpprl.SPRM_P_HUGE_PAPX || sprm == Grpprl.SPRM_P_TABLE_PROPS) {
found[0] = true;
}
});
return found[0];
}
/**
* Копирует Prl массива {@code buf[off..off+len)} в {@code out}:
* обычные — дословно (sprm + операнд), оба указательных — разворачивают
* целевой PrcData на позиции указателя, разбор массива продолжается
* (union зеркала и цепочки — см. javadoc класса).
*/
private static void copyPrls(byte[] buf, int off, int len, byte[] data,
ByteArrayOutputStream out, int[] hops) {
Grpprl.scan(buf, off, len, (sprm, b, operandOff, operandLen) -> {
if (sprm == Grpprl.SPRM_P_HUGE_PAPX || sprm == Grpprl.SPRM_P_TABLE_PROPS) {
follow(Grpprl.operandInt(b, operandOff, operandLen), data, out, hops);
return;
}
out.write(b, operandOff - 2, operandLen + 2);
});
}
/**
* Разворачивает PrcData по смещению {@code ptr} в Data-потоке. Брак
* (ptr за потоком, cbGrpprl вне {@code [1, 0x3FA2]}, grpprl не влезает,
* исчерпан бюджет цепочки) — останов без исключения.
*/
private static void follow(int ptr, byte[] data, ByteArrayOutputStream out, int[] hops) {
if (hops[0]++ >= MAX_HOPS || ptr < 0) {
return;
}
if ((long) ptr + 2 > data.length) {
return;
}
int cb = (data[ptr] & 0xFF) | ((data[ptr + 1] & 0xFF) << 8);
if (cb < 1 || cb > MAX_CB_GRPPRL || (long) ptr + 2 + cb > data.length) {
return;
}
copyPrls(data, ptr + 2, cb, data, out, hops);
}
}
@@ -753,6 +753,99 @@ class DocToDocxFormattingTest {
assertTrue(xml.indexOf(">D3<") < xml.indexOf(">E<"), xml);
}
/**
* Таблица 2×2, у которой TTP-абзац первой строки несёт grpprl, вынесенный
* Word в PrcData (Data-поток): PAPX = единственный {@code sprmPHugePapx
* (0x6646) + ptr}, а {@code sprmPFInTable}/{@code sprmPFTtp}/
* {@code sprmTDefTable} (сетка 900+1000)/бордюры — в PrcData по ptr
* (§2.9.210, §2.6.2). Без разворачивания строка 1 не закрывается
* (маркер TTP течёт в ячейку), сетка берётся из строки 2 (500+1000).
* TTP строки 2 — прямой grpprl, как в {@link #twoRowDoc}.
*/
private static byte[] hugePapxTableDoc() throws IOException {
String text = "A" + (char) 7 + "B" + (char) 7 + (char) 7
+ "C" + (char) 7 + "D" + (char) 7 + (char) 7;
byte[] wd = new byte[TEXT_FC + text.length() * 2];
put16(wd, 0, 0xA5EC);
put16(wd, 2, 0x00C1);
put16(wd, 10, 1 << 9);
put16(wd, 62, 4);
put32(wd, 64, wd.length);
put32(wd, 76, text.length());
put16(wd, 152, 98);
pair(wd, 6, 0, 20);
pair(wd, 13, 20, 12); // PlcfBtePapx
pair(wd, 33, 32, 21); // Clx
byte[] t = text.getBytes(StandardCharsets.UTF_16LE);
System.arraycopy(t, 0, wd, TEXT_FC, t.length);
int page = 3 * 512;
int[] rgfc = {TEXT_FC, TEXT_FC + 4, TEXT_FC + 8, TEXT_FC + 10,
TEXT_FC + 14, TEXT_FC + 18, TEXT_FC + 20};
for (int i = 0; i < rgfc.length; i++) {
put32(wd, page + i * 4, rgfc[i]);
}
int rgbx = page + rgfc.length * 4;
int[] bx = {87, 90, 93, 98, 101, 120};
for (int i = 0; i < bx.length; i++) {
wd[rgbx + i * 13] = (byte) bx[i];
}
wd[page + 511] = 6; // cpara
byte[] inTable = prl(0x2416, 1);
byte[] ttp = prl(0x2417, 1);
byte[] prc = concat(inTable, ttp, tdefTable(2, new int[] {0, 900, 1900}),
tableBorders()); // grpprl строки 1 — в PrcData по 0x10
byte[] hugePrl = {(byte) 0x6646, (byte) (0x6646 >>> 8), 0x10, 0, 0, 0};
byte[] ttpRow2 = concat(inTable, ttp, tdefTable(2, new int[] {0, 500, 1500}),
tableBorders()); // сетка строки 2 — «чужая», не должна победить
papxEntry(wd, page, 87, 0, inTable); // A
papxEntry(wd, page, 90, 0, inTable); // B
papxEntry(wd, page, 93, 0, hugePrl); // TTP строки 1 — только указатель
papxEntry(wd, page, 98, 0, inTable); // C
papxEntry(wd, page, 101, 0, inTable); // D
papxEntry(wd, page, 120, 0, ttpRow2); // TTP строки 2 — прямой TAP
byte[] data = new byte[160];
put16(data, 0x10, prc.length);
System.arraycopy(prc, 0, data, 0x12, prc.length);
byte[] tab = new byte[53];
put32(tab, 0, 0);
put32(tab, 4, text.length()); // PlcfSed
put32(tab, 20, TEXT_FC); // PlcfBtePapx aFc + pn=3
put32(tab, 24, TEXT_FC + 20);
put32(tab, 28, 3);
tab[32] = 0x02; // Clx Pcdt
put32(tab, 33, 16);
put32(tab, 37, 0);
put32(tab, 41, text.length());
put32(tab, 47, TEXT_FC);
try (POIFSFileSystem fs = new POIFSFileSystem();
ByteArrayOutputStream out = new ByteArrayOutputStream()) {
fs.getRoot().createDocument("WordDocument", new ByteArrayInputStream(wd));
fs.getRoot().createDocument("1Table", new ByteArrayInputStream(tab));
fs.getRoot().createDocument("Data", new ByteArrayInputStream(data));
fs.writeFilesystem(out);
return out.toByteArray();
}
}
@Test
void hugePapxRowMark_closesRowWithGridFromPrcData() throws IOException {
String xml = documentXml(hugePapxTableDoc());
assertEquals(1, xml.split("<w:tbl>", -1).length - 1, xml);
assertEquals(2, xml.split("<w:tr>", -1).length - 1, "строки: " + xml);
assertEquals(4, xml.split("<w:tc>", -1).length - 1, "ячейки: " + xml);
assertTrue(xml.contains("<w:gridCol w:w=\"900\"/>")
&& xml.contains("<w:gridCol w:w=\"1000\"/>"),
"сетка должна прийти из PrcData: " + xml);
assertFalse(xml.contains("<w:gridCol w:w=\"500\"/>"),
"сетка строки 2 не должна открыть таблицу: " + xml);
assertTrue(xml.contains("<w:tblBorders"), "бордюры из PrcData: " + xml);
assertTrue(xml.indexOf("<w:tbl>") < xml.indexOf(">A<"), "A в таблице: " + xml);
assertTrue(xml.indexOf(">D<") < xml.indexOf("</w:tbl>"), "D в таблице: " + xml);
assertTrue(xml.indexOf(">A<") < xml.indexOf(">B<")
&& xml.indexOf(">B<") < xml.indexOf(">C<")
&& xml.indexOf(">C<") < xml.indexOf(">D<"), xml);
}
// --- четвёртый документ: списки --------------------------------------
/**
@@ -0,0 +1,189 @@
package ru.pjandro.wordpdf.internal.doc;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import java.io.ByteArrayOutputStream;
import org.junit.jupiter.api.Test;
/**
* Юниты разворачивания grpprl через PrcData ([MS-DOC] §2.9.210, §2.6.2:
* sprmPHugePapx 0x6646 / sprmPTableProps 0x646B). Крафт — байтовые массивы
* in memory, как в {@code CfbReaderTest}: PrcData = [cbGrpprl:2][grpprl];
* содержимое задаётся лямбдой {@code at -> ...}, где {@code at[i]} —
* смещение i-го PrcData в собранном Data-потоке.
*/
class PrcDataTest {
private static final byte[] EMPTY = new byte[0];
private static final byte[] DATA_EMPTY = new byte[16];
@Test
void noPointerSprms_returnsSameArray() {
byte[] grpprl = inTable();
assertSame(grpprl, PrcData.resolve(DATA_EMPTY, grpprl));
assertSame(EMPTY, PrcData.resolve(DATA_EMPTY, EMPTY));
}
@Test
void hugePapx_insertsPrcDataSprms() {
DataStream d = data(at -> concat(inTable(), ttp()));
assertArrayEquals(concat(inTable(), ttp()),
PrcData.resolve(d.bytes, ptr(0x6646, d.at[0])));
}
@Test
void tablePropsChain_mergesKeepingTailAfterPointer() {
// PrcData[0] = [jc][→PrcData[1]][inTable]; PrcData[1] = [inTable].
// Хвост после PTableProps СОХРАНЯЕТСЯ: spec (§2.6.2) велит его игнорировать,
// но Word пишет в нём легаси-зеркало (в ru-table-image.doc — единственный
// TDefTable), а TInsert из PrcData конвертер не читает → union.
DataStream d = data(at -> concat(prl(0x2461, 2), ptr(0x646B, at[1]), inTable()),
at -> inTable());
assertArrayEquals(concat(prl(0x2461, 2), inTable(), inTable()),
PrcData.resolve(d.bytes, ptr(0x6646, d.at[0])));
}
@Test
void hugePapxInMultiPrlArray_othersKeptInPlace() {
DataStream d = data(at -> inTable());
assertArrayEquals(concat(prl(0x2461, 2), inTable(), prl(0x2407, 1)),
PrcData.resolve(d.bytes,
concat(prl(0x2461, 2), ptr(0x6646, d.at[0]), prl(0x2407, 1))));
}
@Test
void topLevelTableProps_expandsChainKeepsTail() {
// Ровная форма TTP-массива из ru-table-image.doc: PTableProps первым,
// легаси-зеркало (здесь — jc) после него; побеждает оба (union).
DataStream d = data(at -> inTable());
assertArrayEquals(concat(inTable(), prl(0x2461, 2)),
PrcData.resolve(d.bytes, concat(ptr(0x646B, d.at[0]), prl(0x2461, 2))));
}
@Test
void pointerBeyondData_keepsForeignPrlsStops() {
assertArrayEquals(prl(0x2461, 2),
PrcData.resolve(DATA_EMPTY, concat(prl(0x2461, 2), ptr(0x6646, 1000))));
}
@Test
void hugePapxCutOffAtEndOfData_stops() {
byte[] d = new byte[33];
d[32] = 40; // cb=40, grpprl за конец Data (32+2+40 > 33)
assertArrayEquals(EMPTY, PrcData.resolve(d, ptr(0x6646, 32)));
}
@Test
void pointerTopBitSet_rejected() {
// u32 ≥ 2^31 → operandInt отдаёт отрицательный int — вне Data
assertArrayEquals(prl(0x2461, 2),
PrcData.resolve(DATA_EMPTY, concat(prl(0x2461, 2), ptr(0x6646, -1))));
}
@Test
void zeroCb_rejected() {
assertArrayEquals(EMPTY, PrcData.resolve(DATA_EMPTY, ptr(0x6646, 0)));
}
@Test
void cbAboveSpecCap_rejected() {
byte[] d = new byte[0x4000];
d[1] = 0x40; // cb = 0x4000 > 0x3FA2 (капа §2.9.210)
assertArrayEquals(EMPTY, PrcData.resolve(d, ptr(0x6646, 0)));
}
@Test
void cycleStopsWithinHopBudget() {
// PrcData[0] ↔ PrcData[1] — цикл через PTableProps; разбор обязан
// остановиться (цепочка по spec обязана завершаться) без исключения.
DataStream d = data(at -> ptr(0x646B, at[1]), at -> ptr(0x646B, at[0]));
assertArrayEquals(prl(0x2461, 2),
PrcData.resolve(d.bytes, concat(ptr(0x6646, d.at[0]), prl(0x2461, 2))));
}
@Test
void selfPointerStops() {
DataStream d = data(at -> ptr(0x6646, at[0]));
assertEquals(0, PrcData.resolve(d.bytes, ptr(0x6646, d.at[0])).length);
}
@Test
void missingDataStream_keepsForeignPrls() {
assertArrayEquals(prl(0x2461, 2),
PrcData.resolve(new byte[0], concat(prl(0x2461, 2), ptr(0x6646, 0))));
}
// --- крафт -----------------------------------------------------------
/** Строит grpprl PrcData по смещениям готового потока. */
private interface GrpBuilder {
byte[] build(int[] at);
}
/** Data-поток и смещения, по которым легли его PrcData. */
private static final class DataStream {
byte[] bytes;
int[] at;
}
/** Потоковый Prl: toggle-спрм (sprm 2 Б + операнд 1 Б). */
private static byte[] prl(int sprm, int toggle) {
return new byte[] {(byte) sprm, (byte) (sprm >>> 8), (byte) toggle};
}
private static byte[] inTable() {
return prl(0x2416, 1); // sprmPFInTable
}
private static byte[] ttp() {
return prl(0x2417, 1); // sprmPFTtp
}
/** Указательный Prl: 0x6646/0x646B (spra=3) + u32 смещение PrcData в Data. */
private static byte[] ptr(int sprm, int offset) {
return new byte[] {(byte) sprm, (byte) (sprm >>> 8),
(byte) offset, (byte) (offset >>> 8),
(byte) (offset >>> 16), (byte) (offset >>> 24) };
}
private static byte[] concat(byte[]... parts) {
int len = 0;
for (byte[] p : parts) {
len += p.length;
}
byte[] out = new byte[len];
int at = 0;
for (byte[] p : parts) {
System.arraycopy(p, 0, out, at, p.length);
at += p.length;
}
return out;
}
/**
* Data-поток: grpprl'ы PrcData подряд, каждый с префиксом cbGrpprl.
* Смещения считаются первым проходом (длина {@code ptr}-Prl не зависит
* от значения указателя), тела — вторым, уже с финальными {@code at}.
*/
private static DataStream data(GrpBuilder... grps) {
int[] at = new int[grps.length];
int pos = 0;
for (int i = 0; i < grps.length; i++) {
at[i] = pos;
pos += 2 + grps[i].build(new int[grps.length]).length;
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
for (GrpBuilder grp : grps) {
byte[] body = grp.build(at);
out.write(body.length & 0xFF);
out.write((body.length >>> 8) & 0xFF);
out.write(body, 0, body.length);
}
DataStream d = new DataStream();
d.bytes = out.toByteArray();
d.at = at;
return d;
}
}