From 1bb51887fd16fa6116305a0828883da58831b2d2 Mon Sep 17 00:00:00 2001 From: Piohrun Date: Tue, 17 Nov 2026 03:29:22 +0100 Subject: [PATCH] craft-pdf: content reads a lone minus between operands as the number 0 (#1958) --- crates/pdf/README.md | 6 +++- crates/pdf/src/cos/content.rs | 38 +++++++++++++++++++++++- crates/pdf/src/cos/content/tests.rs | 46 ++++++++++++++++++++++++++++- 3 files changed, 87 insertions(+), 3 deletions(-) diff --git a/crates/pdf/README.md b/crates/pdf/README.md index b9e0129d3..a1332ce4f 100644 --- a/crates/pdf/README.md +++ b/crates/pdf/README.md @@ -136,7 +136,11 @@ let bytes = write_full(&doc, &SaveOptions::default())?; // rewrite what t With `content`, `cos::content` reads and writes page content streams. `parse` keeps each operator's byte span and skips (and counts) what it cannot read instead of failing; inline images -stay whole, so `parse` → `serialize_ops` round-trips them. `Matrix` holds the arithmetic content +stay whole, so `parse` → `serialize_ops` round-trips them. Between operands, a token of one or two +signs with a minus among them (`-`, `--`, `-+`, `+-`), followed by whitespace, a delimiter or the +end, is read as the number 0, as hayro-syntax reads it. Inside an array or dictionary, or among an +inline image's parameters, such a token still makes the whole operand unreadable (such an image is +left out of `ops` and counted in `ambiguous_images`). `Matrix` holds the arithmetic content interpretation needs. - Reads every cross-reference form (tables, streams, hybrid `/XRefStm`) and object streams. A diff --git a/crates/pdf/src/cos/content.rs b/crates/pdf/src/cos/content.rs index a3087972d..d91552553 100644 --- a/crates/pdf/src/cos/content.rs +++ b/crates/pdf/src/cos/content.rs @@ -137,6 +137,10 @@ pub struct Ops<'a> { ends: &'a [usize], boundary: usize, comment_edges: Vec<(bool, bool)>, + /// Arrays, dictionaries and hex strings whose read failed, until as many `]` or `>` (of either + /// kind) have passed: what follows the opener is re-read token by token, and a sign there is + /// left to the lexer, not read as 0. + broken: usize, } impl<'a> Ops<'a> { @@ -151,6 +155,7 @@ impl<'a> Ops<'a> { ends, boundary: 0, comment_edges: vec![(false, false); ends.len()], + broken: 0, } } @@ -170,7 +175,7 @@ impl Iterator for Ops<'_> { type Item = Op; fn next(&mut self) -> Option { - let Ops { data, lx, operands, start, skipped, ambiguous_images, ends, boundary, comment_edges: edges } = self; + let Ops { data, lx, operands, start, skipped, ambiguous_images, ends, boundary, comment_edges: edges, broken } = self; let (data, ends): (&[u8], &[usize]) = (data, ends); loop { let trivia = lx.pos; @@ -187,6 +192,14 @@ impl Iterator for Ops<'_> { return None; }; let at = lx.pos; + if *broken == 0 + && let Some(run) = lone_minus(data, at) + { + lx.pos = at + run; + start.get_or_insert(at); + operands.push(Object::Int(0)); + continue; + } let operand_start = matches!(b, b'/' | b'(' | b'<' | b'[' | b'+' | b'-' | b'.') || b.is_ascii_digit(); if operand_start { match lx.object() { @@ -200,6 +213,9 @@ impl Iterator for Ops<'_> { lx.pos = data.len(); } Err(_) => { + if matches!(b, b'[' | b'<') { + *broken += 1; + } let read = lx.pos.saturating_sub(at); #[cfg(test)] tests::RESCANNED.with(|c| c.set(c.get() + read)); @@ -219,6 +235,9 @@ impl Iterator for Ops<'_> { } if is_delim(b) { // A stray `)`, `>`, `]`, `{`, `}`. + if matches!(b, b']' | b'>') { + *broken = broken.saturating_sub(1); + } lx.pos += 1; *skipped += 1; continue; @@ -272,6 +291,23 @@ impl Iterator for Ops<'_> { } } +/// The length of the token at `at` when it is one or two signs with a minus among them, followed by +/// whitespace, a delimiter or the end (`-`, `--`, `-+`, `+-`). That is no number to the lexer, but +/// the number 0 to hayro-syntax, both the copy vendored here and PdfCraft's. A lone `-` occurs in +/// real files: PDF.js bug 1753983 has one among the operands of `c`. The two copies disagree on `+` +/// and `++` and on runs such as `---`, both read `+++` as an unknown operator, and signs after a +/// digit belong to that number, so the lexer's reading of those stands. No more than four bytes +/// are looked at: the one before `at` and three from it. +fn lone_minus(data: &[u8], at: usize) -> Option { + if !at.checked_sub(1).and_then(|i| data.get(i)).is_none_or(|c| is_ws(*c) || is_delim(*c)) { + return None; + } + let token = data.get(at..)?; + let run = token.iter().take(2).take_while(|c| matches!(c, b'+' | b'-')).count(); + let ends = token.get(run).is_none_or(|c| is_ws(*c) || is_delim(*c)); + (run > 0 && ends && token.get(..run)?.contains(&b'-')).then_some(run) +} + /// Record the piece boundaries crossed by the comments in `trivia` (skipped whitespace and /// comments). `boundary` is the first boundary not yet passed; boundaries only move forward. fn comment_edges(data: &[u8], trivia: std::ops::Range, ends: &[usize], boundary: &mut usize, edges: &mut [(bool, bool)]) { diff --git a/crates/pdf/src/cos/content/tests.rs b/crates/pdf/src/cos/content/tests.rs index 6a44d51b1..1a6a14851 100644 --- a/crates/pdf/src/cos/content/tests.rs +++ b/crates/pdf/src/cos/content/tests.rs @@ -42,13 +42,14 @@ fn splicing_visits_each_piece_a_few_times() { #[test] fn a_long_unreadable_number_is_read_once() { - for junk in ["+", "5"] { + for junk in ["+", "5", "-", "-+", "+-"] { let n = 20_000; let src = format!("{}{} 1 0 0 1 0 0 cm", junk.repeat(n), if junk == "5" { "x" } else { "" }); RESCANNED.with(|c| c.set(0)); let p = parse(src.as_bytes()); let rescanned = RESCANNED.with(|c| c.get()); assert!(rescanned <= 2 * n, "{rescanned} bytes read for a {n}-byte token"); + assert!(junk == "5" || junk == "+" || rescanned > 0, "the run of {junk:?} is counted"); assert_eq!(p.ops.last().and_then(|o| o.nums::<6>()), Some([1.0, 0.0, 0.0, 1.0, 0.0, 0.0])); } // A short damaged number still recovers byte by byte. @@ -57,6 +58,49 @@ fn a_long_unreadable_number_is_read_once() { assert_eq!(p.ops[0].nums::<2>(), Some([5.0, 0.0])); } +/// A lone `-`, or two signs with a minus among them, between operands, is the number 0 to +/// hayro-syntax, as a lone `-` is in real files (PDF.js bug 1753983, among the operands of `c`): +/// the second `Tr` of `3 Tr - Tr` gets 0, and `0 - (a) "` three operands. The token takes no +/// bytes from what follows and starts the operator's span. Other sign tokens are read as before: a +/// `+` alone, three signs, signs before a letter or after a digit, and signs inside an array or +/// dictionary the lexer can't read. +#[test] +fn a_lone_minus_is_read_as_zero() { + let ops = |data: &[u8]| -> Vec<(Vec, Vec)> { parse(data).ops.into_iter().map(|o| (o.op, o.operands)).collect() }; + let zero = || Object::Int(0); + assert_eq!(ops(b"3 Tr - Tr"), [(b"Tr".to_vec(), vec![Object::Int(3)]), (b"Tr".to_vec(), vec![zero()])]); + assert_eq!(ops(b"0 - (a) \""), [(b"\"".to_vec(), vec![zero(), zero(), Object::String(PdfString::literal(b"a".to_vec()))])]); + for data in [&b"- w"[..], b"-- w", b"+- w", b"-+ w", b"-"] { + let want: &[(Vec, Vec)] = if data == b"-" { &[] } else { &[(b"w".to_vec(), vec![zero()])] }; + assert_eq!(ops(data), want, "{}", String::from_utf8_lossy(data)); + } + assert_eq!(ops(b"(a)-/N gs"), [(b"gs".to_vec(), vec![Object::String(PdfString::literal(b"a".to_vec())), zero(), Object::name("N")])]); + for data in [&b"- w"[..], b"-- w", b"-+ w", b"+- w"] { + let parsed = parse(data); + assert_eq!((parsed.skipped, parsed.ops.first().map(|o| o.span.clone())), (0, Some(0..data.len())), "{}", String::from_utf8_lossy(data)); + } + // As before. + assert_eq!(ops(b"5 + Tc"), [(b"Tc".to_vec(), vec![Object::Int(5)])]); + assert_eq!(ops(b"/Span << /A - >> BDC"), [(b"BDC".to_vec(), vec![Object::name("Span"), Object::name("A")])]); + assert_eq!(ops(b"[(a) - ] TJ"), [(b"TJ".to_vec(), vec![Object::String(PdfString::literal(b"a".to_vec()))])]); + assert_eq!(ops(b"[1 - 2] 0 d"), [(b"d".to_vec(), vec![Object::Int(1), Object::Int(2), Object::Int(0)])]); + assert_eq!(ops(b"<- w"), [(b"w".to_vec(), vec![])]); + // Past a broken array's or dictionary's end, a lone minus is 0 again; not before the outer one's. + assert_eq!(ops(b"[(a) - ] TJ - Tc")[1], (b"Tc".to_vec(), vec![zero()])); + assert_eq!(ops(b"/Span << /A - >> BDC - w")[1], (b"w".to_vec(), vec![zero()])); + assert_eq!( + ops(b"/P << /A << /B - >> /C - >> BDC - w"), + [(b"BDC".to_vec(), vec![Object::name("P"), Object::name("A"), Object::name("B"), Object::name("C")]), (b"w".to_vec(), vec![zero()])] + ); + assert_eq!(ops(b"5 ++ Tc"), [(b"Tc".to_vec(), vec![Object::Int(5)])]); + assert_eq!(ops(b"--- w"), [(b"w".to_vec(), vec![])]); + assert_eq!(ops(b"-x w"), [(b"x".to_vec(), vec![]), (b"w".to_vec(), vec![])]); + assert_eq!(ops(b"5-- Tc"), [(b"Tc".to_vec(), vec![])]); + for (data, n) in [(&b"-5 w"[..], -5.0), (b"+5 w", 5.0), (b"-.5 w", -0.5), (b"--5 w", -5.0)] { + assert_eq!(parse(data).ops.first().and_then(|o| o.num_back(0)), Some(n), "{}", String::from_utf8_lossy(data)); + } +} + #[test] fn operators_keep_operands_and_spans() { let src = b"q 1 0 0 1 72 720 cm BT /F1 12 Tf (Hello \\(world\\)) Tj [(A) -120 (B)] TJ ET Q";