1use 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 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 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 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 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 pub fn original_script_list(&self) -> Option<Result<ScriptList<'a>, ReadError>> {
55 self.script_list_offset().resolve(self.offset_data())
56 }
57
58 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 pub fn original_feature_list(&self) -> Option<Result<FeatureList<'a>, ReadError>> {
67 self.feature_list_offset().resolve(self.offset_data())
68 }
69
70 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 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
91pub type SubstitutionLookupList<'a> = super::layout::SelectedLookupList<'a, SubstitutionLookup<'a>>;
93
94pub type OriginalSubstitutionLookupList<'a> = super::layout::LookupList<'a, SubstitutionLookup<'a>>;
96
97pub type SubstitutionLookupList2<'a> = super::layout::LookupList2<'a, SubstitutionLookup<'a>>;
99
100pub type SubstitutionSequenceContext<'a> = super::layout::SequenceContext<'a>;
102
103pub 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
114pub 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 EmptyExtension,
129}
130
131impl<'a> SubstitutionLookup<'a> {
132 pub fn lookup_flag(&self) -> LookupFlag {
133 self.of_unit_type().lookup_flag()
134 }
135
136 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 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 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 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}