/src/skia/third_party/externals/harfbuzz/src/hb-ot-shape-complex-use.cc
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright © 2015 Mozilla Foundation. |
3 | | * Copyright © 2015 Google, Inc. |
4 | | * |
5 | | * This is part of HarfBuzz, a text shaping library. |
6 | | * |
7 | | * Permission is hereby granted, without written agreement and without |
8 | | * license or royalty fees, to use, copy, modify, and distribute this |
9 | | * software and its documentation for any purpose, provided that the |
10 | | * above copyright notice and the following two paragraphs appear in |
11 | | * all copies of this software. |
12 | | * |
13 | | * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
14 | | * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
15 | | * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
16 | | * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
17 | | * DAMAGE. |
18 | | * |
19 | | * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
20 | | * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
21 | | * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
22 | | * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
23 | | * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
24 | | * |
25 | | * Mozilla Author(s): Jonathan Kew |
26 | | * Google Author(s): Behdad Esfahbod |
27 | | */ |
28 | | |
29 | | #include "hb.hh" |
30 | | |
31 | | #ifndef HB_NO_OT_SHAPE |
32 | | |
33 | | #include "hb-ot-shape-complex-use-machine.hh" |
34 | | #include "hb-ot-shape-complex-use-table.hh" |
35 | | #include "hb-ot-shape-complex-arabic.hh" |
36 | | #include "hb-ot-shape-complex-arabic-joining-list.hh" |
37 | | #include "hb-ot-shape-complex-vowel-constraints.hh" |
38 | | |
39 | | |
40 | | /* |
41 | | * Universal Shaping Engine. |
42 | | * https://docs.microsoft.com/en-us/typography/script-development/use |
43 | | */ |
44 | | |
45 | | static const hb_tag_t |
46 | | use_basic_features[] = |
47 | | { |
48 | | /* |
49 | | * Basic features. |
50 | | * These features are applied all at once, before reordering, constrained |
51 | | * to the syllable. |
52 | | */ |
53 | | HB_TAG('r','k','r','f'), |
54 | | HB_TAG('a','b','v','f'), |
55 | | HB_TAG('b','l','w','f'), |
56 | | HB_TAG('h','a','l','f'), |
57 | | HB_TAG('p','s','t','f'), |
58 | | HB_TAG('v','a','t','u'), |
59 | | HB_TAG('c','j','c','t'), |
60 | | }; |
61 | | static const hb_tag_t |
62 | | use_topographical_features[] = |
63 | | { |
64 | | HB_TAG('i','s','o','l'), |
65 | | HB_TAG('i','n','i','t'), |
66 | | HB_TAG('m','e','d','i'), |
67 | | HB_TAG('f','i','n','a'), |
68 | | }; |
69 | | /* Same order as use_topographical_features. */ |
70 | | enum joining_form_t { |
71 | | JOINING_FORM_ISOL, |
72 | | JOINING_FORM_INIT, |
73 | | JOINING_FORM_MEDI, |
74 | | JOINING_FORM_FINA, |
75 | | _JOINING_FORM_NONE |
76 | | }; |
77 | | static const hb_tag_t |
78 | | use_other_features[] = |
79 | | { |
80 | | /* |
81 | | * Other features. |
82 | | * These features are applied all at once, after reordering and |
83 | | * clearing syllables. |
84 | | */ |
85 | | HB_TAG('a','b','v','s'), |
86 | | HB_TAG('b','l','w','s'), |
87 | | HB_TAG('h','a','l','n'), |
88 | | HB_TAG('p','r','e','s'), |
89 | | HB_TAG('p','s','t','s'), |
90 | | }; |
91 | | |
92 | | static void |
93 | | setup_syllables_use (const hb_ot_shape_plan_t *plan, |
94 | | hb_font_t *font, |
95 | | hb_buffer_t *buffer); |
96 | | static void |
97 | | record_rphf_use (const hb_ot_shape_plan_t *plan, |
98 | | hb_font_t *font, |
99 | | hb_buffer_t *buffer); |
100 | | static void |
101 | | record_pref_use (const hb_ot_shape_plan_t *plan, |
102 | | hb_font_t *font, |
103 | | hb_buffer_t *buffer); |
104 | | static void |
105 | | reorder_use (const hb_ot_shape_plan_t *plan, |
106 | | hb_font_t *font, |
107 | | hb_buffer_t *buffer); |
108 | | |
109 | | static void |
110 | | collect_features_use (hb_ot_shape_planner_t *plan) |
111 | 68 | { |
112 | 68 | hb_ot_map_builder_t *map = &plan->map; |
113 | | |
114 | | /* Do this before any lookups have been applied. */ |
115 | 68 | map->add_gsub_pause (setup_syllables_use); |
116 | | |
117 | | /* "Default glyph pre-processing group" */ |
118 | 68 | map->enable_feature (HB_TAG('l','o','c','l')); |
119 | 68 | map->enable_feature (HB_TAG('c','c','m','p')); |
120 | 68 | map->enable_feature (HB_TAG('n','u','k','t')); |
121 | 68 | map->enable_feature (HB_TAG('a','k','h','n'), F_MANUAL_ZWJ); |
122 | | |
123 | | /* "Reordering group" */ |
124 | 68 | map->add_gsub_pause (_hb_clear_substitution_flags); |
125 | 68 | map->add_feature (HB_TAG('r','p','h','f'), F_MANUAL_ZWJ); |
126 | 68 | map->add_gsub_pause (record_rphf_use); |
127 | 68 | map->add_gsub_pause (_hb_clear_substitution_flags); |
128 | 68 | map->enable_feature (HB_TAG('p','r','e','f'), F_MANUAL_ZWJ); |
129 | 68 | map->add_gsub_pause (record_pref_use); |
130 | | |
131 | | /* "Orthographic unit shaping group" */ |
132 | 544 | for (unsigned int i = 0; i < ARRAY_LENGTH (use_basic_features); i++) |
133 | 476 | map->enable_feature (use_basic_features[i], F_MANUAL_ZWJ); |
134 | | |
135 | 68 | map->add_gsub_pause (reorder_use); |
136 | 68 | map->add_gsub_pause (_hb_clear_syllables); |
137 | | |
138 | | /* "Topographical features" */ |
139 | 340 | for (unsigned int i = 0; i < ARRAY_LENGTH (use_topographical_features); i++) |
140 | 272 | map->add_feature (use_topographical_features[i]); |
141 | 68 | map->add_gsub_pause (nullptr); |
142 | | |
143 | | /* "Standard typographic presentation" */ |
144 | 408 | for (unsigned int i = 0; i < ARRAY_LENGTH (use_other_features); i++) |
145 | 340 | map->enable_feature (use_other_features[i], F_MANUAL_ZWJ); |
146 | 68 | } |
147 | | |
148 | | struct use_shape_plan_t |
149 | | { |
150 | | hb_mask_t rphf_mask; |
151 | | |
152 | | arabic_shape_plan_t *arabic_plan; |
153 | | }; |
154 | | |
155 | | static void * |
156 | | data_create_use (const hb_ot_shape_plan_t *plan) |
157 | 68 | { |
158 | 68 | use_shape_plan_t *use_plan = (use_shape_plan_t *) hb_calloc (1, sizeof (use_shape_plan_t)); |
159 | 68 | if (unlikely (!use_plan)) |
160 | 0 | return nullptr; |
161 | | |
162 | 68 | use_plan->rphf_mask = plan->map.get_1_mask (HB_TAG('r','p','h','f')); |
163 | | |
164 | 68 | if (has_arabic_joining (plan->props.script)) |
165 | 15 | { |
166 | 15 | use_plan->arabic_plan = (arabic_shape_plan_t *) data_create_arabic (plan); |
167 | 15 | if (unlikely (!use_plan->arabic_plan)) |
168 | 0 | { |
169 | 0 | hb_free (use_plan); |
170 | 0 | return nullptr; |
171 | 0 | } |
172 | 68 | } |
173 | | |
174 | 68 | return use_plan; |
175 | 68 | } |
176 | | |
177 | | static void |
178 | | data_destroy_use (void *data) |
179 | 68 | { |
180 | 68 | use_shape_plan_t *use_plan = (use_shape_plan_t *) data; |
181 | | |
182 | 68 | if (use_plan->arabic_plan) |
183 | 15 | data_destroy_arabic (use_plan->arabic_plan); |
184 | | |
185 | 68 | hb_free (data); |
186 | 68 | } |
187 | | |
188 | | static void |
189 | | setup_masks_use (const hb_ot_shape_plan_t *plan, |
190 | | hb_buffer_t *buffer, |
191 | | hb_font_t *font HB_UNUSED) |
192 | 15.7k | { |
193 | 15.7k | const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data; |
194 | | |
195 | | /* Do this before allocating use_category(). */ |
196 | 15.7k | if (use_plan->arabic_plan) |
197 | 3.73k | { |
198 | 3.73k | setup_masks_arabic_plan (use_plan->arabic_plan, buffer, plan->props.script); |
199 | 3.73k | } |
200 | | |
201 | 15.7k | HB_BUFFER_ALLOCATE_VAR (buffer, use_category); |
202 | | |
203 | | /* We cannot setup masks here. We save information about characters |
204 | | * and setup masks later on in a pause-callback. */ |
205 | | |
206 | 15.7k | unsigned int count = buffer->len; |
207 | 15.7k | hb_glyph_info_t *info = buffer->info; |
208 | 298k | for (unsigned int i = 0; i < count; i++) |
209 | 282k | info[i].use_category() = hb_use_get_category (info[i].codepoint); |
210 | 15.7k | } |
211 | | |
212 | | static void |
213 | | setup_rphf_mask (const hb_ot_shape_plan_t *plan, |
214 | | hb_buffer_t *buffer) |
215 | 15.7k | { |
216 | 15.7k | const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data; |
217 | | |
218 | 15.7k | hb_mask_t mask = use_plan->rphf_mask; |
219 | 15.7k | if (!mask) return; |
220 | | |
221 | 0 | hb_glyph_info_t *info = buffer->info; |
222 | |
|
223 | 0 | foreach_syllable (buffer, start, end) |
224 | 0 | { |
225 | 0 | unsigned int limit = info[start].use_category() == USE(R) ? 1 : hb_min (3u, end - start); |
226 | 0 | for (unsigned int i = start; i < start + limit; i++) |
227 | 0 | info[i].mask |= mask; |
228 | 0 | } |
229 | 0 | } |
230 | | |
231 | | static void |
232 | | setup_topographical_masks (const hb_ot_shape_plan_t *plan, |
233 | | hb_buffer_t *buffer) |
234 | 15.7k | { |
235 | 15.7k | const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data; |
236 | 15.7k | if (use_plan->arabic_plan) |
237 | 3.73k | return; |
238 | | |
239 | 12.0k | static_assert ((JOINING_FORM_INIT < 4 && JOINING_FORM_ISOL < 4 && JOINING_FORM_MEDI < 4 && JOINING_FORM_FINA < 4), ""); |
240 | 12.0k | hb_mask_t masks[4], all_masks = 0; |
241 | 60.2k | for (unsigned int i = 0; i < 4; i++) |
242 | 48.1k | { |
243 | 48.1k | masks[i] = plan->map.get_1_mask (use_topographical_features[i]); |
244 | 48.1k | if (masks[i] == plan->map.get_global_mask ()) |
245 | 0 | masks[i] = 0; |
246 | 48.1k | all_masks |= masks[i]; |
247 | 48.1k | } |
248 | 12.0k | if (!all_masks) |
249 | 12.0k | return; |
250 | 0 | hb_mask_t other_masks = ~all_masks; |
251 | |
|
252 | 0 | unsigned int last_start = 0; |
253 | 0 | joining_form_t last_form = _JOINING_FORM_NONE; |
254 | 0 | hb_glyph_info_t *info = buffer->info; |
255 | 0 | foreach_syllable (buffer, start, end) |
256 | 0 | { |
257 | 0 | use_syllable_type_t syllable_type = (use_syllable_type_t) (info[start].syllable() & 0x0F); |
258 | 0 | switch (syllable_type) |
259 | 0 | { |
260 | 0 | case use_independent_cluster: |
261 | 0 | case use_symbol_cluster: |
262 | 0 | case use_hieroglyph_cluster: |
263 | 0 | case use_non_cluster: |
264 | | /* These don't join. Nothing to do. */ |
265 | 0 | last_form = _JOINING_FORM_NONE; |
266 | 0 | break; |
267 | |
|
268 | 0 | case use_virama_terminated_cluster: |
269 | 0 | case use_sakot_terminated_cluster: |
270 | 0 | case use_standard_cluster: |
271 | 0 | case use_number_joiner_terminated_cluster: |
272 | 0 | case use_numeral_cluster: |
273 | 0 | case use_broken_cluster: |
274 | |
|
275 | 0 | bool join = last_form == JOINING_FORM_FINA || last_form == JOINING_FORM_ISOL; |
276 | |
|
277 | 0 | if (join) |
278 | 0 | { |
279 | | /* Fixup previous syllable's form. */ |
280 | 0 | last_form = last_form == JOINING_FORM_FINA ? JOINING_FORM_MEDI : JOINING_FORM_INIT; |
281 | 0 | for (unsigned int i = last_start; i < start; i++) |
282 | 0 | info[i].mask = (info[i].mask & other_masks) | masks[last_form]; |
283 | 0 | } |
284 | | |
285 | | /* Form for this syllable. */ |
286 | 0 | last_form = join ? JOINING_FORM_FINA : JOINING_FORM_ISOL; |
287 | 0 | for (unsigned int i = start; i < end; i++) |
288 | 0 | info[i].mask = (info[i].mask & other_masks) | masks[last_form]; |
289 | |
|
290 | 0 | break; |
291 | 0 | } |
292 | | |
293 | 0 | last_start = start; |
294 | 0 | } |
295 | 0 | } |
296 | | |
297 | | static void |
298 | | setup_syllables_use (const hb_ot_shape_plan_t *plan, |
299 | | hb_font_t *font HB_UNUSED, |
300 | | hb_buffer_t *buffer) |
301 | 15.7k | { |
302 | 15.7k | find_syllables_use (buffer); |
303 | 15.7k | foreach_syllable (buffer, start, end) |
304 | 239k | buffer->unsafe_to_break (start, end); |
305 | 15.7k | setup_rphf_mask (plan, buffer); |
306 | 15.7k | setup_topographical_masks (plan, buffer); |
307 | 15.7k | } |
308 | | |
309 | | static void |
310 | | record_rphf_use (const hb_ot_shape_plan_t *plan, |
311 | | hb_font_t *font HB_UNUSED, |
312 | | hb_buffer_t *buffer) |
313 | 15.7k | { |
314 | 15.7k | const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data; |
315 | | |
316 | 15.7k | hb_mask_t mask = use_plan->rphf_mask; |
317 | 15.7k | if (!mask) return; |
318 | 0 | hb_glyph_info_t *info = buffer->info; |
319 | |
|
320 | 0 | foreach_syllable (buffer, start, end) |
321 | 0 | { |
322 | | /* Mark a substituted repha as USE(R). */ |
323 | 0 | for (unsigned int i = start; i < end && (info[i].mask & mask); i++) |
324 | 0 | if (_hb_glyph_info_substituted (&info[i])) |
325 | 0 | { |
326 | 0 | info[i].use_category() = USE(R); |
327 | 0 | break; |
328 | 0 | } |
329 | 0 | } |
330 | 0 | } |
331 | | |
332 | | static void |
333 | | record_pref_use (const hb_ot_shape_plan_t *plan HB_UNUSED, |
334 | | hb_font_t *font HB_UNUSED, |
335 | | hb_buffer_t *buffer) |
336 | 15.7k | { |
337 | 15.7k | hb_glyph_info_t *info = buffer->info; |
338 | | |
339 | 15.7k | foreach_syllable (buffer, start, end) |
340 | 239k | { |
341 | | /* Mark a substituted pref as VPre, as they behave the same way. */ |
342 | 522k | for (unsigned int i = start; i < end; i++) |
343 | 282k | if (_hb_glyph_info_substituted (&info[i])) |
344 | 0 | { |
345 | 0 | info[i].use_category() = USE(VPre); |
346 | 0 | break; |
347 | 0 | } |
348 | 239k | } |
349 | 15.7k | } |
350 | | |
351 | | static inline bool |
352 | | is_halant_use (const hb_glyph_info_t &info) |
353 | 95.5k | { |
354 | 95.5k | return (info.use_category() == USE(H) || info.use_category() == USE(HVM)) && |
355 | 64 | !_hb_glyph_info_ligated (&info); |
356 | 95.5k | } |
357 | | |
358 | | static void |
359 | | reorder_syllable_use (hb_buffer_t *buffer, unsigned int start, unsigned int end) |
360 | 239k | { |
361 | 239k | use_syllable_type_t syllable_type = (use_syllable_type_t) (buffer->info[start].syllable() & 0x0F); |
362 | | /* Only a few syllable types need reordering. */ |
363 | 239k | if (unlikely (!(FLAG_UNSAFE (syllable_type) & |
364 | 239k | (FLAG (use_virama_terminated_cluster) | |
365 | 239k | FLAG (use_sakot_terminated_cluster) | |
366 | 239k | FLAG (use_standard_cluster) | |
367 | 239k | FLAG (use_broken_cluster) | |
368 | 239k | 0)))) |
369 | 147k | return; |
370 | | |
371 | 91.9k | hb_glyph_info_t *info = buffer->info; |
372 | | |
373 | 0 | #define POST_BASE_FLAGS64 (FLAG64 (USE(FAbv)) | \ |
374 | 0 | FLAG64 (USE(FBlw)) | \ |
375 | 0 | FLAG64 (USE(FPst)) | \ |
376 | 0 | FLAG64 (USE(MAbv)) | \ |
377 | 0 | FLAG64 (USE(MBlw)) | \ |
378 | 0 | FLAG64 (USE(MPst)) | \ |
379 | 0 | FLAG64 (USE(MPre)) | \ |
380 | 0 | FLAG64 (USE(VAbv)) | \ |
381 | 0 | FLAG64 (USE(VBlw)) | \ |
382 | 0 | FLAG64 (USE(VPst)) | \ |
383 | 0 | FLAG64 (USE(VPre)) | \ |
384 | 0 | FLAG64 (USE(VMAbv)) | \ |
385 | 0 | FLAG64 (USE(VMBlw)) | \ |
386 | 0 | FLAG64 (USE(VMPst)) | \ |
387 | 0 | FLAG64 (USE(VMPre))) |
388 | | |
389 | | /* Move things forward. */ |
390 | 91.9k | if (info[start].use_category() == USE(R) && end - start > 1) |
391 | 0 | { |
392 | | /* Got a repha. Reorder it towards the end, but before the first post-base |
393 | | * glyph. */ |
394 | 0 | for (unsigned int i = start + 1; i < end; i++) |
395 | 0 | { |
396 | 0 | bool is_post_base_glyph = (FLAG64_UNSAFE (info[i].use_category()) & POST_BASE_FLAGS64) || |
397 | 0 | is_halant_use (info[i]); |
398 | 0 | if (is_post_base_glyph || i == end - 1) |
399 | 0 | { |
400 | | /* If we hit a post-base glyph, move before it; otherwise move to the |
401 | | * end. Shift things in between backward. */ |
402 | |
|
403 | 0 | if (is_post_base_glyph) |
404 | 0 | i--; |
405 | |
|
406 | 0 | buffer->merge_clusters (start, i + 1); |
407 | 0 | hb_glyph_info_t t = info[start]; |
408 | 0 | memmove (&info[start], &info[start + 1], (i - start) * sizeof (info[0])); |
409 | 0 | info[i] = t; |
410 | |
|
411 | 0 | break; |
412 | 0 | } |
413 | 0 | } |
414 | 0 | } |
415 | | |
416 | | /* Move things back. */ |
417 | 91.9k | unsigned int j = start; |
418 | 187k | for (unsigned int i = start; i < end; i++) |
419 | 95.5k | { |
420 | 95.5k | uint32_t flag = FLAG_UNSAFE (info[i].use_category()); |
421 | 95.5k | if (is_halant_use (info[i])) |
422 | 64 | { |
423 | | /* If we hit a halant, move after it; otherwise move to the beginning, and |
424 | | * shift things in between forward. */ |
425 | 64 | j = i + 1; |
426 | 64 | } |
427 | 95.5k | else if (((flag) & (FLAG (USE(VPre)) | FLAG (USE(VMPre)))) && |
428 | | /* Only move the first component of a MultipleSubst. */ |
429 | 5.49k | 0 == _hb_glyph_info_get_lig_comp (&info[i]) && |
430 | 5.49k | j < i) |
431 | 665 | { |
432 | 665 | buffer->merge_clusters (j, i + 1); |
433 | 665 | hb_glyph_info_t t = info[i]; |
434 | 665 | memmove (&info[j + 1], &info[j], (i - j) * sizeof (info[0])); |
435 | 665 | info[j] = t; |
436 | 665 | } |
437 | 95.5k | } |
438 | 91.9k | } |
439 | | |
440 | | static void |
441 | | reorder_use (const hb_ot_shape_plan_t *plan, |
442 | | hb_font_t *font, |
443 | | hb_buffer_t *buffer) |
444 | 15.7k | { |
445 | 15.7k | if (buffer->message (font, "start reordering USE")) |
446 | 15.7k | { |
447 | 15.7k | hb_syllabic_insert_dotted_circles (font, buffer, |
448 | 15.7k | use_broken_cluster, |
449 | 15.7k | USE(B), |
450 | 15.7k | USE(R)); |
451 | | |
452 | 15.7k | foreach_syllable (buffer, start, end) |
453 | 239k | reorder_syllable_use (buffer, start, end); |
454 | | |
455 | 15.7k | (void) buffer->message (font, "end reordering USE"); |
456 | 15.7k | } |
457 | | |
458 | 15.7k | HB_BUFFER_DEALLOCATE_VAR (buffer, use_category); |
459 | 15.7k | } |
460 | | |
461 | | |
462 | | static void |
463 | | preprocess_text_use (const hb_ot_shape_plan_t *plan, |
464 | | hb_buffer_t *buffer, |
465 | | hb_font_t *font) |
466 | 15.7k | { |
467 | 15.7k | _hb_preprocess_text_vowel_constraints (plan, buffer, font); |
468 | 15.7k | } |
469 | | |
470 | | static bool |
471 | | compose_use (const hb_ot_shape_normalize_context_t *c, |
472 | | hb_codepoint_t a, |
473 | | hb_codepoint_t b, |
474 | | hb_codepoint_t *ab) |
475 | 22.4k | { |
476 | | /* Avoid recomposing split matras. */ |
477 | 22.4k | if (HB_UNICODE_GENERAL_CATEGORY_IS_MARK (c->unicode->general_category (a))) |
478 | 755 | return false; |
479 | | |
480 | 21.6k | return (bool)c->unicode->compose (a, b, ab); |
481 | 21.6k | } |
482 | | |
483 | | |
484 | | const hb_ot_complex_shaper_t _hb_ot_complex_shaper_use = |
485 | | { |
486 | | collect_features_use, |
487 | | nullptr, /* override_features */ |
488 | | data_create_use, |
489 | | data_destroy_use, |
490 | | preprocess_text_use, |
491 | | nullptr, /* postprocess_glyphs */ |
492 | | HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT, |
493 | | nullptr, /* decompose */ |
494 | | compose_use, |
495 | | setup_masks_use, |
496 | | HB_TAG_NONE, /* gpos_tag */ |
497 | | nullptr, /* reorder_marks */ |
498 | | HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY, |
499 | | false, /* fallback_position */ |
500 | | }; |
501 | | |
502 | | |
503 | | #endif |