use std::collections::HashMap;
use pdf_oxide::layout::TextChar;
use crate::diagnostic::Diagnostic;
use crate::pdf_string;
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct Frame {
pub x0: f32,
pub y0: f32,
pub height: f32,
}
impl Frame {
fn x(&self, user_x: f32) -> f32 {
user_x - self.x0
}
fn top_down(&self, baseline: f32) -> f32 {
self.height - (baseline - self.y0)
}
fn y(&self, baseline: f32) -> f32 {
baseline - self.y0
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct Segment {
pub x: f32,
pub baseline: f32,
pub advance: f32,
}
impl Segment {
fn right(&self) -> f32 {
self.x + self.advance
}
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct Declaration {
pub text: String,
pub segments: Vec<Segment>,
}
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct Unit {
pub text: String,
pub segments: Vec<Segment>,
}
impl Unit {
fn advance(&self) -> f32 {
self.segments.iter().map(|s| s.advance).sum()
}
pub fn suppresses_break(&self, band: (f32, f32), right: f32, frame: Frame) -> bool {
if !self.text.is_empty() {
return false;
}
let height = (band.1 - band.0).max(1.0);
self.segments.iter().any(|s| {
let base = frame.top_down(s.baseline);
let on_this_line = base >= band.0 - height * 0.25 && base <= band.1 + height * 0.25;
on_this_line && frame.x(s.right()) >= right - 1.0
})
}
pub fn coverage(
&self,
band: (f32, f32),
x: (f32, f32),
frame: Frame,
) -> (f32, Option<Segment>) {
let total = self.advance();
if total <= 0.0 {
return (0.0, None);
}
let height = (band.1 - band.0).max(1.0);
let mut inside = 0.0;
let mut first = None;
for s in &self.segments {
let base = frame.top_down(s.baseline);
if base < band.0 - height * 0.25 || base > band.1 + height * 0.25 {
continue;
}
let overlap = frame.x(s.right()).min(x.1) - frame.x(s.x).max(x.0);
if overlap > 0.0 {
inside += overlap;
if first.is_none() {
first = Some(*s);
}
}
}
(inside / total, first)
}
}
pub(crate) fn synthesise(
template: &TextChar,
text: &str,
seg: Segment,
frame: Frame,
) -> Vec<TextChar> {
let count = text.chars().count().max(1);
let step = seg.advance / count as f32;
text.chars()
.enumerate()
.map(|(i, ch)| {
let mut c = template.clone();
let x = frame.x(seg.x) + step * i as f32;
c.char = ch;
c.origin_x = x;
c.origin_y = frame.y(seg.baseline);
c.bbox.x = x;
c.bbox.y = frame.y(seg.baseline);
c.bbox.width = step;
c.advance_width = step;
c.rendered_advance = step;
c
})
.collect()
}
#[derive(Clone, Debug)]
pub(crate) struct Unrepaired {
pub diagnostic: Diagnostic,
pub segments: Vec<Segment>,
}
pub(crate) fn repair(
chars: &mut Vec<TextChar>,
decls: &[Declaration],
page: usize,
) -> (Vec<Unit>, Vec<Unrepaired>) {
const EPS: f32 = 0.05;
let mut remove = vec![false; chars.len()];
let mut units = Vec::new();
let mut diagnostics = Vec::new();
for d in decls {
let Some(anchor) = d.segments.first() else {
diagnostics.push(Unrepaired {
diagnostic: Diagnostic::DeclarationUnanchored {
page,
text: d.text.clone(),
},
segments: Vec::new(),
});
continue;
};
let wanted = d.text.len(); let mut chain = Vec::with_capacity(wanted);
let mut cursor = anchor.x;
for _ in 0..wanted {
let hit = chars.iter().enumerate().position(|(i, c)| {
!remove[i]
&& !chain.contains(&i)
&& (c.origin_y - anchor.baseline).abs() < EPS
&& (c.origin_x - cursor).abs() < EPS
});
match hit {
Some(i) => {
cursor = chars[i].origin_x + chars[i].rendered_advance;
chain.push(i);
}
None => break,
}
}
if chain.len() != wanted {
diagnostics.push(Unrepaired {
diagnostic: Diagnostic::DeclarationUnrepaired {
page,
text: d.text.clone(),
found: chain.len(),
wanted,
x: anchor.x,
},
segments: d.segments.clone(),
});
continue;
}
for i in chain {
remove[i] = true;
}
units.push(Unit {
text: d.text.clone(),
segments: d.segments.clone(),
});
}
let mut i = 0;
chars.retain(|_| {
let keep = !remove[i];
i += 1;
keep
});
(units, diagnostics)
}
pub(crate) fn present(content: &[u8]) -> bool {
content.windows(11).any(|w| w == b"/ActualText")
}
#[derive(Clone, Debug, Default)]
pub(crate) struct FontWidths {
pub first_char: i64,
pub widths: Vec<f32>,
pub missing: f32,
}
impl FontWidths {
fn width(&self, code: u8) -> f32 {
let i = code as i64 - self.first_char;
if i >= 0 && (i as usize) < self.widths.len() {
self.widths[i as usize]
} else {
self.missing
}
}
}
#[derive(Clone, Debug, PartialEq)]
enum Token {
Num(f32),
Str(Vec<u8>),
Name(String),
Op(String),
Punct,
}
pub(crate) fn scan(
content: &[u8],
fonts: &HashMap<String, FontWidths>,
page: usize,
) -> (Vec<Declaration>, Vec<Diagnostic>) {
let mut decls = Vec::new();
let mut unsupported = Vec::new();
let mut open: Vec<Option<Declaration>> = Vec::new();
let mut operands: Vec<Token> = Vec::new();
let mut cursor = Cursor::default();
let mut state = TextState::default();
let mut font: Option<String> = None;
for token in tokenise(content) {
let Token::Op(op) = &token else {
operands.push(token);
continue;
};
let op = op.clone();
let nums: Vec<f32> = operands
.iter()
.filter_map(|t| match t {
Token::Num(n) => Some(*n),
_ => None,
})
.collect();
match op.as_str() {
"BT" => cursor.set(0.0, 0.0),
"Tm" if nums.len() >= 6 => cursor.set(nums[4], nums[5]),
"Td" if nums.len() >= 2 => {
cursor.set(cursor.line.0 + nums[0], cursor.line.1 + nums[1]);
}
"TD" if nums.len() >= 2 => {
state.leading = -nums[1];
cursor.set(cursor.line.0 + nums[0], cursor.line.1 + nums[1]);
}
"T*" => cursor.next_line(state.leading),
"TL" if !nums.is_empty() => state.leading = nums[0],
"Tc" if !nums.is_empty() => state.char_spacing = nums[0],
"Tw" if !nums.is_empty() => state.word_spacing = nums[0],
"Tz" if !nums.is_empty() => state.horizontal = nums[0] / 100.0,
"Tf" => {
for t in &operands {
if let Token::Name(n) = t {
font = Some(n.clone());
}
}
if let Some(n) = nums.last() {
state.size = *n;
}
}
"Tj" | "'" | "\"" => {
if op != "Tj" {
cursor.next_line(state.leading);
}
let mut last: Option<Vec<u8>> = None;
for t in &operands {
if let Token::Str(s) = t {
last = Some(s.clone());
}
}
if let Some(s) = last {
show(&s, &mut cursor, &mut open, fonts, font.as_deref(), &state);
}
}
"TJ" => {
for t in operands.clone() {
match t {
Token::Str(s) => {
show(&s, &mut cursor, &mut open, fonts, font.as_deref(), &state);
}
Token::Num(n) => {
cursor.adjust(-n / 1000.0 * state.size * state.horizontal, &mut open);
}
Token::Name(_) | Token::Op(_) | Token::Punct => {}
}
}
}
"BDC" | "BMC" => match declared_text(&operands) {
Some(text) => {
if cursor.pos.is_none() {
unsupported.push(Diagnostic::DeclarationOutsideText {
page,
text: text.clone(),
});
open.push(None);
} else {
open.push(Some(Declaration {
text,
segments: Vec::new(),
}));
}
}
None => open.push(None),
},
"EMC" => {
if let Some(Some(d)) = open.pop() {
if d.segments.is_empty() {
unsupported.push(Diagnostic::DeclarationCoversNoText {
page,
text: d.text.clone(),
});
} else {
decls.push(d);
}
}
}
_ => {}
}
operands.clear();
}
if !open.is_empty() {
unsupported.push(Diagnostic::ScopesLeftOpen {
page,
count: open.len(),
});
}
(decls, unsupported)
}
#[derive(Default)]
struct Cursor {
pos: Option<(f32, f32)>,
line: (f32, f32),
fresh: bool,
}
impl Cursor {
fn set(&mut self, x: f32, y: f32) {
self.pos = Some((x, y));
self.line = (x, y);
self.fresh = true;
}
fn next_line(&mut self, leading: f32) {
self.set(self.line.0, self.line.1 - leading);
}
fn adjust(&mut self, dx: f32, open: &mut [Option<Declaration>]) {
if let Some(p) = self.pos.as_mut() {
p.0 += dx;
}
if self.fresh {
return;
}
for d in open.iter_mut().flatten() {
if let Some(s) = d.segments.last_mut() {
s.advance += dx;
}
}
}
}
struct TextState {
size: f32,
char_spacing: f32,
word_spacing: f32,
horizontal: f32,
leading: f32,
}
impl Default for TextState {
fn default() -> Self {
Self {
size: 0.0,
char_spacing: 0.0,
word_spacing: 0.0,
horizontal: 1.0,
leading: 0.0,
}
}
}
fn show(
bytes: &[u8],
cursor: &mut Cursor,
open: &mut [Option<Declaration>],
fonts: &HashMap<String, FontWidths>,
font: Option<&str>,
state: &TextState,
) {
let Some(pos) = cursor.pos else { return };
let metrics = font.and_then(|f| fonts.get(f));
let mut total = 0.0;
for &code in bytes {
let w0 = metrics.map_or(0.0, |m| m.width(code)) / 1000.0;
let spacing = if code == b' ' {
state.word_spacing
} else {
0.0
};
total += (w0 * state.size + state.char_spacing + spacing) * state.horizontal;
}
for d in open.iter_mut().flatten() {
if cursor.fresh || d.segments.is_empty() {
d.segments.push(Segment {
x: pos.0,
baseline: pos.1,
advance: 0.0,
});
}
if let Some(s) = d.segments.last_mut() {
s.advance += total;
}
}
cursor.pos = Some((pos.0 + total, pos.1));
cursor.fresh = false;
}
fn declared_text(operands: &[Token]) -> Option<String> {
let at = operands
.iter()
.position(|t| matches!(t, Token::Name(n) if n == "ActualText"))?;
operands[at + 1..].iter().find_map(|t| match t {
Token::Str(s) => Some(pdf_string::decode(s).text),
_ => None,
})
}
fn tokenise(data: &[u8]) -> Vec<Token> {
let mut out = Vec::new();
let mut i = 0;
while i < data.len() {
let b = data[i];
match b {
b' ' | b'\t' | b'\r' | b'\n' | b'\0' | 0x0C => i += 1,
b'%' => {
while i < data.len() && data[i] != b'\n' {
i += 1;
}
}
b'(' => {
let (s, next) = literal_string(data, i + 1);
out.push(Token::Str(s));
i = next;
}
b'<' if data.get(i + 1) == Some(&b'<') => {
out.push(Token::Punct);
i += 2;
}
b'>' if data.get(i + 1) == Some(&b'>') => {
out.push(Token::Punct);
i += 2;
}
b'<' => {
let (s, next) = hex_string(data, i + 1);
out.push(Token::Str(s));
i = next;
}
b'[' | b']' | b'{' | b'}' | b')' | b'>' => {
out.push(Token::Punct);
i += 1;
}
b'/' => {
let start = i + 1;
i = start;
while i < data.len() && !is_delimiter(data[i]) {
i += 1;
}
out.push(Token::Name(
String::from_utf8_lossy(&data[start..i]).into_owned(),
));
}
b'+' | b'-' | b'.' | b'0'..=b'9' => {
let start = i;
i += 1;
while i < data.len() && matches!(data[i], b'0'..=b'9' | b'.' | b'-' | b'+') {
i += 1;
}
match std::str::from_utf8(&data[start..i])
.ok()
.and_then(|s| s.parse::<f32>().ok())
{
Some(n) => out.push(Token::Num(n)),
None => out.push(Token::Punct),
}
}
_ => {
let start = i;
while i < data.len() && !is_delimiter(data[i]) {
i += 1;
}
if i == start {
i += 1;
continue;
}
out.push(Token::Op(
String::from_utf8_lossy(&data[start..i]).into_owned(),
));
}
}
}
out
}
fn is_delimiter(b: u8) -> bool {
matches!(
b,
b' ' | b'\t'
| b'\r'
| b'\n'
| b'\0'
| 0x0C
| b'('
| b')'
| b'<'
| b'>'
| b'['
| b']'
| b'{'
| b'}'
| b'/'
| b'%'
)
}
fn literal_string(data: &[u8], mut i: usize) -> (Vec<u8>, usize) {
let mut out = Vec::new();
let mut depth = 1usize;
while i < data.len() {
match data[i] {
b'\\' => {
let Some(&next) = data.get(i + 1) else { break };
i += 2;
match next {
b'n' => out.push(b'\n'),
b'r' => out.push(b'\r'),
b't' => out.push(b'\t'),
b'b' => out.push(8),
b'f' => out.push(12),
b'\n' => {}
b'\r' => {
if data.get(i) == Some(&b'\n') {
i += 1;
}
}
b'0'..=b'7' => {
let mut v = (next - b'0') as u32;
let mut taken = 1;
while taken < 3 {
match data.get(i) {
Some(&d @ b'0'..=b'7') => {
v = v * 8 + (d - b'0') as u32;
i += 1;
taken += 1;
}
_ => break,
}
}
out.push((v & 0xFF) as u8);
}
other => out.push(other),
}
}
b'(' => {
depth += 1;
out.push(b'(');
i += 1;
}
b')' => {
depth -= 1;
i += 1;
if depth == 0 {
break;
}
out.push(b')');
}
other => {
out.push(other);
i += 1;
}
}
}
(out, i)
}
fn hex_string(data: &[u8], mut i: usize) -> (Vec<u8>, usize) {
let mut digits = Vec::new();
while i < data.len() && data[i] != b'>' {
if data[i].is_ascii_hexdigit() {
digits.push(data[i]);
}
i += 1;
}
if digits.len() % 2 == 1 {
digits.push(b'0'); }
let bytes = digits
.chunks(2)
.filter_map(|p| u8::from_str_radix(std::str::from_utf8(p).ok()?, 16).ok())
.collect();
(bytes, i + 1)
}
#[cfg(test)]
mod tests {
use super::*;
fn widths() -> HashMap<String, FontWidths> {
let mut m = HashMap::new();
m.insert(
"F1".to_string(),
FontWidths {
first_char: 32,
widths: vec![1000.0; 96],
missing: 1000.0,
},
);
m
}
#[test]
fn reads_a_hex_declaration_and_its_extent() {
let content = b"BT /F1 10 Tf 100 700 Td [(the )]TJ \
/Span<</ActualText<FEFF00530065006300740069006F006E>>>BDC \
[(\xA7)]TJ EMC [( on)]TJ ET";
let (decls, unsupported) = scan(content, &widths(), 1);
assert!(unsupported.is_empty(), "{unsupported:?}");
assert_eq!(decls.len(), 1);
assert_eq!(decls[0].text, "Section");
assert_eq!(
decls[0].segments,
vec![Segment {
x: 140.0,
baseline: 700.0,
advance: 10.0
}]
);
}
#[test]
fn reads_an_empty_literal_declaration() {
let content = b"BT /F1 10 Tf 100 700 Td [(infra)]TJ \
/Span<</ActualText()>>BDC [(-)]TJ EMC ET";
let (decls, _) = scan(content, &widths(), 1);
assert_eq!(decls.len(), 1);
assert_eq!(decls[0].text, "");
assert_eq!(decls[0].segments[0].x, 150.0);
}
#[test]
fn strips_the_byte_order_mark() {
let content = b"BT /F1 10 Tf 0 0 Td /Span<</ActualText<FEFF0041>>>BDC [(x)]TJ EMC ET";
let (decls, _) = scan(content, &widths(), 1);
assert_eq!(decls[0].text, "A");
}
#[test]
fn anchors_at_the_text_not_at_the_bdc() {
let content = b"BT /F1 10 Tf 100 700 Td [(the)]TJ ET \
/Span<</ActualText<FEFF0041>>>BDC \
BT /F1 10 Tf 200 500 Td [(x)]TJ ET EMC";
let (decls, _) = scan(content, &widths(), 1);
assert_eq!(decls[0].segments[0].x, 200.0);
assert_eq!(decls[0].segments[0].baseline, 500.0);
}
#[test]
fn a_span_across_a_line_break_is_two_segments() {
let content = b"BT /F1 10 Tf 100 700 Td \
/Span<</ActualText<FEFF0041>>>BDC \
[(third)]TJ -20 -14 Td [(of)]TJ EMC ET";
let (decls, _) = scan(content, &widths(), 1);
assert_eq!(decls[0].segments.len(), 2);
assert_eq!(decls[0].segments[0].advance, 50.0);
assert_eq!(decls[0].segments[1].baseline, 686.0);
assert_eq!(decls[0].segments[1].advance, 20.0);
}
#[test]
fn tj_kerning_counts_toward_the_advance() {
let content = b"BT /F1 10 Tf 0 0 Td /Span<</ActualText<FEFF0041>>>BDC \
[(ab)-500(cd)]TJ EMC ET";
let (decls, _) = scan(content, &widths(), 1);
assert_eq!(decls[0].segments[0].advance, 20.0 + 5.0 + 20.0);
}
#[test]
fn a_scope_without_a_declaration_is_not_one() {
let content = b"BT /F1 10 Tf 0 0 Td /P <</MCID 0>> BDC [(ab)]TJ EMC ET";
let (decls, unsupported) = scan(content, &widths(), 1);
assert!(decls.is_empty());
assert!(unsupported.is_empty(), "{unsupported:?}");
}
#[test]
fn nested_scopes_pop_in_order() {
let content = b"BT /F1 10 Tf 0 0 Td /P<</MCID 0>>BDC \
/Span<</ActualText<FEFF0041>>>BDC [(ab)]TJ EMC \
[(cd)]TJ EMC ET";
let (decls, unsupported) = scan(content, &widths(), 1);
assert_eq!(decls.len(), 1);
assert_eq!(decls[0].text, "A");
assert_eq!(decls[0].segments[0].advance, 20.0);
assert!(unsupported.is_empty(), "{unsupported:?}");
}
#[test]
fn a_declaration_covering_nothing_is_reported() {
let content = b"BT /F1 10 Tf 0 0 Td /Span<</ActualText<FEFF0041>>>BDC EMC ET";
let (decls, unsupported) = scan(content, &widths(), 1);
assert!(decls.is_empty());
assert_eq!(unsupported.len(), 1);
}
#[test]
fn present_finds_the_key() {
assert!(present(b"q /Span<</ActualText<FEFF>>>BDC EMC Q"));
assert!(!present(b"BT /F1 10 Tf (plain) Tj ET"));
}
#[test]
fn hex_strings_pad_an_odd_digit() {
let (bytes, _) = hex_string(b"41 4>", 0);
assert_eq!(bytes, vec![0x41, 0x40]);
}
#[test]
fn literal_strings_handle_escapes_and_nesting() {
let (bytes, _) = literal_string(b"a\\(b\\) (c) \\101\\n)", 0);
assert_eq!(bytes, b"a(b) (c) A\n");
}
}