use std::io::{Read, Seek};
use crate::overlay_annotations::DrMap;
use crate::parser::{is_delimiter, is_ws, Parser};
use crate::{Dictionary, Object, ObjectRef, Pdf, Result};
fn resource_type_for_operator(op: &[u8]) -> Option<&'static [u8]> {
Some(match op {
b"CS" | b"cs" => b"ColorSpace",
b"gs" => b"ExtGState",
b"Tf" => b"Font",
b"SCN" | b"scn" => b"Pattern",
b"BDC" | b"DP" => b"Properties",
b"sh" => b"Shading",
b"Do" => b"XObject",
_ => return None,
})
}
pub(crate) fn resource_replacer(content: &[u8], dr_map: &DrMap) -> Vec<u8> {
if dr_map.is_empty() {
return content.to_vec();
}
let mut out: Vec<u8> = Vec::with_capacity(content.len());
let mut last_name: Option<(usize, usize, Vec<u8>)> = None;
let mut pos = 0usize;
while pos < content.len() {
let byte = content[pos];
if is_ws(byte) {
let start = pos;
while pos < content.len() && is_ws(content[pos]) {
pos += 1;
}
out.extend_from_slice(&content[start..pos]);
continue;
}
if byte == b'%' {
let start = pos;
while pos < content.len() && !matches!(content[pos], b'\n' | b'\r') {
pos += 1;
}
out.extend_from_slice(&content[start..pos]);
continue;
}
if byte == b'/'
|| byte == b'('
|| byte == b'<'
|| byte == b'['
|| matches!(byte, b'+' | b'-' | b'.' | b'0'..=b'9')
{
let mut parser = Parser::new_no_reference(&content[pos..]);
match parser.parse_one_object() {
Ok(obj) => {
let end = pos + parser.position();
let out_start = out.len();
out.extend_from_slice(&content[pos..end]);
if let Object::Name(name) = obj {
last_name = Some((out_start, out.len(), name));
}
pos = end;
}
Err(_) => {
out.push(byte);
pos += 1;
}
}
continue;
}
let start = pos;
while pos < content.len() && !is_ws(content[pos]) && !is_delimiter(content[pos]) {
pos += 1;
}
if pos == start {
out.push(content[pos]);
pos += 1;
continue;
}
let op = &content[start..pos];
out.extend_from_slice(op);
if op == b"ID" {
if pos < content.len() {
out.push(content[pos]);
pos += 1;
}
let data_start = pos;
let ei_pos = find_inline_image_ei(content, data_start);
out.extend_from_slice(&content[data_start..ei_pos]);
pos = ei_pos;
continue;
}
if let Some(rtype) = resource_type_for_operator(op) {
if let Some((out_start, out_end, name)) = last_name.take() {
let renamed = dr_map.category(rtype).and_then(|m| m.get(name.as_slice()));
if let Some(new_name) = renamed {
let mut replacement = Vec::with_capacity(new_name.len() + 1);
replacement.push(b'/');
crate::object::write_name_escaped(&mut replacement, new_name);
out.splice(out_start..out_end, replacement);
}
} }
}
out
}
fn find_inline_image_ei(content: &[u8], data_start: usize) -> usize {
let mut last_candidate: Option<usize> = None;
let mut search_pos = data_start;
while let Some(i) = next_delimiter_bounded_ei(content, data_start, search_pos) {
last_candidate = Some(i);
if ei_lookahead_passes(&content[i + 2..]) {
return i;
}
search_pos = i + 2;
}
last_candidate.unwrap_or(content.len())
}
fn next_delimiter_bounded_ei(content: &[u8], data_start: usize, from: usize) -> Option<usize> {
let mut i = from;
while i + 1 < content.len() {
if content[i] == b'E'
&& content[i + 1] == b'I'
&& (i == data_start || is_ws(content[i - 1]))
&& (i + 2 >= content.len() || is_ws(content[i + 2]) || is_delimiter(content[i + 2]))
{
return Some(i);
}
i += 1;
}
None
}
fn ei_lookahead_passes(rest: &[u8]) -> bool {
let mut pos = 0usize;
for _ in 0..10 {
while pos < rest.len() && is_ws(rest[pos]) {
pos += 1;
}
if pos >= rest.len() {
return true;
}
let byte = rest[pos];
if byte == b'%' {
while pos < rest.len() && !matches!(rest[pos], b'\n' | b'\r') {
pos += 1;
}
continue;
}
if byte == b'/'
|| byte == b'('
|| byte == b'<'
|| byte == b'['
|| matches!(byte, b'+' | b'-' | b'.' | b'0'..=b'9')
{
let mut parser = Parser::new_no_reference(&rest[pos..]);
match parser.parse_one_object() {
Ok(_) => {
pos += parser.position();
continue;
}
Err(_) => return false,
}
}
if is_delimiter(byte) {
return false;
}
let start = pos;
while pos < rest.len() && !is_ws(rest[pos]) && !is_delimiter(rest[pos]) {
pos += 1;
}
let mut found_alpha = false;
let mut found_other = false;
for &ch in &rest[start..pos] {
if ch.is_ascii_alphabetic() || ch == b'*' {
found_alpha = true;
} else if (ch as i8) < 32 {
return false;
} else {
found_other = true;
}
}
if found_alpha && found_other {
return false;
}
}
true
}
pub(crate) fn adjust_appearance_stream<R: Read + Seek>(
dest: &mut Pdf<R>,
ap_stream_ref: ObjectRef,
dr_map: &DrMap,
) -> Result<()> {
if dr_map.is_empty() {
return Ok(());
}
let Object::Stream(mut stream) = dest.resolve(ap_stream_ref)? else {
return Ok(()); };
let Some(resources_val) = stream.dict.get("Resources").cloned() else {
return Ok(());
};
let (mut resources, was_indirect) = match resources_val {
Object::Dictionary(d) => (d, false),
Object::Reference(r) => match dest.resolve(r)?.into_dict() {
Some(d) => (d, true),
None => return Ok(()), },
_ => return Ok(()), };
let mut local_dr_map = dr_map.clone();
for category in dr_map.categories() {
let Some(renames) = dr_map.category(category) else {
continue; };
let existing = resources.get(category).cloned();
let mut subdict = match existing {
Some(Object::Dictionary(d)) => d,
Some(Object::Reference(r)) => dest.resolve(r)?.into_dict().unwrap_or_default(),
_ => Dictionary::new(),
};
let mut merge_with = Dictionary::new();
for (old_key, new_key) in renames {
if let Some(existing_new) = subdict.get(new_key.as_slice()).cloned() {
merge_with.insert(new_key.clone(), existing_new);
}
if let Some(existing_old) = subdict.remove(old_key) {
subdict.insert(new_key.clone(), existing_old);
}
}
if merge_with.iter().next().is_some() {
let staged: Vec<(Vec<u8>, Object)> = merge_with
.iter()
.map(|(k, v)| (k.to_vec(), v.clone()))
.collect();
let mut ref_to_key: Option<std::collections::HashMap<ObjectRef, Vec<u8>>> = None;
for (key, rval) in staged {
if subdict.get(key.as_slice()).is_none() {
subdict.insert(key, rval);
continue;
}
let snapshot = ref_to_key.get_or_insert_with(|| {
let mut m = std::collections::HashMap::new();
for (k, v) in subdict.iter() {
if let Some(r) = v.as_ref_id() {
m.insert(r, k.to_vec());
}
}
m
});
let reused = rval.as_ref_id().and_then(|r| snapshot.get(&r).cloned());
if let Some(existing_key) = reused {
if existing_key != key {
local_dr_map.insert_rename(category, key, existing_key);
}
} else {
let fresh_name = crate::overlay_annotations::unique_dr_name(&key, &subdict)?;
subdict.insert(fresh_name.clone(), rval);
local_dr_map.insert_rename(category, key, fresh_name);
}
}
}
resources.insert(category, Object::Dictionary(subdict));
}
let empty_categories: Vec<Vec<u8>> = resources
.iter()
.filter_map(|(key, value)| match value {
Object::Dictionary(d) if d.iter().next().is_none() => Some(key.to_vec()),
_ => None,
})
.collect();
for key in empty_categories {
resources.remove(&key);
}
if let Ok(decoded) = crate::filters::decode_stream_data(&stream.dict, &stream.data) {
let new_decoded = resource_replacer(&decoded, &local_dr_map);
match crate::filters::encode_stream_data(&stream.dict, &new_decoded) {
Ok(encoded) => {
stream.dict.insert(
"Length",
Object::Integer(i64::try_from(encoded.len()).unwrap_or(i64::MAX)),
);
stream.data = encoded;
}
Err(_) => {
let mut flate_dict = Dictionary::new();
flate_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
if let Ok(encoded) = crate::filters::encode_stream_data(&flate_dict, &new_decoded) {
stream.dict.remove("DecodeParms");
stream
.dict
.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
stream.dict.insert(
"Length",
Object::Integer(i64::try_from(encoded.len()).unwrap_or(i64::MAX)),
);
stream.data = encoded;
}
}
}
}
if was_indirect {
let new_ref = allocate_next_ref(dest)?;
dest.set_object(new_ref, Object::Dictionary(resources));
stream.dict.insert("Resources", Object::Reference(new_ref));
} else {
stream
.dict
.insert("Resources", Object::Dictionary(resources));
}
dest.set_object(ap_stream_ref, Object::Stream(stream));
Ok(())
}
fn allocate_next_ref<R: Read + Seek>(dest: &Pdf<R>) -> Result<ObjectRef> {
let n = dest
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| crate::Error::Unsupported("object-number space exhausted".to_string()))?;
Ok(ObjectRef::new(n, 0))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ObjectRef;
use std::io::Cursor;
fn dr_map_with(category: &[u8], old: &[u8], new: &[u8]) -> DrMap {
crate::overlay_annotations::DrMap::for_test(category, old, new)
}
#[test]
fn resource_replacer_empty_dr_map_is_identity() {
let dr_map = DrMap::new();
let content = b"/F1 18 Tf (hi) Tj";
assert_eq!(resource_replacer(content, &dr_map), content);
}
#[test]
fn resource_replacer_rewrites_tf_font_name() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content = b"/F1 18 Tf";
assert_eq!(resource_replacer(content, &dr_map), b"/F1_1 18 Tf");
}
#[test]
fn resource_replacer_name_not_in_dr_map_is_verbatim() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content = b"/F2 18 Tf";
assert_eq!(resource_replacer(content, &dr_map), content);
}
#[test]
fn resource_replacer_rewrites_even_when_name_absent_from_local_resources() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content = b"/F1 18 Tf";
assert_eq!(resource_replacer(content, &dr_map), b"/F1_1 18 Tf".to_vec());
}
#[test]
fn resource_replacer_name_inside_string_literal_is_verbatim() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content = b"(F1) Tj";
assert_eq!(resource_replacer(content, &dr_map), content);
}
#[test]
fn resource_replacer_preserves_whitespace_and_comments() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b" % a comment\n /F1 18 Tf ";
assert_eq!(
resource_replacer(content, &dr_map),
b" % a comment\n /F1_1 18 Tf ".to_vec()
);
}
#[test]
fn resource_replacer_recovers_from_malformed_token_midstream() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"/F1 18 Tf ) /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"/F1_1 18 Tf ) /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_recovers_from_operand_parse_error() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"(bad /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"(bad /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_do_xobject() {
let dr_map = dr_map_with(b"XObject", b"Fx1", b"Fx1_1");
assert_eq!(
resource_replacer(b"q /Fx1 Do Q", &dr_map),
b"q /Fx1_1 Do Q".to_vec()
);
}
#[test]
fn resource_replacer_gs_extgstate() {
let dr_map = dr_map_with(b"ExtGState", b"GS1", b"GS1_1");
assert_eq!(
resource_replacer(b"/GS1 gs", &dr_map),
b"/GS1_1 gs".to_vec()
);
}
#[test]
fn resource_replacer_sh_shading() {
let dr_map = dr_map_with(b"Shading", b"Sh1", b"Sh1_1");
assert_eq!(
resource_replacer(b"/Sh1 sh", &dr_map),
b"/Sh1_1 sh".to_vec()
);
}
#[test]
fn resource_replacer_cs_and_lowercase_cs_colorspace() {
let dr_map = dr_map_with(b"ColorSpace", b"CS1", b"CS1_1");
assert_eq!(
resource_replacer(b"/CS1 CS", &dr_map),
b"/CS1_1 CS".to_vec()
);
assert_eq!(
resource_replacer(b"/CS1 cs", &dr_map),
b"/CS1_1 cs".to_vec()
);
}
#[test]
fn resource_replacer_scn_and_lowercase_scn_pattern() {
let dr_map = dr_map_with(b"Pattern", b"P1", b"P1_1");
assert_eq!(
resource_replacer(b"1 0 0 /P1 SCN", &dr_map),
b"1 0 0 /P1_1 SCN".to_vec()
);
assert_eq!(
resource_replacer(b"1 0 0 /P1 scn", &dr_map),
b"1 0 0 /P1_1 scn".to_vec()
);
}
#[test]
fn resource_replacer_bdc_and_dp_properties_use_second_name() {
let dr_map = dr_map_with(b"Properties", b"P1", b"P1_1");
assert_eq!(
resource_replacer(b"/Span /P1 BDC", &dr_map),
b"/Span /P1_1 BDC".to_vec()
);
assert_eq!(
resource_replacer(b"/Span /P1 DP", &dr_map),
b"/Span /P1_1 DP".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_data_is_opaque() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] =
b"/F1 18 Tf BI /W 1 /H 1 /BPC 8 /CS /G ID \x01/F1 18 Tf\x02 EI /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"/F1_1 18 Tf BI /W 1 /H 1 /BPC 8 /CS /G ID \x01/F1 18 Tf\x02 EI /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_ei_followed_by_delimiter_not_whitespace() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI /W 1 ID \x01/F1 18 Tf\x02 EI/F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"BI /W 1 ID \x01/F1 18 Tf\x02 EI/F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_without_ei_copies_to_eof() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI /W 1 ID \x01/F1 18 Tf\x02";
assert_eq!(resource_replacer(content, &dr_map), content);
}
#[test]
fn resource_replacer_inline_image_rejects_fake_ei_via_lookahead() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"/F1 18 Tf BI /W 1 /H 1 /BPC 8 /CS /G ID \x01\x02 EI \xFFzzzz /F1 18 Tf \x05\x06 EI /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"/F1_1 18 Tf BI /W 1 /H 1 /BPC 8 /CS /G ID \x01\x02 EI \xFFzzzz /F1 18 Tf \x05\x06 EI /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_rejects_fake_ei_mixed_alpha_and_other_word() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI ID \x01 EI ab1 more /F1 18 Tf \x02 EI /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"BI ID \x01 EI ab1 more /F1 18 Tf \x02 EI /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_rejects_fake_ei_stray_delimiter() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI ID \x01 EI ) /F1 18 Tf \x02 EI /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"BI ID \x01 EI ) /F1 18 Tf \x02 EI /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_rejects_fake_ei_malformed_operand() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI ID \x01 EI (unterminated /F1 18 Tf \x02 EI /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"BI ID \x01 EI (unterminated /F1 18 Tf \x02 EI /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_lookahead_treats_comment_as_one_token() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI ID \x01 EI %trailing comment";
assert_eq!(resource_replacer(content, &dr_map), content);
}
#[test]
fn resource_replacer_inline_image_lookahead_ten_clean_tokens_accepts() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI ID \x01 EI 1 2 3 4 5 6 7 8 9 10 /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"BI ID \x01 EI 1 2 3 4 5 6 7 8 9 10 /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_inline_image_falls_back_to_last_rejected_candidate() {
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let content: &[u8] = b"BI ID \x01 EI \xFFbad /F1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"BI ID \x01 EI \xFFbad /F1_1 18 Tf".to_vec()
);
}
#[test]
fn resource_replacer_rewrites_a_rename_chain_independently_of_dict_state() {
let mut dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
dr_map.insert_rename(b"Font", b"F1_1".to_vec(), b"F1_1_1".to_vec());
let content: &[u8] = b"/F1 18 Tf /F1_1 18 Tf";
assert_eq!(
resource_replacer(content, &dr_map),
b"/F1_1 18 Tf /F1_1_1 18 Tf".to_vec()
);
}
fn minimal_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog >>\nendobj\n");
let xref_start = pdf.len() as u64;
pdf.extend_from_slice(
format!("xref\n0 2\n0000000000 65535 f \n{off1:010} 00000 n \n").as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 2 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n")
.as_bytes(),
);
pdf
}
fn open_minimal() -> Pdf<Cursor<Vec<u8>>> {
Pdf::open(Cursor::new(minimal_pdf_bytes())).expect("minimal pdf should parse")
}
fn set_dict<R: Read + Seek>(pdf: &mut Pdf<R>, n: u32, entries: &[(&str, Object)]) -> ObjectRef {
let mut d = Dictionary::new();
for (k, v) in entries {
d.insert(*k, v.clone());
}
let r = ObjectRef::new(n, 0);
pdf.set_object(r, Object::Dictionary(d));
r
}
fn set_stream<R: Read + Seek>(
pdf: &mut Pdf<R>,
n: u32,
entries: &[(&str, Object)],
data: &[u8],
) -> ObjectRef {
let mut d = Dictionary::new();
for (k, v) in entries {
d.insert(*k, v.clone());
}
let r = ObjectRef::new(n, 0);
pdf.set_object(r, Object::Stream(crate::Stream::new(d, data.to_vec())));
r
}
#[test]
fn adjust_appearance_stream_empty_dr_map_is_noop() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.set_object(font_ref, Object::Dictionary(Dictionary::new()));
let resources_ref = set_dict(
&mut pdf,
3,
&[(
"Font",
Object::Dictionary({
let mut d = Dictionary::new();
d.insert("F1", Object::Reference(font_ref));
d
}),
)],
);
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Reference(resources_ref))],
b"/F1 18 Tf",
);
adjust_appearance_stream(&mut pdf, ap_ref, &DrMap::new()).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1 18 Tf");
assert_eq!(
stream.dict.get("Resources"),
Some(&Object::Reference(resources_ref))
);
}
#[test]
fn adjust_appearance_stream_no_resources_is_noop() {
let mut pdf = open_minimal();
let ap_ref = set_stream(&mut pdf, 4, &[], b"/F1 18 Tf");
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1 18 Tf");
assert!(stream.dict.get("Resources").is_none());
}
#[test]
fn adjust_appearance_stream_rewrites_content_and_privatizes_indirect_resources() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.set_object(font_ref, Object::Dictionary(Dictionary::new()));
let resources_ref = set_dict(
&mut pdf,
3,
&[(
"Font",
Object::Dictionary({
let mut d = Dictionary::new();
d.insert("F1", Object::Reference(font_ref));
d
}),
)],
);
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Reference(resources_ref))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1_1 18 Tf");
let new_resources_ref = stream
.dict
.get_ref("Resources")
.expect("Resources should stay an indirect reference");
assert_ne!(
new_resources_ref, resources_ref,
"must be a FRESH private object, not the original shared one"
);
let new_font = pdf
.resolve(new_resources_ref)
.unwrap()
.into_dict()
.unwrap()
.get("Font")
.and_then(Object::as_dict)
.unwrap()
.clone();
assert_eq!(new_font.get("F1_1"), Some(&Object::Reference(font_ref)));
assert!(new_font.get("F1").is_none());
let orig_font = pdf
.resolve(resources_ref)
.unwrap()
.into_dict()
.unwrap()
.get("Font")
.and_then(Object::as_dict)
.unwrap()
.clone();
assert_eq!(orig_font.get("F1"), Some(&Object::Reference(font_ref)));
}
#[test]
fn adjust_appearance_stream_direct_resources_stays_direct() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.set_object(font_ref, Object::Dictionary(Dictionary::new()));
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(font_ref));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1_1 18 Tf");
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(font.get("F1_1"), Some(&Object::Reference(font_ref)));
}
#[test]
fn adjust_appearance_stream_ensures_and_drops_empty_category() {
let mut pdf = open_minimal();
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(Dictionary::new()));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"q Q",
);
let dr_map = dr_map_with(b"ExtGState", b"GS1", b"GS1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("expected direct Resources dict");
assert!(
resources.get("ExtGState").is_none(),
"empty /ExtGState sub-dict must be dropped, not left behind"
);
assert!(resources.get("Font").is_none());
}
#[test]
fn adjust_appearance_stream_rewrites_content_when_category_subdict_is_indirect() {
let mut pdf = open_minimal();
let font_ref = ObjectRef::new(5, 0);
pdf.set_object(font_ref, Object::Dictionary(Dictionary::new()));
let font_dict_ref = ObjectRef::new(6, 0);
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(font_ref));
pdf.set_object(font_dict_ref, Object::Dictionary(font_dict));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Reference(font_dict_ref));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1_1 18 Tf");
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(font.get_ref("F1_1"), Some(font_ref));
assert!(font.get("F1").is_none());
}
#[test]
fn adjust_appearance_stream_double_conflict_mints_fresh_local_name() {
let mut pdf = open_minimal();
let f1_font_ref = ObjectRef::new(5, 0);
pdf.set_object(f1_font_ref, Object::Dictionary(Dictionary::new()));
let f1_1_font_ref = ObjectRef::new(6, 0);
pdf.set_object(f1_1_font_ref, Object::Dictionary(Dictionary::new()));
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(f1_font_ref));
font_dict.insert("F1_1", Object::Reference(f1_1_font_ref));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1_1 18 Tf /F1_1_1 18 Tf");
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert!(font.get("F1").is_none());
assert_eq!(
font.get_ref("F1_1"),
Some(f1_font_ref),
"the renamed slot now holds F1's original value"
);
assert_eq!(
font.get_ref("F1_1_1"),
Some(f1_1_font_ref),
"the displaced original F1_1 value moved to the freshly minted name"
);
}
#[test]
fn adjust_appearance_stream_double_conflict_same_object_is_noop() {
let mut pdf = open_minimal();
let shared_font_ref = ObjectRef::new(5, 0);
pdf.set_object(shared_font_ref, Object::Dictionary(Dictionary::new()));
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(shared_font_ref));
font_dict.insert("F1_1", Object::Reference(shared_font_ref));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1_1 18 Tf /F1_1 18 Tf");
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert!(font.get("F1").is_none());
assert!(
font.get("F1_1_1").is_none(),
"no fresh name should be minted for a same-object collision"
);
assert_eq!(font.get_ref("F1_1"), Some(shared_font_ref));
}
#[test]
fn adjust_appearance_stream_unsupported_filter_is_non_fatal_noop() {
let mut pdf = open_minimal();
let mut font_dict = Dictionary::new();
font_dict.insert("F2", Object::Integer(1));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", Object::Dictionary(resources)),
("Filter", Object::Name(b"CCITTFaxDecode".to_vec())),
],
b"\x00\x01opaque-ccitt-bytes",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let result = adjust_appearance_stream(&mut pdf, ap_ref, &dr_map);
assert!(
result.is_ok(),
"an undecodable AP stream content must not fail the whole call"
);
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(
stream.data, b"\x00\x01opaque-ccitt-bytes",
"content bytes must be left exactly as read when they cannot be decoded"
);
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(
font.get("F2"),
Some(&Object::Integer(1)),
"unrelated existing key is untouched"
);
assert!(font.get("F1").is_none());
assert!(font.get("F1_1").is_none());
}
#[test]
fn adjust_appearance_stream_undecodable_filter_keeps_resources_rename_but_leaves_content_stale()
{
let mut pdf = open_minimal();
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Integer(1));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", Object::Dictionary(resources)),
("Filter", Object::Name(b"CCITTFaxDecode".to_vec())),
],
b"\x00\x01/F1 opaque-ccitt-bytes",
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
let result = adjust_appearance_stream(&mut pdf, ap_ref, &dr_map);
assert!(
result.is_ok(),
"an undecodable AP stream content must not fail the whole call"
);
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(
stream.data, b"\x00\x01/F1 opaque-ccitt-bytes",
"content bytes must be left exactly as read — qpdf does not roll \
back a rename it already applied to /Resources just because the \
later tokenize step failed"
);
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(
font.get("F1_1"),
Some(&Object::Integer(1)),
"the /Resources dict rename (steps 1-4) still applies even though \
the content (step 5) could not be rewritten"
);
assert!(font.get("F1").is_none());
}
#[test]
fn adjust_appearance_stream_rename_chain_matches_qpdf_verified_result() {
let mut pdf = open_minimal();
let f1_font_ref = ObjectRef::new(5, 0);
pdf.set_object(f1_font_ref, Object::Dictionary(Dictionary::new()));
let f1_1_font_ref = ObjectRef::new(6, 0);
pdf.set_object(f1_1_font_ref, Object::Dictionary(Dictionary::new()));
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(f1_font_ref));
font_dict.insert("F1_1", Object::Reference(f1_1_font_ref));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F1 18 Tf /F1_1 18 Tf",
);
let mut dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
dr_map.insert_rename(b"Font", b"F1_1".to_vec(), b"F1_1_1".to_vec());
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(stream.data, b"/F1_1 18 Tf /F1_1_1 18 Tf");
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert!(font.get("F1").is_none());
assert_eq!(
font.get_ref("F1_1"),
Some(f1_1_font_ref),
"the true original F1_1 value re-lands under its OWN name via the re-merge"
);
assert_eq!(
font.get_ref("F1_1_1"),
Some(f1_font_ref),
"F1's value ends up under F1_1_1, having been reprocessed by the second rename entry"
);
}
#[test]
fn adjust_appearance_stream_reuses_existing_key_for_same_object_on_new_conflict() {
let mut pdf = open_minimal();
let shared_ref = ObjectRef::new(5, 0);
pdf.set_object(shared_ref, Object::Dictionary(Dictionary::new()));
let other_ref = ObjectRef::new(6, 0);
pdf.set_object(other_ref, Object::Dictionary(Dictionary::new()));
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(shared_ref));
font_dict.insert("F2", Object::Reference(shared_ref));
font_dict.insert("F3", Object::Reference(other_ref));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F3 18 Tf /F2 18 Tf",
);
let dr_map = dr_map_with(b"Font", b"F3", b"F2");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(
stream.data, b"/F2 18 Tf /F1 18 Tf",
"F3 (now under F2) rewrites to /F2; the original /F2 token must \
follow its displaced value to wherever it actually ended up (F1), \
not stay pointing at F2 (now a different object) or lose the rename"
);
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(font.get_ref("F1"), Some(shared_ref));
assert_eq!(font.get_ref("F2"), Some(other_ref));
assert!(font.get("F3").is_none());
assert!(
font.get("F2_1").is_none(),
"no fresh name should be minted — the displaced value is REUSED \
under its existing F1 name, not aliased under a new one"
);
}
#[test]
fn adjust_appearance_stream_reuses_slot_vacated_earlier_in_same_merge() {
let mut pdf = open_minimal();
let shared_ref = ObjectRef::new(5, 0);
pdf.set_object(shared_ref, Object::Dictionary(Dictionary::new()));
let temp_ref = ObjectRef::new(6, 0);
pdf.set_object(temp_ref, Object::Dictionary(Dictionary::new()));
let other_ref = ObjectRef::new(7, 0);
pdf.set_object(other_ref, Object::Dictionary(Dictionary::new()));
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Reference(temp_ref));
font_dict.insert("F1_1", Object::Reference(shared_ref));
font_dict.insert("F2", Object::Reference(other_ref));
font_dict.insert("F4", Object::Reference(shared_ref));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let ap_ref = set_stream(
&mut pdf,
4,
&[("Resources", Object::Dictionary(resources))],
b"/F4 12 Tf",
);
let mut dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
dr_map.insert_rename(b"Font", b"F1_1".to_vec(), b"F3".to_vec());
dr_map.insert_rename(b"Font", b"F2".to_vec(), b"F4".to_vec());
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
assert_eq!(
stream.data, b"/F1_1 12 Tf",
"the /F4 token must follow shared_ref to wherever it actually \
ended up (F1_1, reused from the in-loop reinstate), not a \
freshly minted alias"
);
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(
font.get_ref("F1_1"),
Some(shared_ref),
"the vacated slot's own verbatim reinstate"
);
assert_eq!(
font.get_ref("F4"),
Some(other_ref),
"F4's occupant is untouched — the reuse branch never mutates \
subdict, unlike the fresh-mint branch"
);
assert!(
font.get("F4_1").is_none(),
"no fresh alias minted for F4 — it reuses F1_1 by ObjectRef \
identity instead"
);
}
fn pack_lzw_9bit_literal(bytes: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut buf: u32 = 0;
let mut bits: u32 = 0;
let mut codes: Vec<u16> = bytes.iter().map(|&b| u16::from(b)).collect();
codes.push(257); for code in codes {
buf = (buf << 9) | u32::from(code);
bits += 9;
while bits >= 8 {
bits -= 8;
out.push((buf >> bits) as u8);
}
}
if bits > 0 {
out.push((buf << (8 - bits)) as u8);
}
out
}
#[test]
fn adjust_appearance_stream_lzw_reencode_failure_falls_back_to_flate() {
let mut pdf = open_minimal();
let mut font_dict = Dictionary::new();
font_dict.insert("F1", Object::Integer(1));
let mut resources = Dictionary::new();
resources.insert("Font", Object::Dictionary(font_dict));
let lzw_bytes = pack_lzw_9bit_literal(b"/F1 18 Tf");
let ap_ref = set_stream(
&mut pdf,
4,
&[
("Resources", Object::Dictionary(resources)),
("Filter", Object::Name(b"LZWDecode".to_vec())),
],
&lzw_bytes,
);
let dr_map = dr_map_with(b"Font", b"F1", b"F1_1");
adjust_appearance_stream(&mut pdf, ap_ref, &dr_map).unwrap();
let stream = pdf.resolve(ap_ref).unwrap().into_stream().unwrap();
let resources = stream
.dict
.get("Resources")
.and_then(Object::as_dict)
.expect("Resources should stay a direct (embedded) dictionary");
let font = resources.get("Font").and_then(Object::as_dict).unwrap();
assert_eq!(font.get("F1_1"), Some(&Object::Integer(1)));
assert!(font.get("F1").is_none());
assert_eq!(
stream.dict.get("Filter"),
Some(&Object::Name(b"FlateDecode".to_vec())),
"un-re-encodable /LZWDecode must fall back to /FlateDecode"
);
assert!(
stream.dict.get("DecodeParms").is_none(),
"stale LZW /DecodeParms must not survive the filter swap"
);
let decoded_content =
crate::filters::decode_stream_data(&stream.dict, &stream.data).unwrap();
assert_eq!(
decoded_content, b"/F1_1 18 Tf",
"content must reference the RENAMED name, consistent with /Resources"
);
let expected_length = i64::try_from(stream.data.len()).unwrap();
assert_eq!(
stream.dict.get("Length"),
Some(&Object::Integer(expected_length)),
"/Length must match the newly re-encoded bytes"
);
}
}