use crate::parser::{is_delimiter, is_ws};
use crate::{Error, Result};
#[derive(Debug, Clone)]
struct ObjectSpan {
num: u32,
gen: u32,
obj_line_start: usize,
end: usize,
stream_len: Option<usize>,
length_holder: Option<u32>,
}
fn find_next_obj(input: &[u8], from: usize) -> Option<(u32, u32, usize, usize)> {
let mut line_start = from;
while line_start < input.len() {
let line_end = memchr_nl(input, line_start).unwrap_or(input.len());
let line = &input[line_start..line_end];
if let Some((num, gen, kw_end)) = parse_obj_header(line) {
return Some((num, gen, line_start, line_start + kw_end));
}
line_start = line_end + 1;
if line_end >= input.len() {
break;
}
}
None
}
fn memchr_nl(buf: &[u8], from: usize) -> Option<usize> {
buf[from..]
.iter()
.position(|&b| b == b'\n')
.map(|i| from + i)
}
fn parse_obj_header(line: &[u8]) -> Option<(u32, u32, usize)> {
let line = if line.last() == Some(&b'\r') {
&line[..line.len() - 1]
} else {
line
};
let s = std::str::from_utf8(line).ok()?;
let mut it = s.split_ascii_whitespace();
let num: u32 = it.next()?.parse().ok()?;
let gen: u32 = it.next()?.parse().ok()?;
if it.next()? != "obj" {
return None;
}
if it.next().is_some() {
return None;
}
let kw_end = s.rfind("obj")? + 3;
Some((num, gen, kw_end))
}
fn rfind_line_keyword(input: &[u8], kw: &[u8]) -> Option<usize> {
let mut found = None;
let mut from = 0;
while let Some(pos) = find_line_keyword_from(input, kw, from) {
found = Some(pos);
from = pos + 1;
}
found
}
fn find_name_token(hay: &[u8], name: &[u8]) -> Option<usize> {
find_name_token_from(hay, name, 0)
}
fn find_name_token_from(hay: &[u8], name: &[u8], from: usize) -> Option<usize> {
let mut i = from;
while i < hay.len() {
match hay[i] {
b'%' => {
while i < hay.len() && hay[i] != b'\n' && hay[i] != b'\r' {
i += 1;
}
}
b'<' if hay.get(i + 1) == Some(&b'<') => i += 2,
b'>' if hay.get(i + 1) == Some(&b'>') => i += 2,
b'<' => {
i += 1;
while i < hay.len() && hay[i] != b'>' {
i += 1;
}
i += 1;
}
b'(' => {
i += 1;
let mut depth = 1usize;
while i < hay.len() && depth > 0 {
match hay[i] {
b'\\' => i += 1, b'(' => depth += 1,
b')' => depth -= 1,
_ => {}
}
i += 1;
}
}
b'/' if hay[i..].starts_with(name) => {
let after = hay.get(i + name.len());
if after.is_none_or(|&b| is_ws(b) || is_delimiter(b)) {
return Some(i);
}
i += 1; }
_ => i += 1,
}
}
None
}
enum LengthKind {
Indirect(u32),
IndirectUnsupportedGeneration,
Direct,
None,
}
fn classify_length(dict: &[u8]) -> LengthKind {
let needle = b"/Length";
let Some(p) = find_name_token(dict, needle) else {
return LengthKind::None;
};
let rest = &dict[p + needle.len()..];
let s = match std::str::from_utf8(rest) {
Ok(s) => s,
Err(_) => return LengthKind::None,
};
let mut it = s.split_ascii_whitespace();
let Some(first) = it.next() else {
return LengthKind::None;
};
if first.parse::<u32>().is_err() {
return LengthKind::None;
}
let second = it.next();
let third = it.next();
if let (Some(g), Some(r)) = (second, third) {
if let (Ok(gen), "R") = (g.parse::<u32>(), r) {
return if gen == 0 {
LengthKind::Indirect(first.parse().unwrap())
} else {
LengthKind::IndirectUnsupportedGeneration
};
}
}
LengthKind::Direct
}
fn find_subslice(hay: &[u8], needle: &[u8]) -> Option<usize> {
if needle.is_empty() || hay.len() < needle.len() {
return None;
}
hay.windows(needle.len()).position(|w| w == needle)
}
fn detect_objstm(body: &[u8]) -> bool {
let mut from = 0;
while let Some(tp) = find_name_token_from(body, b"/Type", from) {
let mut j = tp + b"/Type".len();
loop {
match body.get(j) {
Some(&b) if is_ws(b) => j += 1,
Some(&b'%') => {
while body.get(j).is_some_and(|&c| c != b'\n' && c != b'\r') {
j += 1;
}
}
_ => break,
}
}
if body[j..].starts_with(b"/ObjStm")
&& body
.get(j + b"/ObjStm".len())
.is_none_or(|&b| is_ws(b) || is_delimiter(b))
{
return true;
}
from = tp + b"/Type".len();
}
false
}
pub fn fix_qdf(input: &[u8]) -> Result<Vec<u8>> {
let xref_pos = rfind_line_keyword(input, b"xref")
.ok_or_else(|| Error::parse(0, "fix_qdf: no classic `xref` table found"))?;
let body_region = &input[..xref_pos];
let mut objects: Vec<ObjectSpan> = Vec::new();
let mut cursor = 0usize;
while let Some((num, gen, line_start, kw_end)) = find_next_obj(body_region, cursor) {
let mut stream_info: Option<(usize, usize, usize)> = None; let after_dict = find_subslice(&body_region[kw_end..], b"<<")
.map(|o| kw_end + o)
.and_then(|d| find_matching_dict_close(body_region, d))
.map(|c| c + 2);
if let Some(stream_kw) =
after_dict.and_then(|sf| find_line_keyword_from(body_region, b"stream", sf))
{
let first_endobj = find_line_keyword_from(body_region, b"endobj", kw_end);
let stream_is_ours = match first_endobj {
None => true,
Some(eob) => stream_kw < eob,
};
if stream_is_ours {
let mut content_start = stream_kw + b"stream".len();
if body_region.get(content_start) == Some(&b'\r') {
content_start += 1;
}
if body_region.get(content_start) == Some(&b'\n') {
content_start += 1;
}
if let Some(endstream_kw) =
find_line_keyword_from(body_region, b"endstream", content_start)
{
stream_info = Some((stream_kw, content_start, endstream_kw));
}
}
}
let endobj_search_from = match stream_info {
Some((_, _, endstream_kw)) => endstream_kw + b"endstream".len(),
None => kw_end,
};
let endobj = find_line_keyword_from(body_region, b"endobj", endobj_search_from)
.ok_or_else(|| Error::parse(line_start, "fix_qdf: object without matching `endobj`"))?;
let end = endobj + b"endobj".len();
let body = &body_region[kw_end..endobj];
if detect_objstm(body) {
return Err(Error::Unsupported(
"fix_qdf: object streams (/Type /ObjStm) are not supported in QDF input".into(),
));
}
let mut stream_len = None;
let mut length_holder = None;
if let Some((stream_kw_abs, content_start_abs, endstream_kw_abs)) = stream_info {
stream_len = Some(endstream_kw_abs - content_start_abs);
let dict = &body_region[kw_end..stream_kw_abs];
match classify_length(dict) {
LengthKind::Indirect(m) => length_holder = Some(m),
LengthKind::IndirectUnsupportedGeneration => {
return Err(Error::parse(
line_start,
"fix_qdf: stream /Length holder with non-zero generation \
is not supported (canonical QDF uses generation 0)",
));
}
LengthKind::Direct | LengthKind::None => {
}
}
}
objects.push(ObjectSpan {
num,
gen,
obj_line_start: line_start,
end,
stream_len,
length_holder,
});
cursor = end;
}
if objects.is_empty() {
return Err(Error::parse(0, "fix_qdf: no objects found before xref"));
}
for (i, obj) in objects.iter().enumerate() {
if obj.num as usize != i + 1 {
return Err(Error::parse(
obj.obj_line_start,
"fix_qdf: non-sequential object numbering \
(canonical QDF numbers objects 1..N in order)",
));
}
}
let gen0_object_numbers: std::collections::HashSet<u32> = objects
.iter()
.filter(|o| o.gen == 0)
.map(|o| o.num)
.collect();
let mut new_len_body: std::collections::HashMap<u32, usize> = std::collections::HashMap::new();
for obj in &objects {
if let (Some(len), Some(holder)) = (obj.stream_len, obj.length_holder) {
if !gen0_object_numbers.contains(&holder) {
return Err(Error::parse(
obj.obj_line_start,
"fix_qdf: stream's indirect /Length holder object (M 0) is missing",
));
}
if let Some(&prev) = new_len_body.get(&holder) {
if prev != len {
return Err(Error::parse(
obj.obj_line_start,
"fix_qdf: indirect /Length holder reused with conflicting lengths",
));
}
}
new_len_body.insert(holder, len);
}
}
let mut out: Vec<u8> = Vec::with_capacity(input.len() + 16);
let first_obj_start = objects[0].obj_line_start;
out.extend_from_slice(&body_region[..first_obj_start]);
let mut new_offsets: Vec<(u32, u32, usize)> = Vec::with_capacity(objects.len());
for (i, obj) in objects.iter().enumerate() {
if i > 0 {
let prev_end = objects[i - 1].end;
out.extend_from_slice(&body_region[prev_end..obj.obj_line_start]);
}
new_offsets.push((obj.num, obj.gen, out.len()));
if let Some(&new_len) = new_len_body.get(&obj.num).filter(|_| obj.gen == 0) {
rewrite_length_holder(&mut out, &body_region[obj.obj_line_start..obj.end], new_len)?;
} else {
out.extend_from_slice(&body_region[obj.obj_line_start..obj.end]);
}
}
let last_end = objects.last().unwrap().end;
out.extend_from_slice(&body_region[last_end..xref_pos]);
let startxref_value = out.len();
let size = objects.len() + 1;
out.extend_from_slice(b"xref\n");
out.extend_from_slice(format!("0 {size}\n").as_bytes());
out.extend_from_slice(b"0000000000 65535 f \n");
for &(_, gen, off) in &new_offsets {
out.extend_from_slice(format!("{off:010} {gen:05} n \n").as_bytes());
}
let trailer_kw = find_subslice(&input[xref_pos..], b"trailer")
.map(|p| xref_pos + p)
.ok_or_else(|| Error::parse(xref_pos, "fix_qdf: no `trailer` keyword"))?;
let dict_open = find_subslice(&input[trailer_kw..], b"<<")
.map(|p| trailer_kw + p)
.ok_or_else(|| Error::parse(trailer_kw, "fix_qdf: trailer has no dictionary"))?;
let dict_close = find_matching_dict_close(input, dict_open)
.ok_or_else(|| Error::parse(dict_open, "fix_qdf: unterminated trailer dictionary"))?;
let trailer_prefix = &input[xref_pos..trailer_kw]; let _ = trailer_prefix;
let trailer_dict = &input[trailer_kw..dict_close + 2];
let rewritten_trailer = rewrite_size(trailer_dict, size);
out.extend_from_slice(&rewritten_trailer);
let after_dict = dict_close + 2;
let startxref_kw = find_subslice(&input[after_dict..], b"startxref")
.map(|p| after_dict + p)
.ok_or_else(|| Error::parse(after_dict, "fix_qdf: no `startxref` keyword"))?;
out.extend_from_slice(&input[after_dict..startxref_kw]);
out.extend_from_slice(b"startxref\n");
out.extend_from_slice(format!("{startxref_value}\n").as_bytes());
let eof = find_subslice(&input[startxref_kw..], b"%%EOF")
.map(|p| startxref_kw + p)
.ok_or_else(|| Error::parse(startxref_kw, "fix_qdf: no `%%EOF` marker"))?;
out.extend_from_slice(&input[eof..]);
Ok(out)
}
fn find_line_keyword_from(input: &[u8], kw: &[u8], from: usize) -> Option<usize> {
let mut i = from;
while i + kw.len() <= input.len() {
if &input[i..i + kw.len()] == kw {
let at_line_start = i == 0 || input[i - 1] == b'\n' || input[i - 1] == b'\r';
let after_ok = match input.get(i + kw.len()) {
None => true,
Some(&c) => c == b'\n' || c == b'\r' || c == b' ' || c == b'\t',
};
if at_line_start && after_ok {
return Some(i);
}
}
i += 1;
}
None
}
fn rewrite_length_holder(out: &mut Vec<u8>, obj_bytes: &[u8], new_len: usize) -> Result<()> {
let nl = obj_bytes
.iter()
.position(|&b| b == b'\n')
.ok_or_else(|| Error::parse(0, "fix_qdf: malformed length object header"))?;
out.extend_from_slice(&obj_bytes[..=nl]);
let endobj_rel = find_line_keyword_from(obj_bytes, b"endobj", nl + 1)
.ok_or_else(|| Error::parse(0, "fix_qdf: length object missing endobj"))?;
let body = &obj_bytes[nl + 1..endobj_rel];
let lead = body
.iter()
.take_while(|&&b| b.is_ascii_whitespace())
.count();
let after_int = body[lead..]
.iter()
.position(|&b| !b.is_ascii_digit())
.map(|p| lead + p)
.unwrap_or(body.len());
if after_int == lead || !body[lead..after_int].iter().all(|b| b.is_ascii_digit()) {
return Err(Error::parse(
0,
"fix_qdf: length-holder body is not a plain integer",
));
}
out.extend_from_slice(&body[..lead]);
out.extend_from_slice(new_len.to_string().as_bytes());
out.extend_from_slice(&body[after_int..]);
out.extend_from_slice(&obj_bytes[endobj_rel..]);
Ok(())
}
fn find_matching_dict_close(input: &[u8], open: usize) -> Option<usize> {
let mut depth = 0usize;
let mut i = open;
while i < input.len() {
match input[i] {
b'%' => {
while i < input.len() && input[i] != b'\n' && input[i] != b'\r' {
i += 1;
}
}
b'<' if input.get(i + 1) == Some(&b'<') => {
depth += 1;
i += 2;
}
b'>' if input.get(i + 1) == Some(&b'>') => {
depth -= 1;
if depth == 0 {
return Some(i);
}
i += 2;
}
b'<' => {
i += 1;
while i < input.len() && input[i] != b'>' {
i += 1;
}
i += 1;
}
b'(' => {
i += 1;
let mut sdepth = 1usize;
while i < input.len() && sdepth > 0 {
match input[i] {
b'\\' => i += 1, b'(' => sdepth += 1,
b')' => sdepth -= 1,
_ => {}
}
i += 1;
}
}
_ => i += 1,
}
}
None
}
fn rewrite_size(trailer: &[u8], size: usize) -> Vec<u8> {
let Some(p) = find_name_token(trailer, b"/Size") else {
return trailer.to_vec();
};
let mut out = Vec::with_capacity(trailer.len() + 4);
out.extend_from_slice(&trailer[..p + b"/Size".len()]);
let rest = &trailer[p + b"/Size".len()..];
let ws = rest
.iter()
.take_while(|&&b| b.is_ascii_whitespace())
.count();
let digits = rest[ws..].iter().take_while(|b| b.is_ascii_digit()).count();
out.extend_from_slice(&rest[..ws]);
out.extend_from_slice(size.to_string().as_bytes());
out.extend_from_slice(&rest[ws + digits..]);
out
}