use crate::error::{ParseError, RawTag};
use alloc::string::String;
use alloc::vec::Vec;
pub(crate) const TAG: RawTag = *b"name";
const RECORD: usize = 12;
pub mod name_id {
pub const COPYRIGHT: u16 = 0;
pub const FAMILY: u16 = 1;
pub const SUBFAMILY: u16 = 2;
pub const UNIQUE_ID: u16 = 3;
pub const FULL_NAME: u16 = 4;
pub const VERSION: u16 = 5;
pub const POSTSCRIPT: u16 = 6;
pub const TRADEMARK: u16 = 7;
pub const MANUFACTURER: u16 = 8;
pub const DESIGNER: u16 = 9;
pub const DESCRIPTION: u16 = 10;
pub const VENDOR_URL: u16 = 11;
pub const DESIGNER_URL: u16 = 12;
pub const LICENSE: u16 = 13;
pub const LICENSE_URL: u16 = 14;
pub const PREFERRED_FAMILY: u16 = 16;
pub const PREFERRED_SUBFAMILY: u16 = 17;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NameRecord<'a> {
pub platform_id: u16,
pub encoding_id: u16,
pub language_id: u16,
pub name_id: u16,
pub bytes: &'a [u8],
}
impl NameRecord<'_> {
#[must_use]
pub const fn is_windows(self) -> bool {
self.platform_id == 3
}
#[must_use]
pub fn to_str(&self) -> Option<&str> {
core::str::from_utf8(self.bytes).ok()
}
#[must_use]
pub fn decode(&self) -> String {
if self.is_windows() {
let mut units = Vec::with_capacity(self.bytes.len() / 2);
for c in self.bytes.chunks_exact(2) {
if let Ok(pair) = <[u8; 2]>::try_from(c) {
units.push(u16::from_be_bytes(pair));
}
}
String::from_utf16_lossy(&units)
} else {
self.bytes.iter().map(|&b| b as char).collect()
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NameTable<'a> {
data: &'a [u8],
count: u16,
string_offset: usize,
}
impl<'a> NameTable<'a> {
pub fn parse(data: &'a [u8]) -> Result<Self, ParseError> {
if data.len() < 6 {
return Err(ParseError::TruncatedTable {
tag: TAG,
expected: 6,
got: data.len(),
});
}
let count = crate::reader::be_u16_at(data, 2, TAG)?;
let string_offset = usize::from(crate::reader::be_u16_at(data, 4, TAG)?);
let end = 6usize
.checked_add(
usize::from(count)
.checked_mul(RECORD)
.ok_or(ParseError::InvalidGlyphFormat)?,
)
.ok_or(ParseError::InvalidGlyphFormat)?;
if end > data.len() {
return Err(ParseError::TruncatedTable {
tag: TAG,
expected: end,
got: data.len(),
});
}
Ok(Self {
data,
count,
string_offset,
})
}
#[must_use]
pub fn as_bytes(&self) -> &'a [u8] {
self.data
}
pub fn format(&self) -> Result<u16, ParseError> {
crate::reader::be_u16_at(self.data, 0, TAG)
}
#[must_use]
pub const fn count(&self) -> u16 {
self.count
}
pub fn records(&self) -> Result<Vec<NameRecord<'a>>, ParseError> {
let mut out = Vec::with_capacity(usize::from(self.count));
for i in 0..usize::from(self.count) {
out.push(self.record_at(i)?);
}
Ok(out)
}
fn record_at(&self, i: usize) -> Result<NameRecord<'a>, ParseError> {
let at = 6 + i * RECORD;
let platform_id = crate::reader::be_u16_at(self.data, at, TAG)?;
let encoding_id = crate::reader::be_u16_at(self.data, at + 2, TAG)?;
let language_id = crate::reader::be_u16_at(self.data, at + 4, TAG)?;
let name_id = crate::reader::be_u16_at(self.data, at + 6, TAG)?;
let length = usize::from(crate::reader::be_u16_at(self.data, at + 8, TAG)?);
let offset = usize::from(crate::reader::be_u16_at(self.data, at + 10, TAG)?);
let base = self
.string_offset
.checked_add(offset)
.ok_or(ParseError::InvalidGlyphFormat)?;
let bytes = crate::reader::slice_at(self.data, base, length, TAG)?;
Ok(NameRecord {
platform_id,
encoding_id,
language_id,
name_id,
bytes,
})
}
#[must_use]
pub fn get(&self, id: u16) -> Option<NameRecord<'a>> {
let mut best: Option<(u8, NameRecord<'a>)> = None;
for i in 0..usize::from(self.count) {
let rec = self.record_at(i).ok()?;
if rec.name_id != id {
continue;
}
let score = match rec.platform_id {
3 => 3,
0 => 2,
1 => 1,
_ => 0,
};
best = match best {
None => Some((score, rec)),
Some((s, _)) if score > s => Some((score, rec)),
other => other,
};
}
best.map(|(_, rec)| rec)
}
#[must_use]
pub fn family(&self) -> Option<String> {
self.get(name_id::FAMILY).map(|r| r.decode())
}
#[must_use]
pub fn subfamily(&self) -> Option<String> {
self.get(name_id::SUBFAMILY).map(|r| r.decode())
}
#[must_use]
pub fn full_name(&self) -> Option<String> {
self.get(name_id::FULL_NAME).map(|r| r.decode())
}
#[must_use]
pub fn postscript_name(&self) -> Option<String> {
self.get(name_id::POSTSCRIPT).map(|r| r.decode())
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)]
use super::{name_id, NameTable};
use alloc::vec::Vec;
fn sample() -> Vec<u8> {
let mut d = Vec::new();
d.extend_from_slice(&0u16.to_be_bytes()); d.extend_from_slice(&2u16.to_be_bytes()); let string_offset = 6u16 + 2 * 12;
d.extend_from_slice(&string_offset.to_be_bytes());
d.extend_from_slice(&3u16.to_be_bytes());
d.extend_from_slice(&1u16.to_be_bytes());
d.extend_from_slice(&0x0409u16.to_be_bytes());
d.extend_from_slice(&name_id::FAMILY.to_be_bytes());
d.extend_from_slice(&8u16.to_be_bytes()); d.extend_from_slice(&0u16.to_be_bytes()); d.extend_from_slice(&1u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(&0u16.to_be_bytes());
d.extend_from_slice(&name_id::POSTSCRIPT.to_be_bytes());
d.extend_from_slice(&12u16.to_be_bytes());
d.extend_from_slice(&8u16.to_be_bytes());
d.extend_from_slice(&[0x00, 0x54, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74]); d.extend_from_slice(b"Test-Regular");
d
}
#[test]
fn reads_records_and_helpers() {
let d = sample();
let n = NameTable::parse(&d).unwrap();
assert_eq!(n.count(), 2);
assert_eq!(n.format().unwrap(), 0);
assert_eq!(n.family().as_deref(), Some("Test"));
assert_eq!(n.postscript_name().as_deref(), Some("Test-Regular"));
assert!(n.subfamily().is_none());
let fam = n.get(name_id::FAMILY).unwrap();
assert!(fam.is_windows());
assert_eq!(fam.decode(), "Test");
let recs = n.records().unwrap();
assert_eq!(recs.len(), 2);
assert_eq!(recs[1].to_str(), Some("Test-Regular"));
}
#[test]
fn errors() {
assert_eq!(
NameTable::parse(&[0u8; 5]),
Err(crate::ParseError::TruncatedTable {
tag: *b"name",
expected: 6,
got: 5
})
);
let mut d = sample();
d.truncate(20);
assert!(NameTable::parse(&d).is_err());
let mut d = sample();
d.truncate(35);
let n = NameTable::parse(&d).unwrap();
assert!(n.records().is_err());
assert!(n.get(super::name_id::FAMILY).is_none());
}
}