use std::collections::BTreeMap;
use std::sync::OnceLock;
pub fn unicode(name: &str) -> Option<String> {
let base = name.split('.').next().unwrap_or(name);
if base.is_empty() {
return None;
}
if base.contains('_') {
let mut out = String::new();
for piece in base.split('_') {
out.push_str(&unicode(piece)?);
}
return Some(out);
}
if let Some(text) = constructed(base) {
return Some(text);
}
table().get(base).cloned()
}
fn constructed(name: &str) -> Option<String> {
if let Some(digits) = name.strip_prefix("uni") {
if digits.len() >= 4
&& digits.len() % 4 == 0
&& digits.chars().all(|c| c.is_ascii_hexdigit())
{
let mut out = String::new();
for chunk in digits.as_bytes().chunks(4) {
let value = u32::from_str_radix(std::str::from_utf8(chunk).ok()?, 16).ok()?;
out.push(char::from_u32(value)?);
}
return Some(out);
}
}
if let Some(digits) = name.strip_prefix('u') {
if (4..=6).contains(&digits.len()) && digits.chars().all(|c| c.is_ascii_hexdigit()) {
let value = u32::from_str_radix(digits, 16).ok()?;
return char::from_u32(value).map(String::from);
}
}
None
}
fn built_in_table() -> BTreeMap<String, String> {
let mut out = BTreeMap::new();
for letter in ('A'..='Z').chain('a'..='z') {
out.insert(letter.to_string(), letter.to_string());
}
for (name, text) in BUILT_IN {
out.insert(name.to_string(), text.to_string());
}
out
}
fn table() -> &'static BTreeMap<String, String> {
static TABLE: OnceLock<BTreeMap<String, String>> = OnceLock::new();
TABLE.get_or_init(|| {
let mut out = built_in_table();
if let Some(text) = installed_list() {
for line in text.lines() {
if line.starts_with('#') {
continue;
}
let Some((name, values)) = line.split_once(';') else {
continue;
};
let text: Option<String> = values
.split_whitespace()
.map(|value| u32::from_str_radix(value, 16).ok().and_then(char::from_u32))
.collect();
if let Some(text) = text {
out.insert(name.to_string(), text);
}
}
}
out
})
}
fn installed_list() -> Option<String> {
let found = std::process::Command::new("kpsewhich")
.arg("glyphlist.txt")
.output()
.ok()?;
let path = String::from_utf8_lossy(&found.stdout).trim().to_string();
std::fs::read_to_string(path).ok()
}
const BUILT_IN: &[(&str, &str)] = &[
("space", " "),
("exclam", "!"),
("quotedbl", "\""),
("numbersign", "#"),
("dollar", "$"),
("percent", "%"),
("ampersand", "&"),
("quotesingle", "'"),
("quoteright", "\u{2019}"),
("quoteleft", "\u{2018}"),
("parenleft", "("),
("parenright", ")"),
("asterisk", "*"),
("plus", "+"),
("comma", ","),
("hyphen", "-"),
("period", "."),
("slash", "/"),
("zero", "0"),
("one", "1"),
("two", "2"),
("three", "3"),
("four", "4"),
("five", "5"),
("six", "6"),
("seven", "7"),
("eight", "8"),
("nine", "9"),
("colon", ":"),
("semicolon", ";"),
("less", "<"),
("equal", "="),
("greater", ">"),
("question", "?"),
("at", "@"),
("bracketleft", "["),
("backslash", "\\"),
("bracketright", "]"),
("asciicircum", "^"),
("underscore", "_"),
("grave", "`"),
("braceleft", "{"),
("bar", "|"),
("braceright", "}"),
("asciitilde", "~"),
("endash", "\u{2013}"),
("emdash", "\u{2014}"),
("quotedblleft", "\u{201c}"),
("quotedblright", "\u{201d}"),
("dotlessi", "\u{131}"),
("ff", "\u{fb00}"),
("fi", "\u{fb01}"),
("fl", "\u{fb02}"),
("ffi", "\u{fb03}"),
("ffl", "\u{fb04}"),
];
pub fn to_unicode_wide(name: &str, codes: &[(u16, String)]) -> String {
let mut out = String::new();
out.push_str(
"/CIDInit /ProcSet findresource begin\n\
12 dict begin\n\
begincmap\n\
/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n",
);
out.push_str(&format!("/CMapName /{name} def\n/CMapType 2 def\n"));
out.push_str("1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n");
for block in codes.chunks(100) {
out.push_str(&format!("{} beginbfchar\n", block.len()));
for (code, text) in block {
let utf16: String = text
.encode_utf16()
.map(|unit| format!("{unit:04X}"))
.collect();
out.push_str(&format!("<{code:04X}> <{utf16}>\n"));
}
out.push_str("endbfchar\n");
}
out.push_str("endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");
out
}
pub fn to_unicode(name: &str, codes: &[(u8, String)]) -> String {
let mut out = String::new();
out.push_str(
"/CIDInit /ProcSet findresource begin\n\
12 dict begin\n\
begincmap\n\
/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n",
);
out.push_str(&format!("/CMapName /{name} def\n/CMapType 2 def\n"));
out.push_str("1 begincodespacerange\n<00> <FF>\nendcodespacerange\n");
for block in codes.chunks(100) {
out.push_str(&format!("{} beginbfchar\n", block.len()));
for (code, text) in block {
let utf16: String = text
.encode_utf16()
.map(|unit| format!("{unit:04X}"))
.collect();
out.push_str(&format!("<{code:02X}> <{utf16}>\n"));
}
out.push_str("endbfchar\n");
}
out.push_str("endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n");
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_constructed_name_says_which_character_it_is() {
assert_eq!(unicode("uni0041").as_deref(), Some("A"));
assert_eq!(unicode("uni00E9").as_deref(), Some("\u{e9}"));
assert_eq!(unicode("uni004100420043").as_deref(), Some("ABC"));
assert_eq!(unicode("u1D400").as_deref(), Some("\u{1d400}"));
assert_eq!(unicode("u0041").as_deref(), Some("A"));
assert_eq!(unicode("a.sc").as_deref(), Some("a"));
assert_eq!(unicode("one.oldstyle").as_deref(), Some("1"));
assert_eq!(unicode("uni0041.alt").as_deref(), Some("A"));
assert_eq!(unicode("f_f_i").as_deref(), Some("ffi"));
assert_eq!(unicode("a_b").as_deref(), Some("ab"));
assert_eq!(unicode(".notdef"), None);
assert_eq!(unicode("cid42"), None);
assert_eq!(unicode("uni00G1"), None);
assert_eq!(unicode("u12"), None);
assert_eq!(unicode(""), None);
}
#[test]
fn the_names_resolve_without_a_tex_installation() {
let built = built_in_table();
for name in [
"A",
"a",
"Z",
"z",
"space",
"quoteright",
"ff",
"ffl",
"dotlessi",
] {
assert!(
built.contains_key(name),
"{name} needs glyphlist.txt to resolve"
);
}
assert_eq!(built.get("A").map(String::as_str), Some("A"));
assert_eq!(built.get("z").map(String::as_str), Some("z"));
assert_eq!(built.get("1"), None);
assert_eq!(built.get("one").map(String::as_str), Some("1"));
}
#[test]
fn the_names_a_tex_font_uses_are_known() {
assert_eq!(unicode("space").as_deref(), Some(" "));
assert_eq!(unicode("A").as_deref(), Some("A"));
assert_eq!(unicode("ff").as_deref(), Some("\u{fb00}"));
assert_eq!(unicode("fi").as_deref(), Some("\u{fb01}"));
assert_eq!(unicode("ffl").as_deref(), Some("\u{fb04}"));
assert_eq!(unicode("quoteright").as_deref(), Some("\u{2019}"));
assert_eq!(unicode("endash").as_deref(), Some("\u{2013}"));
assert_eq!(unicode("dotlessi").as_deref(), Some("\u{131}"));
}
#[test]
fn a_map_is_written_in_blocks_a_reader_accepts() {
let codes: Vec<(u8, String)> = (b'A'..=b'C')
.map(|code| (code, (code as char).to_string()))
.collect();
let map = to_unicode("Test", &codes);
assert!(map.contains("/CMapName /Test def"), "{map}");
assert!(map.contains("/CMapType 2 def"), "{map}");
assert!(map.contains("<00> <FF>"), "{map}");
assert!(map.contains("3 beginbfchar\n"), "{map}");
assert!(map.contains("<41> <0041>"), "{map}");
assert!(map.ends_with("end\nend\n"), "{map}");
let map = to_unicode("Wide", &[(1, "\u{1d400}".to_string())]);
assert!(map.contains("<01> <D835DC00>"), "{map}");
let many: Vec<(u8, String)> = (0..=255u8).map(|c| (c, "x".to_string())).collect();
let map = to_unicode("Many", &many);
assert_eq!(map.matches("beginbfchar\n").count(), 3, "{}", map.len());
assert_eq!(map.matches("100 beginbfchar\n").count(), 2);
assert_eq!(map.matches("56 beginbfchar\n").count(), 1);
assert_eq!(map.matches("endbfchar\n").count(), 3);
}
#[test]
fn the_installations_glyph_list_is_read_when_it_is_there() {
if installed_list().is_none() {
return;
}
assert_eq!(unicode("eacute").as_deref(), Some("\u{e9}"));
assert_eq!(unicode("Adieresis").as_deref(), Some("\u{c4}"));
assert_eq!(unicode("germandbls").as_deref(), Some("\u{df}"));
assert_eq!(unicode("Omega").as_deref(), Some("\u{2126}"));
assert!(unicode("Ohm").is_none() || unicode("Ohm").is_some());
}
}