Skip to main content

read_fonts/tables/
gsub.rs

1//! the [GSUB] table
2//!
3//! [GSUB]: https://docs.microsoft.com/en-us/typography/opentype/spec/gsub
4
5use super::layout::header::HeaderOffset;
6pub use super::layout::{
7    ChainedSequenceContext, ClassDef, CoverageTable, Device, FeatureList, FeatureVariations,
8    Lookup, LookupList, ScriptList, SequenceContext,
9};
10use super::layout::{ExtensionLookup, LookupFlag, SelectedLookupList, Subtables};
11
12#[cfg(feature = "std")]
13mod closure;
14#[cfg(test)]
15#[path = "../tests/test_gsub.rs"]
16mod tests;
17
18use crate::types::Compatible;
19
20include!("../../generated/generated_gsub.rs");
21
22impl<'a> Gsub<'a> {
23    /// The offset to the script list, original or extended.
24    pub(crate) fn selected_script_list_offset(&self) -> Result<HeaderOffset, ReadError> {
25        self.select_offset(self.script_list_offset(), self.script_list2_offset())
26    }
27
28    /// The offset to the feature list, original or extended.
29    pub(crate) fn selected_feature_list_offset(&self) -> Result<HeaderOffset, ReadError> {
30        self.select_offset(self.feature_list_offset(), self.feature_list2_offset())
31    }
32
33    /// The offset to the lookup list, original or extended.
34    pub(crate) fn selected_lookup_list_offset(&self) -> Result<HeaderOffset, ReadError> {
35        self.select_offset(self.lookup_list_offset(), self.lookup_list2_offset())
36    }
37
38    fn select_offset(
39        &self,
40        original: Nullable<Offset16>,
41        extended: Option<Nullable<Offset32>>,
42    ) -> Result<HeaderOffset, ReadError> {
43        HeaderOffset::select(original, extended, self.version().compatible((1, 2)))
44    }
45
46    /// Resolves the table, preferring the 32-bit offset when it is nonzero.
47    pub fn script_list(&self) -> Result<ScriptList<'a>, ReadError> {
48        self.selected_script_list_offset()?
49            .offset()
50            .resolve(self.offset_data())
51    }
52
53    /// Resolves the original 16-bit offset without applying precedence.
54    pub fn original_script_list(&self) -> Option<Result<ScriptList<'a>, ReadError>> {
55        self.script_list_offset().resolve(self.offset_data())
56    }
57
58    /// Resolves the table, preferring the 32-bit offset when it is nonzero.
59    pub fn feature_list(&self) -> Result<FeatureList<'a>, ReadError> {
60        self.selected_feature_list_offset()?
61            .offset()
62            .resolve(self.offset_data())
63    }
64
65    /// Resolves the original 16-bit offset without applying precedence.
66    pub fn original_feature_list(&self) -> Option<Result<FeatureList<'a>, ReadError>> {
67        self.feature_list_offset().resolve(self.offset_data())
68    }
69
70    /// Resolves the lookup list, preferring LookupList2 when its offset is nonzero.
71    pub fn lookup_list(&self) -> Result<SubstitutionLookupList<'a>, ReadError> {
72        let data = self.offset_data();
73        match self.selected_lookup_list_offset()? {
74            HeaderOffset::Original(offset) => {
75                offset.resolve(data).map(SelectedLookupList::Original)
76            }
77            HeaderOffset::Extended(offset) => {
78                offset.resolve(data).map(SelectedLookupList::Extended)
79            }
80        }
81    }
82
83    /// Resolves the original 16-bit lookup-list offset.
84    pub fn original_lookup_list(
85        &self,
86    ) -> Option<Result<OriginalSubstitutionLookupList<'a>, ReadError>> {
87        self.lookup_list_offset().resolve(self.offset_data())
88    }
89}
90
91/// The GSUB lookup list selected by the header.
92pub type SubstitutionLookupList<'a> = super::layout::SelectedLookupList<'a, SubstitutionLookup<'a>>;
93
94/// A lookup list with the original 16-bit offsets.
95pub type OriginalSubstitutionLookupList<'a> = super::layout::LookupList<'a, SubstitutionLookup<'a>>;
96
97/// A lookup list with 32-bit offsets.
98pub type SubstitutionLookupList2<'a> = super::layout::LookupList2<'a, SubstitutionLookup<'a>>;
99
100/// A GSUB [SequenceContext]
101pub type SubstitutionSequenceContext<'a> = super::layout::SequenceContext<'a>;
102
103/// A GSUB [ChainedSequenceContext]
104pub type SubstitutionChainContext<'a> = super::layout::ChainedSequenceContext<'a>;
105
106impl<'a, T: FontRead<'a, Args = ()>> ExtensionLookup<'a, T> for ExtensionSubstFormat1<'a, T> {
107    fn extension(&self) -> Result<T, ReadError> {
108        self.extension()
109    }
110}
111
112type SubSubtables<'a, T> = Subtables<'a, T, ExtensionSubstFormat1<'a, T>>;
113
114/// The subtables from a GPOS lookup.
115///
116/// This type is a convenience that removes the need to dig into the
117/// [`SubstitutionLookup`] enum in order to access subtables, and it also abstracts
118/// away the distinction between extension and non-extension lookups.
119pub enum SubstitutionSubtables<'a> {
120    Single(SubSubtables<'a, SingleSubst<'a>>),
121    Multiple(SubSubtables<'a, MultipleSubst<'a>>),
122    Alternate(SubSubtables<'a, AlternateSubst<'a>>),
123    Ligature(SubSubtables<'a, LigatureSubst<'a>>),
124    Contextual(SubSubtables<'a, SubstitutionSequenceContext<'a>>),
125    ChainContextual(SubSubtables<'a, SubstitutionChainContext<'a>>),
126    Reverse(SubSubtables<'a, ReverseChainSingleSubst<'a>>),
127    /// An extension lookup did not have any subtables
128    EmptyExtension,
129}
130
131impl<'a> SubstitutionLookup<'a> {
132    pub fn lookup_flag(&self) -> LookupFlag {
133        self.of_unit_type().lookup_flag()
134    }
135
136    /// Different enumerations for GSUB and GPOS
137    pub fn lookup_type(&self) -> u16 {
138        self.of_unit_type().lookup_type()
139    }
140
141    pub fn mark_filtering_set(&self) -> Option<u16> {
142        self.of_unit_type().mark_filtering_set()
143    }
144
145    /// Return the subtables for this lookup.
146    ///
147    /// This method handles both extension and non-extension lookups, and saves
148    /// the caller needing to dig into the `SubstitutionLookup` enum itself.
149    pub fn subtables(&self) -> Result<SubstitutionSubtables<'a>, ReadError> {
150        let raw_lookup = self.of_unit_type();
151        let offsets = raw_lookup.subtable_offsets();
152        let data = raw_lookup.offset_data();
153        match raw_lookup.lookup_type() {
154            1 => Ok(SubstitutionSubtables::Single(Subtables::new(offsets, data))),
155            2 => Ok(SubstitutionSubtables::Multiple(Subtables::new(
156                offsets, data,
157            ))),
158            3 => Ok(SubstitutionSubtables::Alternate(Subtables::new(
159                offsets, data,
160            ))),
161            4 => Ok(SubstitutionSubtables::Ligature(Subtables::new(
162                offsets, data,
163            ))),
164            5 => Ok(SubstitutionSubtables::Contextual(Subtables::new(
165                offsets, data,
166            ))),
167            6 => Ok(SubstitutionSubtables::ChainContextual(Subtables::new(
168                offsets, data,
169            ))),
170            8 => Ok(SubstitutionSubtables::Reverse(Subtables::new(
171                offsets, data,
172            ))),
173            7 => {
174                // look through subtable offsets to try and find a lookup type.
175                // this is robust in the case where the first subtable offset is
176                // malformed, but a later one is okay.
177                let Some(lookup_type) = offsets.iter().find_map(|off| {
178                    off.get()
179                        .resolve::<ExtensionSubstFormat1<()>>(data)
180                        .ok()
181                        .map(|ext| ext.extension_lookup_type())
182                }) else {
183                    return Ok(SubstitutionSubtables::EmptyExtension);
184                };
185
186                match lookup_type {
187                    1 => Ok(SubstitutionSubtables::Single(Subtables::new_ext(
188                        offsets, data,
189                    ))),
190                    2 => Ok(SubstitutionSubtables::Multiple(Subtables::new_ext(
191                        offsets, data,
192                    ))),
193                    3 => Ok(SubstitutionSubtables::Alternate(Subtables::new_ext(
194                        offsets, data,
195                    ))),
196                    4 => Ok(SubstitutionSubtables::Ligature(Subtables::new_ext(
197                        offsets, data,
198                    ))),
199                    5 => Ok(SubstitutionSubtables::Contextual(Subtables::new_ext(
200                        offsets, data,
201                    ))),
202                    6 => Ok(SubstitutionSubtables::ChainContextual(Subtables::new_ext(
203                        offsets, data,
204                    ))),
205                    8 => Ok(SubstitutionSubtables::Reverse(Subtables::new_ext(
206                        offsets, data,
207                    ))),
208                    other => Err(ReadError::InvalidFormat(other as _)),
209                }
210            }
211            other => Err(ReadError::InvalidFormat(other as _)),
212        }
213    }
214}
215
216impl<'a> MultipleSubst<'a> {
217    /// Returns the coverage table of either format.
218    pub fn coverage(&self) -> Result<CoverageTable<'a>, ReadError> {
219        match self {
220            Self::Format1(t) => t.coverage(),
221            Self::Format2(t) => t.coverage(),
222        }
223    }
224}