mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 18:04:48 +00:00
270 lines
10 KiB
Rust
270 lines
10 KiB
Rust
//! Embedded Type 1 and CFF font programs in PostScript / EPS source.
|
|
|
|
/// A font program embedded in the PostScript source of an EPS file.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct EmbeddedFontProgram {
|
|
/// The PostScript `/FontName` when one is present in the source. CFF `StartData` blocks store
|
|
/// their name inside the CFF Name INDEX, which the font parser reads from `program`.
|
|
pub name: Option<String>,
|
|
/// The bytes of the Type 1 program or CFF font set.
|
|
pub program: Vec<u8>,
|
|
/// Whether `program` is a CFF font set rather than a Type 1 program.
|
|
pub cff: bool,
|
|
}
|
|
|
|
/// Embedded font programs in a PostScript section, in source order within each format.
|
|
///
|
|
/// Type 1 programs are recognized from their `eexec` and `cleartomark` delimiters and are named
|
|
/// by `/FontName`. CFF `StartData` blocks are returned without a name because the name is inside
|
|
/// the binary CFF data. Malformed or truncated blocks are skipped, as in the original EPS reader.
|
|
pub fn embedded_font_programs(ps: &[u8]) -> Vec<EmbeddedFontProgram> {
|
|
let mut out = Vec::new();
|
|
let mut heads = positions(ps, b"%!PS-AdobeFont");
|
|
heads.extend(positions(ps, b"%!FontType1"));
|
|
heads.sort_unstable();
|
|
let names = positions(ps, b"/FontName");
|
|
let mut from = 0;
|
|
let mut used = 0;
|
|
while let Some(ee) = find_eexec(ps, from) {
|
|
from = ee + 5;
|
|
let last_before = |v: &[usize]| v[..v.partition_point(|&p| p < ee)].last().copied().filter(|&p| p >= used);
|
|
// The fallback look-back stops at the previous font's end, so it cannot pick up its header.
|
|
let start = last_before(&heads).or_else(|| last_before(&names).map(|p| p.saturating_sub(512).max(used)));
|
|
let Some(start) = start else { continue };
|
|
let end = find_from(ps, b"cleartomark", ee).map_or(ps.len(), |p| p + 11);
|
|
if let Some(name) = name_after(&ps[start..ee], b"/FontName") {
|
|
out.push(EmbeddedFontProgram { name: Some(name), program: ps[start..end].to_vec(), cff: false });
|
|
}
|
|
from = end;
|
|
used = end;
|
|
}
|
|
|
|
let mut from = 0;
|
|
while let Some(sd) = find_from(ps, b"StartData", from) {
|
|
from = sd + 9;
|
|
let head = String::from_utf8_lossy(&ps[sd.saturating_sub(64)..sd]).into_owned();
|
|
let Some(len) = head.split_whitespace().last().and_then(|t| t.parse::<usize>().ok()) else { continue };
|
|
let s = sd + 10;
|
|
let Some(data) = ps.get(s..s.saturating_add(len)) else { continue };
|
|
out.push(EmbeddedFontProgram { name: None, program: data.to_vec(), cff: true });
|
|
from = s + len;
|
|
}
|
|
out
|
|
}
|
|
|
|
fn find_from(hay: &[u8], needle: &[u8], from: usize) -> Option<usize> {
|
|
hay.get(from..)?.windows(needle.len()).position(|w| w == needle).map(|p| p + from)
|
|
}
|
|
|
|
/// Find an executable `eexec` operator, ignoring comments, literal strings and names.
|
|
fn find_eexec(ps: &[u8], from: usize) -> Option<usize> {
|
|
let mut pos = from.min(ps.len());
|
|
while pos < ps.len() {
|
|
let c = ps[pos];
|
|
if is_white(c) {
|
|
pos += 1;
|
|
continue;
|
|
}
|
|
if c == b'%' {
|
|
let start = pos;
|
|
while pos < ps.len() && !matches!(ps[pos], b'\n' | b'\r') {
|
|
pos += 1;
|
|
}
|
|
let line = &ps[start..pos];
|
|
let marker: Option<&[u8]> = if line.starts_with(b"%%BeginData:") {
|
|
Some(b"%%EndData")
|
|
} else if line.starts_with(b"%%BeginBinary:") {
|
|
Some(b"%%EndBinary")
|
|
} else if line.starts_with(b"%%BeginPreview") {
|
|
Some(b"%%EndPreview")
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(marker) = marker {
|
|
let rest = ps.get(pos..)?;
|
|
pos = rest.windows(marker.len()).position(|window| window == marker).map_or(ps.len(), |offset| pos + offset);
|
|
}
|
|
continue;
|
|
}
|
|
if c == b'(' {
|
|
pos += 1;
|
|
let mut depth = 1usize;
|
|
while pos < ps.len() && depth > 0 {
|
|
match ps[pos] {
|
|
b'\\' => pos = pos.saturating_add(2).min(ps.len()),
|
|
b'(' => {
|
|
depth = depth.saturating_add(1);
|
|
pos += 1;
|
|
}
|
|
b')' => {
|
|
depth -= 1;
|
|
pos += 1;
|
|
}
|
|
_ => pos += 1,
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if c == b'<' {
|
|
match ps.get(pos + 1) {
|
|
Some(b'<') => pos += 2,
|
|
Some(b'~') => {
|
|
pos += 2;
|
|
pos = ps
|
|
.get(pos..)
|
|
.and_then(|rest| {
|
|
rest.windows(2).position(|window| window == b"~>").map(|offset| pos.saturating_add(offset).saturating_add(2))
|
|
})
|
|
.unwrap_or(ps.len());
|
|
}
|
|
_ => {
|
|
pos += 1;
|
|
while pos < ps.len() && ps[pos] != b'>' {
|
|
pos += 1;
|
|
}
|
|
pos = pos.saturating_add(1).min(ps.len());
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if c == b'/' {
|
|
pos += 1;
|
|
if ps.get(pos) == Some(&b'/') {
|
|
pos += 1;
|
|
}
|
|
while pos < ps.len() && !is_white(ps[pos]) && !is_delimiter(ps[pos]) {
|
|
pos += 1;
|
|
}
|
|
continue;
|
|
}
|
|
if is_delimiter(c) {
|
|
pos += 1;
|
|
continue;
|
|
}
|
|
let start = pos;
|
|
while pos < ps.len() && !is_white(ps[pos]) && !is_delimiter(ps[pos]) {
|
|
pos += 1;
|
|
}
|
|
if &ps[start..pos] == b"eexec" {
|
|
return Some(start);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn is_white(c: u8) -> bool {
|
|
matches!(c, 0 | 9 | 10 | 12 | 13 | 32)
|
|
}
|
|
|
|
fn is_delimiter(c: u8) -> bool {
|
|
matches!(c, b'(' | b')' | b'<' | b'>' | b'[' | b']' | b'{' | b'}' | b'/' | b'%')
|
|
}
|
|
|
|
fn positions(hay: &[u8], needle: &[u8]) -> Vec<usize> {
|
|
let mut out = vec![];
|
|
let mut from = 0;
|
|
while let Some(p) = find_from(hay, needle, from) {
|
|
out.push(p);
|
|
from = p + needle.len();
|
|
}
|
|
out
|
|
}
|
|
|
|
fn name_after(b: &[u8], key: &[u8]) -> Option<String> {
|
|
let p = find_from(b, key, 0)? + key.len();
|
|
let rest = &b[p..];
|
|
let s = rest.iter().position(|c| *c == b'/')? + 1;
|
|
let e = rest[s..].iter().position(|c| is_white(*c) || is_delimiter(*c)).map_or(rest.len(), |q| s + q);
|
|
(e > s).then(|| String::from_utf8_lossy(&rest[s..e]).into_owned())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
|
|
|
use super::embedded_font_programs;
|
|
|
|
#[test]
|
|
fn finds_type1_font_programs_by_name() {
|
|
let ps = b"%!PS-Adobe-3.0 EPSF-3.0\n%!PS-AdobeFont-1.0: Test\n/FontName /Test def\ncurrentfile eexec\n0000\ncleartomark\n";
|
|
let fonts = embedded_font_programs(ps);
|
|
assert_eq!(fonts.len(), 1);
|
|
assert_eq!(fonts[0].name.as_deref(), Some("Test"));
|
|
assert!(!fonts[0].cff);
|
|
assert!(String::from_utf8_lossy(&fonts[0].program).contains("cleartomark"));
|
|
}
|
|
|
|
#[test]
|
|
fn finds_cff_startdata_without_interpreting_its_name_index() {
|
|
let ps = b"%!PS-Adobe-3.0 EPSF-3.0\n10 StartData\n0123456789\n";
|
|
let fonts = embedded_font_programs(ps);
|
|
assert_eq!(fonts.len(), 1);
|
|
assert_eq!(fonts[0].name, None);
|
|
assert!(fonts[0].cff);
|
|
assert_eq!(fonts[0].program, b"0123456789");
|
|
}
|
|
|
|
#[test]
|
|
fn ignores_truncated_startdata() {
|
|
let fonts = embedded_font_programs(b"%!PS-Adobe-3.0 EPSF-3.0\n100 StartData\nshort");
|
|
assert!(fonts.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn many_headerless_eexec_words_do_not_hide_later_font() {
|
|
let mut ps = b"%!PS-Adobe-3.0 EPSF-3.0\n".to_vec();
|
|
ps.extend_from_slice(b"eexec ".repeat(20_000).as_slice());
|
|
ps.extend_from_slice(b"\n%!PS-AdobeFont-1.0: Real\n/FontName /Real def\ncurrentfile eexec\n0000\ncleartomark\n");
|
|
let fonts = embedded_font_programs(&ps);
|
|
assert_eq!(fonts.len(), 1);
|
|
assert_eq!(fonts[0].name.as_deref(), Some("Real"));
|
|
}
|
|
|
|
#[test]
|
|
fn headerless_font_does_not_reuse_previous_font_header() {
|
|
let first = b"%!PS-AdobeFont-1.0: A\n/FontName /A def\ncurrentfile eexec\n0000\ncleartomark\n";
|
|
let second = b"/FontName /B def\ncurrentfile eexec\n0000\ncleartomark\n";
|
|
let mut ps = b"%!PS-Adobe-3.0 EPSF-3.0\n".to_vec();
|
|
ps.extend_from_slice(first);
|
|
ps.extend_from_slice(second);
|
|
let fonts = embedded_font_programs(&ps);
|
|
assert_eq!(fonts.len(), 2);
|
|
let b = fonts.iter().find(|font| font.name.as_deref() == Some("B")).unwrap();
|
|
assert!(!String::from_utf8_lossy(&b.program).contains("AdobeFont"));
|
|
}
|
|
|
|
#[test]
|
|
fn eexec_in_comments_strings_names_and_font_names_is_not_an_operator() {
|
|
let ps = b"%!PS-Adobe-3.0 EPSF-3.0\n%!PS-AdobeFont-1.0: Test\n%% eexec in a comment\n%%BeginBinary: 10\neexec junk\n%%EndBinary\n/FontName /eexecTest def\n(nested (ignored eexec)) pop\n<6565786563> pop\n<~eexec~> pop\n/eexec def\ncurrentfile eexec\n0000\ncleartomark\n";
|
|
let fonts = embedded_font_programs(ps);
|
|
assert_eq!(fonts.len(), 1);
|
|
assert_eq!(fonts[0].name.as_deref(), Some("eexecTest"));
|
|
}
|
|
|
|
#[test]
|
|
fn font_name_stops_at_postscript_delimiters_and_comments() {
|
|
let ps = b"%!PS-AdobeFont-1.0: Test\n/FontName /Test%comment\n def\ncurrentfile eexec\n0000\ncleartomark\n";
|
|
let fonts = embedded_font_programs(ps);
|
|
assert_eq!(fonts.len(), 1);
|
|
assert_eq!(fonts[0].name.as_deref(), Some("Test"));
|
|
}
|
|
|
|
#[test]
|
|
fn font_names_stop_at_every_postscript_delimiter() {
|
|
for delimiter in b"()<>[]{}/%" {
|
|
let mut source = b"/FontName /Test".to_vec();
|
|
source.push(*delimiter);
|
|
source.extend_from_slice(b"ignored");
|
|
assert_eq!(super::name_after(&source, b"/FontName").as_deref(), Some("Test"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn literal_name_backslash_does_not_escape_a_comment_delimiter() {
|
|
let ps = b"%!PS-AdobeFont-1.0: Test\n/FontName /Test def\n/unused\\%(\npop\ncurrentfile eexec\n0000\ncleartomark\n";
|
|
let fonts = embedded_font_programs(ps);
|
|
assert_eq!(fonts.len(), 1);
|
|
assert_eq!(fonts[0].name.as_deref(), Some("Test"));
|
|
}
|
|
}
|