Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/harfbuzz/src/OT/Layout/GSUB/SubstLookup.hh @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 #ifndef OT_LAYOUT_GSUB_SUBSTLOOKUP_HH
2 #define OT_LAYOUT_GSUB_SUBSTLOOKUP_HH
3
4 #include "Common.hh"
5 #include "SubstLookupSubTable.hh"
6
7 namespace OT {
8 namespace Layout {
9 namespace GSUB_impl {
10
11 struct SubstLookup : Lookup
12 {
13 using SubTable = SubstLookupSubTable;
14
15 bool sanitize (hb_sanitize_context_t *c) const
16 { return Lookup::sanitize<SubTable> (c); }
17
18 const SubTable& get_subtable (unsigned int i) const
19 { return Lookup::get_subtable<SubTable> (i); }
20
21 static inline bool lookup_type_is_reverse (unsigned int lookup_type)
22 { return lookup_type == SubTable::ReverseChainSingle; }
23
24 bool is_reverse () const
25 {
26 unsigned int type = get_type ();
27 if (unlikely (type == SubTable::Extension))
28 return get_subtable (0).u.extension.is_reverse ();
29 return lookup_type_is_reverse (type);
30 }
31
32 bool may_have_non_1to1 () const
33 {
34 hb_have_non_1to1_context_t c;
35 return dispatch (&c);
36 }
37
38 bool apply (hb_ot_apply_context_t *c) const
39 {
40 TRACE_APPLY (this);
41 return_trace (dispatch (c));
42 }
43
44 bool intersects (const hb_set_t *glyphs) const
45 {
46 hb_intersects_context_t c (glyphs);
47 return dispatch (&c);
48 }
49
50 hb_closure_context_t::return_t closure (hb_closure_context_t *c, unsigned int this_index) const
51 {
52 if (!c->should_visit_lookup (this_index))
53 return hb_closure_context_t::default_return_value ();
54
55 c->set_recurse_func (dispatch_closure_recurse_func);
56
57 hb_closure_context_t::return_t ret = dispatch (c);
58
59 c->flush ();
60
61 return ret;
62 }
63
64 hb_closure_lookups_context_t::return_t closure_lookups (hb_closure_lookups_context_t *c, unsigned this_index) const
65 {
66 if (c->is_lookup_visited (this_index))
67 return hb_closure_lookups_context_t::default_return_value ();
68
69 c->set_lookup_visited (this_index);
70 if (!intersects (c->glyphs))
71 {
72 c->set_lookup_inactive (this_index);
73 return hb_closure_lookups_context_t::default_return_value ();
74 }
75
76 hb_closure_lookups_context_t::return_t ret = dispatch (c);
77 return ret;
78 }
79
80 hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
81 {
82 c->set_recurse_func (dispatch_recurse_func<hb_collect_glyphs_context_t>);
83 return dispatch (c);
84 }
85
86 template <typename set_t>
87 void collect_coverage (set_t *glyphs) const
88 {
89 hb_collect_coverage_context_t<set_t> c (glyphs);
90 dispatch (&c);
91 }
92
93 bool would_apply (hb_would_apply_context_t *c,
94 const hb_ot_layout_lookup_accelerator_t *accel) const
95 {
96 if (unlikely (!c->len)) return false;
97 if (!accel->may_have (c->glyphs[0])) return false;
98 return dispatch (c);
99 }
100
101 template<typename Glyphs, typename Substitutes,
102 hb_requires (hb_is_sorted_source_of (Glyphs,
103 const hb_codepoint_t) &&
104 hb_is_source_of (Substitutes,
105 const hb_codepoint_t))>
106 bool serialize_single (hb_serialize_context_t *c,
107 uint32_t lookup_props,
108 Glyphs glyphs,
109 Substitutes substitutes)
110 {
111 TRACE_SERIALIZE (this);
112 if (unlikely (!Lookup::serialize (c, SubTable::Single, lookup_props, 1))) return_trace (false);
113 if (c->push<SubTable> ()->u.single.serialize (c, hb_zip (glyphs, substitutes)))
114 {
115 c->add_link (get_subtables<SubTable> ()[0], c->pop_pack ());
116 return_trace (true);
117 }
118 c->pop_discard ();
119 return_trace (false);
120 }
121
122 template<typename Iterator,
123 hb_requires (hb_is_sorted_iterator (Iterator))>
124 bool serialize (hb_serialize_context_t *c,
125 uint32_t lookup_props,
126 Iterator it)
127 {
128 TRACE_SERIALIZE (this);
129 if (unlikely (!Lookup::serialize (c, SubTable::Multiple, lookup_props, 1))) return_trace (false);
130 if (c->push<SubTable> ()->u.multiple.
131 serialize (c, it))
132 {
133 c->add_link (get_subtables<SubTable> ()[0], c->pop_pack ());
134 return_trace (true);
135 }
136 c->pop_discard ();
137 return_trace (false);
138 }
139
140 bool serialize_alternate (hb_serialize_context_t *c,
141 uint32_t lookup_props,
142 hb_sorted_array_t<const HBGlyphID16> glyphs,
143 hb_array_t<const unsigned int> alternate_len_list,
144 hb_array_t<const HBGlyphID16> alternate_glyphs_list)
145 {
146 TRACE_SERIALIZE (this);
147 if (unlikely (!Lookup::serialize (c, SubTable::Alternate, lookup_props, 1))) return_trace (false);
148
149 if (c->push<SubTable> ()->u.alternate.
150 serialize (c,
151 glyphs,
152 alternate_len_list,
153 alternate_glyphs_list))
154 {
155 c->add_link (get_subtables<SubTable> ()[0], c->pop_pack ());
156 return_trace (true);
157 }
158 c->pop_discard ();
159 return_trace (false);
160 }
161
162 bool serialize_ligature (hb_serialize_context_t *c,
163 uint32_t lookup_props,
164 hb_sorted_array_t<const HBGlyphID16> first_glyphs,
165 hb_array_t<const unsigned int> ligature_per_first_glyph_count_list,
166 hb_array_t<const HBGlyphID16> ligatures_list,
167 hb_array_t<const unsigned int> component_count_list,
168 hb_array_t<const HBGlyphID16> component_list /* Starting from second for each ligature */)
169 {
170 TRACE_SERIALIZE (this);
171 if (unlikely (!Lookup::serialize (c, SubTable::Ligature, lookup_props, 1))) return_trace (false);
172 if (c->push<SubTable> ()->u.ligature.
173 serialize (c,
174 first_glyphs,
175 ligature_per_first_glyph_count_list,
176 ligatures_list,
177 component_count_list,
178 component_list))
179 {
180 c->add_link (get_subtables<SubTable> ()[0], c->pop_pack ());
181 return_trace (true);
182 }
183 c->pop_discard ();
184 return_trace (false);
185 }
186
187 template <typename context_t>
188 static inline typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
189
190 static inline typename hb_closure_context_t::return_t closure_glyphs_recurse_func (hb_closure_context_t *c, unsigned lookup_index, hb_set_t *covered_seq_indices, unsigned seq_index, unsigned end_index);
191
192 static inline hb_closure_context_t::return_t dispatch_closure_recurse_func (hb_closure_context_t *c, unsigned lookup_index, hb_set_t *covered_seq_indices, unsigned seq_index, unsigned end_index)
193 {
194 if (!c->should_visit_lookup (lookup_index))
195 return hb_empty_t ();
196
197 hb_closure_context_t::return_t ret = closure_glyphs_recurse_func (c, lookup_index, covered_seq_indices, seq_index, end_index);
198
199 /* While in theory we should flush here, it will cause timeouts because a recursive
200 * lookup can keep growing the glyph set. Skip, and outer loop will retry up to
201 * HB_CLOSURE_MAX_STAGES time, which should be enough for every realistic font. */
202 //c->flush ();
203
204 return ret;
205 }
206
207 template <typename context_t, typename ...Ts>
208 typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
209 { return Lookup::dispatch<SubTable> (c, std::forward<Ts> (ds)...); }
210
211 bool subset (hb_subset_context_t *c) const
212 { return Lookup::subset<SubTable> (c); }
213 };
214
215
216 }
217 }
218 }
219
220 #endif /* OT_LAYOUT_GSUB_SUBSTLOOKUP_HH */