2 * Copyright © 2007,2008,2009,2010 Red Hat, Inc.
3 * Copyright © 2010,2012 Google, Inc.
5 * This is part of HarfBuzz, a text shaping library.
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.
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
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.
25 * Red Hat Author(s): Behdad Esfahbod
26 * Google Author(s): Behdad Esfahbod
29 #ifndef HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH
30 #define HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH
32 #include "hb-buffer-private.hh"
33 #include "hb-ot-layout-gdef-table.hh"
34 #include "hb-set-private.hh"
40 #ifndef HB_DEBUG_CLOSURE
41 #define HB_DEBUG_CLOSURE (HB_DEBUG+0)
44 #define TRACE_CLOSURE(this) \
45 hb_auto_trace_t<HB_DEBUG_CLOSURE, hb_void_t> trace \
46 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
49 struct hb_closure_context_t
51 inline const char *get_name (void) { return "CLOSURE"; }
52 static const unsigned int max_debug_depth
= HB_DEBUG_CLOSURE
;
53 typedef hb_void_t return_t
;
54 typedef return_t (*recurse_func_t
) (hb_closure_context_t
*c
, unsigned int lookup_index
);
55 template <typename T
, typename F
>
56 inline bool may_dispatch (const T
*obj
, const F
*format
) { return true; }
58 inline return_t
dispatch (const T
&obj
) { obj
.closure (this); return HB_VOID
; }
59 static return_t
default_return_value (void) { return HB_VOID
; }
60 bool stop_sublookup_iteration (return_t r HB_UNUSED
) const { return false; }
61 return_t
recurse (unsigned int lookup_index
)
63 if (unlikely (nesting_level_left
== 0 || !recurse_func
))
64 return default_return_value ();
67 recurse_func (this, lookup_index
);
74 recurse_func_t recurse_func
;
75 unsigned int nesting_level_left
;
76 unsigned int debug_depth
;
78 hb_closure_context_t (hb_face_t
*face_
,
80 unsigned int nesting_level_left_
= MAX_NESTING_LEVEL
) :
84 nesting_level_left (nesting_level_left_
),
87 void set_recurse_func (recurse_func_t func
) { recurse_func
= func
; }
92 #ifndef HB_DEBUG_WOULD_APPLY
93 #define HB_DEBUG_WOULD_APPLY (HB_DEBUG+0)
96 #define TRACE_WOULD_APPLY(this) \
97 hb_auto_trace_t<HB_DEBUG_WOULD_APPLY, bool> trace \
98 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
101 struct hb_would_apply_context_t
103 inline const char *get_name (void) { return "WOULD_APPLY"; }
104 static const unsigned int max_debug_depth
= HB_DEBUG_WOULD_APPLY
;
105 typedef bool return_t
;
106 template <typename T
, typename F
>
107 inline bool may_dispatch (const T
*obj
, const F
*format
) { return true; }
108 template <typename T
>
109 inline return_t
dispatch (const T
&obj
) { return obj
.would_apply (this); }
110 static return_t
default_return_value (void) { return false; }
111 bool stop_sublookup_iteration (return_t r
) const { return r
; }
114 const hb_codepoint_t
*glyphs
;
117 unsigned int debug_depth
;
119 hb_would_apply_context_t (hb_face_t
*face_
,
120 const hb_codepoint_t
*glyphs_
,
122 bool zero_context_
) :
126 zero_context (zero_context_
),
132 #ifndef HB_DEBUG_COLLECT_GLYPHS
133 #define HB_DEBUG_COLLECT_GLYPHS (HB_DEBUG+0)
136 #define TRACE_COLLECT_GLYPHS(this) \
137 hb_auto_trace_t<HB_DEBUG_COLLECT_GLYPHS, hb_void_t> trace \
138 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
141 struct hb_collect_glyphs_context_t
143 inline const char *get_name (void) { return "COLLECT_GLYPHS"; }
144 static const unsigned int max_debug_depth
= HB_DEBUG_COLLECT_GLYPHS
;
145 typedef hb_void_t return_t
;
146 typedef return_t (*recurse_func_t
) (hb_collect_glyphs_context_t
*c
, unsigned int lookup_index
);
147 template <typename T
, typename F
>
148 inline bool may_dispatch (const T
*obj
, const F
*format
) { return true; }
149 template <typename T
>
150 inline return_t
dispatch (const T
&obj
) { obj
.collect_glyphs (this); return HB_VOID
; }
151 static return_t
default_return_value (void) { return HB_VOID
; }
152 bool stop_sublookup_iteration (return_t r HB_UNUSED
) const { return false; }
153 return_t
recurse (unsigned int lookup_index
)
155 if (unlikely (nesting_level_left
== 0 || !recurse_func
))
156 return default_return_value ();
158 /* Note that GPOS sets recurse_func to NULL already, so it doesn't get
159 * past the previous check. For GSUB, we only want to collect the output
160 * glyphs in the recursion. If output is not requested, we can go home now.
162 * Note further, that the above is not exactly correct. A recursed lookup
163 * is allowed to match input that is not matched in the context, but that's
164 * not how most fonts are built. It's possible to relax that and recurse
165 * with all sets here if it proves to be an issue.
168 if (output
== hb_set_get_empty ())
171 /* Return if new lookup was recursed to before. */
172 if (recursed_lookups
.has (lookup_index
))
175 hb_set_t
*old_before
= before
;
176 hb_set_t
*old_input
= input
;
177 hb_set_t
*old_after
= after
;
178 before
= input
= after
= hb_set_get_empty ();
180 nesting_level_left
--;
181 recurse_func (this, lookup_index
);
182 nesting_level_left
++;
188 recursed_lookups
.add (lookup_index
);
198 recurse_func_t recurse_func
;
199 hb_set_t recursed_lookups
;
200 unsigned int nesting_level_left
;
201 unsigned int debug_depth
;
203 hb_collect_glyphs_context_t (hb_face_t
*face_
,
204 hb_set_t
*glyphs_before
, /* OUT. May be NULL */
205 hb_set_t
*glyphs_input
, /* OUT. May be NULL */
206 hb_set_t
*glyphs_after
, /* OUT. May be NULL */
207 hb_set_t
*glyphs_output
, /* OUT. May be NULL */
208 unsigned int nesting_level_left_
= MAX_NESTING_LEVEL
) :
210 before (glyphs_before
? glyphs_before
: hb_set_get_empty ()),
211 input (glyphs_input
? glyphs_input
: hb_set_get_empty ()),
212 after (glyphs_after
? glyphs_after
: hb_set_get_empty ()),
213 output (glyphs_output
? glyphs_output
: hb_set_get_empty ()),
216 nesting_level_left (nesting_level_left_
),
219 recursed_lookups
.init ();
221 ~hb_collect_glyphs_context_t (void)
223 recursed_lookups
.fini ();
226 void set_recurse_func (recurse_func_t func
) { recurse_func
= func
; }
231 #ifndef HB_DEBUG_GET_COVERAGE
232 #define HB_DEBUG_GET_COVERAGE (HB_DEBUG+0)
235 template <typename set_t
>
236 struct hb_add_coverage_context_t
238 inline const char *get_name (void) { return "GET_COVERAGE"; }
239 static const unsigned int max_debug_depth
= HB_DEBUG_GET_COVERAGE
;
240 typedef const Coverage
&return_t
;
241 template <typename T
, typename F
>
242 inline bool may_dispatch (const T
*obj
, const F
*format
) { return true; }
243 template <typename T
>
244 inline return_t
dispatch (const T
&obj
) { return obj
.get_coverage (); }
245 static return_t
default_return_value (void) { return Null(Coverage
); }
246 bool stop_sublookup_iteration (return_t r
) const
248 r
.add_coverage (set
);
252 hb_add_coverage_context_t (set_t
*set_
) :
257 unsigned int debug_depth
;
262 #ifndef HB_DEBUG_APPLY
263 #define HB_DEBUG_APPLY (HB_DEBUG+0)
266 #define TRACE_APPLY(this) \
267 hb_auto_trace_t<HB_DEBUG_APPLY, bool> trace \
268 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
269 "idx %d codepoint %u", c->buffer->idx, c->buffer->cur().codepoint);
271 struct hb_apply_context_t
275 inline matcher_t (void) :
280 #define arg1(arg) (arg) /* Remove the macro to see why it's needed! */
284 match_data (NULL
) {};
286 typedef bool (*match_func_t
) (hb_codepoint_t glyph_id
, const USHORT
&value
, const void *data
);
288 inline void set_ignore_zwnj (bool ignore_zwnj_
) { ignore_zwnj
= ignore_zwnj_
; }
289 inline void set_ignore_zwj (bool ignore_zwj_
) { ignore_zwj
= ignore_zwj_
; }
290 inline void set_lookup_props (unsigned int lookup_props_
) { lookup_props
= lookup_props_
; }
291 inline void set_mask (hb_mask_t mask_
) { mask
= mask_
; }
292 inline void set_syllable (uint8_t syllable_
) { syllable
= syllable_
; }
293 inline void set_match_func (match_func_t match_func_
,
294 const void *match_data_
)
295 { match_func
= match_func_
; match_data
= match_data_
; }
303 inline may_match_t
may_match (const hb_glyph_info_t
&info
,
304 const USHORT
*glyph_data
) const
306 if (!(info
.mask
& mask
) ||
307 (syllable
&& syllable
!= info
.syllable ()))
311 return match_func (info
.codepoint
, *glyph_data
, match_data
) ? MATCH_YES
: MATCH_NO
;
323 may_skip (const hb_apply_context_t
*c
,
324 const hb_glyph_info_t
&info
) const
326 if (!c
->check_glyph_property (&info
, lookup_props
))
329 if (unlikely (_hb_glyph_info_is_default_ignorable (&info
) &&
330 (ignore_zwnj
|| !_hb_glyph_info_is_zwnj (&info
)) &&
331 (ignore_zwj
|| !_hb_glyph_info_is_zwj (&info
))))
338 unsigned int lookup_props
;
343 match_func_t match_func
;
344 const void *match_data
;
347 struct skipping_iterator_t
349 inline void init (hb_apply_context_t
*c_
, bool context_match
= false)
352 match_glyph_data
= NULL
,
353 matcher
.set_match_func (NULL
, NULL
);
354 matcher
.set_lookup_props (c
->lookup_props
);
355 /* Ignore ZWNJ if we are matching GSUB context, or matching GPOS. */
356 matcher
.set_ignore_zwnj (context_match
|| c
->table_index
== 1);
357 /* Ignore ZWJ if we are matching GSUB context, or matching GPOS, or if asked to. */
358 matcher
.set_ignore_zwj (context_match
|| c
->table_index
== 1 || c
->auto_zwj
);
359 matcher
.set_mask (context_match
? -1 : c
->lookup_mask
);
361 inline void set_lookup_props (unsigned int lookup_props
)
363 matcher
.set_lookup_props (lookup_props
);
365 inline void set_match_func (matcher_t::match_func_t match_func
,
366 const void *match_data
,
367 const USHORT glyph_data
[])
369 matcher
.set_match_func (match_func
, match_data
);
370 match_glyph_data
= glyph_data
;
373 inline void reset (unsigned int start_index_
,
374 unsigned int num_items_
)
377 num_items
= num_items_
;
378 end
= c
->buffer
->len
;
379 matcher
.set_syllable (start_index_
== c
->buffer
->idx
? c
->buffer
->cur().syllable () : 0);
382 inline void reject (void) { num_items
++; match_glyph_data
--; }
384 inline bool next (void)
386 assert (num_items
> 0);
387 while (idx
+ num_items
< end
)
390 const hb_glyph_info_t
&info
= c
->buffer
->info
[idx
];
392 matcher_t::may_skip_t skip
= matcher
.may_skip (c
, info
);
393 if (unlikely (skip
== matcher_t::SKIP_YES
))
396 matcher_t::may_match_t match
= matcher
.may_match (info
, match_glyph_data
);
397 if (match
== matcher_t::MATCH_YES
||
398 (match
== matcher_t::MATCH_MAYBE
&&
399 skip
== matcher_t::SKIP_NO
))
406 if (skip
== matcher_t::SKIP_NO
)
411 inline bool prev (void)
413 assert (num_items
> 0);
414 while (idx
>= num_items
)
417 const hb_glyph_info_t
&info
= c
->buffer
->out_info
[idx
];
419 matcher_t::may_skip_t skip
= matcher
.may_skip (c
, info
);
420 if (unlikely (skip
== matcher_t::SKIP_YES
))
423 matcher_t::may_match_t match
= matcher
.may_match (info
, match_glyph_data
);
424 if (match
== matcher_t::MATCH_YES
||
425 (match
== matcher_t::MATCH_MAYBE
&&
426 skip
== matcher_t::SKIP_NO
))
433 if (skip
== matcher_t::SKIP_NO
)
441 hb_apply_context_t
*c
;
443 const USHORT
*match_glyph_data
;
445 unsigned int num_items
;
450 inline const char *get_name (void) { return "APPLY"; }
451 static const unsigned int max_debug_depth
= HB_DEBUG_APPLY
;
452 typedef bool return_t
;
453 typedef return_t (*recurse_func_t
) (hb_apply_context_t
*c
, unsigned int lookup_index
);
454 template <typename T
, typename F
>
455 inline bool may_dispatch (const T
*obj
, const F
*format
) { return true; }
456 template <typename T
>
457 inline return_t
dispatch (const T
&obj
) { return obj
.apply (this); }
458 static return_t
default_return_value (void) { return false; }
459 bool stop_sublookup_iteration (return_t r
) const { return r
; }
460 return_t
recurse (unsigned int lookup_index
)
462 if (unlikely (nesting_level_left
== 0 || !recurse_func
))
463 return default_return_value ();
465 nesting_level_left
--;
466 bool ret
= recurse_func (this, lookup_index
);
467 nesting_level_left
++;
471 unsigned int table_index
; /* GSUB/GPOS */
475 hb_direction_t direction
;
476 hb_mask_t lookup_mask
;
478 recurse_func_t recurse_func
;
479 unsigned int nesting_level_left
;
480 unsigned int lookup_props
;
482 bool has_glyph_classes
;
483 skipping_iterator_t iter_input
, iter_context
;
484 unsigned int debug_depth
;
487 hb_apply_context_t (unsigned int table_index_
,
489 hb_buffer_t
*buffer_
) :
490 table_index (table_index_
),
491 font (font_
), face (font
->face
), buffer (buffer_
),
492 direction (buffer_
->props
.direction
),
496 nesting_level_left (MAX_NESTING_LEVEL
),
498 gdef (*hb_ot_layout_from_face (face
)->gdef
),
499 has_glyph_classes (gdef
.has_glyph_classes ()),
504 inline void set_lookup_mask (hb_mask_t mask
) { lookup_mask
= mask
; }
505 inline void set_auto_zwj (bool auto_zwj_
) { auto_zwj
= auto_zwj_
; }
506 inline void set_recurse_func (recurse_func_t func
) { recurse_func
= func
; }
507 inline void set_lookup (const Lookup
&l
) { set_lookup_props (l
.get_props ()); }
508 inline void set_lookup_props (unsigned int lookup_props_
)
510 lookup_props
= lookup_props_
;
511 iter_input
.init (this, false);
512 iter_context
.init (this, true);
516 match_properties_mark (hb_codepoint_t glyph
,
517 unsigned int glyph_props
,
518 unsigned int match_props
) const
520 /* If using mark filtering sets, the high short of
521 * match_props has the set index.
523 if (match_props
& LookupFlag::UseMarkFilteringSet
)
524 return gdef
.mark_set_covers (match_props
>> 16, glyph
);
526 /* The second byte of match_props has the meaning
527 * "ignore marks of attachment type different than
528 * the attachment type specified."
530 if (match_props
& LookupFlag::MarkAttachmentType
)
531 return (match_props
& LookupFlag::MarkAttachmentType
) == (glyph_props
& LookupFlag::MarkAttachmentType
);
537 check_glyph_property (const hb_glyph_info_t
*info
,
538 unsigned int match_props
) const
540 hb_codepoint_t glyph
= info
->codepoint
;
541 unsigned int glyph_props
= _hb_glyph_info_get_glyph_props (info
);
543 /* Not covered, if, for example, glyph class is ligature and
544 * match_props includes LookupFlags::IgnoreLigatures
546 if (glyph_props
& match_props
& LookupFlag::IgnoreFlags
)
549 if (unlikely (glyph_props
& HB_OT_LAYOUT_GLYPH_PROPS_MARK
))
550 return match_properties_mark (glyph
, glyph_props
, match_props
);
555 inline void _set_glyph_props (hb_codepoint_t glyph_index
,
556 unsigned int class_guess
= 0,
557 bool ligature
= false,
558 bool component
= false) const
560 unsigned int add_in
= _hb_glyph_info_get_glyph_props (&buffer
->cur()) &
561 HB_OT_LAYOUT_GLYPH_PROPS_PRESERVE
;
562 add_in
|= HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED
;
565 add_in
|= HB_OT_LAYOUT_GLYPH_PROPS_LIGATED
;
566 /* In the only place that the MULTIPLIED bit is used, Uniscribe
567 * seems to only care about the "last" transformation between
568 * Ligature and Multiple substitions. Ie. if you ligate, expand,
569 * and ligate again, it forgives the multiplication and acts as
570 * if only ligation happened. As such, clear MULTIPLIED bit.
572 add_in
&= ~HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED
;
575 add_in
|= HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED
;
576 if (likely (has_glyph_classes
))
577 _hb_glyph_info_set_glyph_props (&buffer
->cur(), add_in
| gdef
.get_glyph_props (glyph_index
));
578 else if (class_guess
)
579 _hb_glyph_info_set_glyph_props (&buffer
->cur(), add_in
| class_guess
);
582 inline void replace_glyph (hb_codepoint_t glyph_index
) const
584 _set_glyph_props (glyph_index
);
585 buffer
->replace_glyph (glyph_index
);
587 inline void replace_glyph_inplace (hb_codepoint_t glyph_index
) const
589 _set_glyph_props (glyph_index
);
590 buffer
->cur().codepoint
= glyph_index
;
592 inline void replace_glyph_with_ligature (hb_codepoint_t glyph_index
,
593 unsigned int class_guess
) const
595 _set_glyph_props (glyph_index
, class_guess
, true);
596 buffer
->replace_glyph (glyph_index
);
598 inline void output_glyph_for_component (hb_codepoint_t glyph_index
,
599 unsigned int class_guess
) const
601 _set_glyph_props (glyph_index
, class_guess
, false, true);
602 buffer
->output_glyph (glyph_index
);
608 typedef bool (*intersects_func_t
) (hb_set_t
*glyphs
, const USHORT
&value
, const void *data
);
609 typedef void (*collect_glyphs_func_t
) (hb_set_t
*glyphs
, const USHORT
&value
, const void *data
);
610 typedef bool (*match_func_t
) (hb_codepoint_t glyph_id
, const USHORT
&value
, const void *data
);
612 struct ContextClosureFuncs
614 intersects_func_t intersects
;
616 struct ContextCollectGlyphsFuncs
618 collect_glyphs_func_t collect
;
620 struct ContextApplyFuncs
626 static inline bool intersects_glyph (hb_set_t
*glyphs
, const USHORT
&value
, const void *data HB_UNUSED
)
628 return glyphs
->has (value
);
630 static inline bool intersects_class (hb_set_t
*glyphs
, const USHORT
&value
, const void *data
)
632 const ClassDef
&class_def
= *reinterpret_cast<const ClassDef
*>(data
);
633 return class_def
.intersects_class (glyphs
, value
);
635 static inline bool intersects_coverage (hb_set_t
*glyphs
, const USHORT
&value
, const void *data
)
637 const OffsetTo
<Coverage
> &coverage
= (const OffsetTo
<Coverage
>&)value
;
638 return (data
+coverage
).intersects (glyphs
);
641 static inline bool intersects_array (hb_closure_context_t
*c
,
643 const USHORT values
[],
644 intersects_func_t intersects_func
,
645 const void *intersects_data
)
647 for (unsigned int i
= 0; i
< count
; i
++)
648 if (likely (!intersects_func (c
->glyphs
, values
[i
], intersects_data
)))
654 static inline void collect_glyph (hb_set_t
*glyphs
, const USHORT
&value
, const void *data HB_UNUSED
)
658 static inline void collect_class (hb_set_t
*glyphs
, const USHORT
&value
, const void *data
)
660 const ClassDef
&class_def
= *reinterpret_cast<const ClassDef
*>(data
);
661 class_def
.add_class (glyphs
, value
);
663 static inline void collect_coverage (hb_set_t
*glyphs
, const USHORT
&value
, const void *data
)
665 const OffsetTo
<Coverage
> &coverage
= (const OffsetTo
<Coverage
>&)value
;
666 (data
+coverage
).add_coverage (glyphs
);
668 static inline void collect_array (hb_collect_glyphs_context_t
*c HB_UNUSED
,
671 const USHORT values
[],
672 collect_glyphs_func_t collect_func
,
673 const void *collect_data
)
675 for (unsigned int i
= 0; i
< count
; i
++)
676 collect_func (glyphs
, values
[i
], collect_data
);
680 static inline bool match_glyph (hb_codepoint_t glyph_id
, const USHORT
&value
, const void *data HB_UNUSED
)
682 return glyph_id
== value
;
684 static inline bool match_class (hb_codepoint_t glyph_id
, const USHORT
&value
, const void *data
)
686 const ClassDef
&class_def
= *reinterpret_cast<const ClassDef
*>(data
);
687 return class_def
.get_class (glyph_id
) == value
;
689 static inline bool match_coverage (hb_codepoint_t glyph_id
, const USHORT
&value
, const void *data
)
691 const OffsetTo
<Coverage
> &coverage
= (const OffsetTo
<Coverage
>&)value
;
692 return (data
+coverage
).get_coverage (glyph_id
) != NOT_COVERED
;
695 static inline bool would_match_input (hb_would_apply_context_t
*c
,
696 unsigned int count
, /* Including the first glyph (not matched) */
697 const USHORT input
[], /* Array of input values--start with second glyph */
698 match_func_t match_func
,
699 const void *match_data
)
704 for (unsigned int i
= 1; i
< count
; i
++)
705 if (likely (!match_func (c
->glyphs
[i
], input
[i
- 1], match_data
)))
710 static inline bool match_input (hb_apply_context_t
*c
,
711 unsigned int count
, /* Including the first glyph (not matched) */
712 const USHORT input
[], /* Array of input values--start with second glyph */
713 match_func_t match_func
,
714 const void *match_data
,
715 unsigned int *end_offset
,
716 unsigned int match_positions
[MAX_CONTEXT_LENGTH
],
717 bool *p_is_mark_ligature
= NULL
,
718 unsigned int *p_total_component_count
= NULL
)
722 if (unlikely (count
> MAX_CONTEXT_LENGTH
)) return TRACE_RETURN (false);
724 hb_buffer_t
*buffer
= c
->buffer
;
726 hb_apply_context_t::skipping_iterator_t
&skippy_iter
= c
->iter_input
;
727 skippy_iter
.reset (buffer
->idx
, count
- 1);
728 skippy_iter
.set_match_func (match_func
, match_data
, input
);
731 * This is perhaps the trickiest part of OpenType... Remarks:
733 * - If all components of the ligature were marks, we call this a mark ligature.
735 * - If there is no GDEF, and the ligature is NOT a mark ligature, we categorize
736 * it as a ligature glyph.
738 * - Ligatures cannot be formed across glyphs attached to different components
739 * of previous ligatures. Eg. the sequence is LAM,SHADDA,LAM,FATHA,HEH, and
740 * LAM,LAM,HEH form a ligature, leaving SHADDA,FATHA next to eachother.
741 * However, it would be wrong to ligate that SHADDA,FATHA sequence.o
742 * There is an exception to this: If a ligature tries ligating with marks that
743 * belong to it itself, go ahead, assuming that the font designer knows what
744 * they are doing (otherwise it can break Indic stuff when a matra wants to
745 * ligate with a conjunct...)
748 bool is_mark_ligature
= _hb_glyph_info_is_mark (&buffer
->cur());
750 unsigned int total_component_count
= 0;
751 total_component_count
+= _hb_glyph_info_get_lig_num_comps (&buffer
->cur());
753 unsigned int first_lig_id
= _hb_glyph_info_get_lig_id (&buffer
->cur());
754 unsigned int first_lig_comp
= _hb_glyph_info_get_lig_comp (&buffer
->cur());
756 match_positions
[0] = buffer
->idx
;
757 for (unsigned int i
= 1; i
< count
; i
++)
759 if (!skippy_iter
.next ()) return TRACE_RETURN (false);
761 match_positions
[i
] = skippy_iter
.idx
;
763 unsigned int this_lig_id
= _hb_glyph_info_get_lig_id (&buffer
->info
[skippy_iter
.idx
]);
764 unsigned int this_lig_comp
= _hb_glyph_info_get_lig_comp (&buffer
->info
[skippy_iter
.idx
]);
766 if (first_lig_id
&& first_lig_comp
) {
767 /* If first component was attached to a previous ligature component,
768 * all subsequent components should be attached to the same ligature
769 * component, otherwise we shouldn't ligate them. */
770 if (first_lig_id
!= this_lig_id
|| first_lig_comp
!= this_lig_comp
)
771 return TRACE_RETURN (false);
773 /* If first component was NOT attached to a previous ligature component,
774 * all subsequent components should also NOT be attached to any ligature
775 * component, unless they are attached to the first component itself! */
776 if (this_lig_id
&& this_lig_comp
&& (this_lig_id
!= first_lig_id
))
777 return TRACE_RETURN (false);
780 is_mark_ligature
= is_mark_ligature
&& _hb_glyph_info_is_mark (&buffer
->info
[skippy_iter
.idx
]);
781 total_component_count
+= _hb_glyph_info_get_lig_num_comps (&buffer
->info
[skippy_iter
.idx
]);
784 *end_offset
= skippy_iter
.idx
- buffer
->idx
+ 1;
786 if (p_is_mark_ligature
)
787 *p_is_mark_ligature
= is_mark_ligature
;
789 if (p_total_component_count
)
790 *p_total_component_count
= total_component_count
;
792 return TRACE_RETURN (true);
794 static inline void ligate_input (hb_apply_context_t
*c
,
795 unsigned int count
, /* Including the first glyph */
796 unsigned int match_positions
[MAX_CONTEXT_LENGTH
], /* Including the first glyph */
797 unsigned int match_length
,
798 hb_codepoint_t lig_glyph
,
799 bool is_mark_ligature
,
800 unsigned int total_component_count
)
804 hb_buffer_t
*buffer
= c
->buffer
;
806 buffer
->merge_clusters (buffer
->idx
, buffer
->idx
+ match_length
);
809 * - If it *is* a mark ligature, we don't allocate a new ligature id, and leave
810 * the ligature to keep its old ligature id. This will allow it to attach to
811 * a base ligature in GPOS. Eg. if the sequence is: LAM,LAM,SHADDA,FATHA,HEH,
812 * and LAM,LAM,HEH for a ligature, they will leave SHADDA and FATHA wit a
813 * ligature id and component value of 2. Then if SHADDA,FATHA form a ligature
814 * later, we don't want them to lose their ligature id/component, otherwise
815 * GPOS will fail to correctly position the mark ligature on top of the
816 * LAM,LAM,HEH ligature. See:
817 * https://bugzilla.gnome.org/show_bug.cgi?id=676343
819 * - If a ligature is formed of components that some of which are also ligatures
820 * themselves, and those ligature components had marks attached to *their*
821 * components, we have to attach the marks to the new ligature component
822 * positions! Now *that*'s tricky! And these marks may be following the
823 * last component of the whole sequence, so we should loop forward looking
824 * for them and update them.
826 * Eg. the sequence is LAM,LAM,SHADDA,FATHA,HEH, and the font first forms a
827 * 'calt' ligature of LAM,HEH, leaving the SHADDA and FATHA with a ligature
828 * id and component == 1. Now, during 'liga', the LAM and the LAM-HEH ligature
829 * form a LAM-LAM-HEH ligature. We need to reassign the SHADDA and FATHA to
830 * the new ligature with a component value of 2.
832 * This in fact happened to a font... See:
833 * https://bugzilla.gnome.org/show_bug.cgi?id=437633
836 unsigned int klass
= is_mark_ligature
? 0 : HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE
;
837 unsigned int lig_id
= is_mark_ligature
? 0 : _hb_allocate_lig_id (buffer
);
838 unsigned int last_lig_id
= _hb_glyph_info_get_lig_id (&buffer
->cur());
839 unsigned int last_num_components
= _hb_glyph_info_get_lig_num_comps (&buffer
->cur());
840 unsigned int components_so_far
= last_num_components
;
842 if (!is_mark_ligature
)
844 _hb_glyph_info_set_lig_props_for_ligature (&buffer
->cur(), lig_id
, total_component_count
);
845 if (_hb_glyph_info_get_general_category (&buffer
->cur()) == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK
)
847 _hb_glyph_info_set_general_category (&buffer
->cur(), HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER
);
848 _hb_glyph_info_set_modified_combining_class (&buffer
->cur(), 0);
851 c
->replace_glyph_with_ligature (lig_glyph
, klass
);
853 for (unsigned int i
= 1; i
< count
; i
++)
855 while (buffer
->idx
< match_positions
[i
])
857 if (!is_mark_ligature
) {
858 unsigned int new_lig_comp
= components_so_far
- last_num_components
+
859 MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer
->cur()), 1u), last_num_components
);
860 _hb_glyph_info_set_lig_props_for_mark (&buffer
->cur(), lig_id
, new_lig_comp
);
862 buffer
->next_glyph ();
865 last_lig_id
= _hb_glyph_info_get_lig_id (&buffer
->cur());
866 last_num_components
= _hb_glyph_info_get_lig_num_comps (&buffer
->cur());
867 components_so_far
+= last_num_components
;
869 /* Skip the base glyph */
873 if (!is_mark_ligature
&& last_lig_id
) {
874 /* Re-adjust components for any marks following. */
875 for (unsigned int i
= buffer
->idx
; i
< buffer
->len
; i
++) {
876 if (last_lig_id
== _hb_glyph_info_get_lig_id (&buffer
->info
[i
])) {
877 unsigned int new_lig_comp
= components_so_far
- last_num_components
+
878 MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer
->info
[i
]), 1u), last_num_components
);
879 _hb_glyph_info_set_lig_props_for_mark (&buffer
->info
[i
], lig_id
, new_lig_comp
);
887 static inline bool match_backtrack (hb_apply_context_t
*c
,
889 const USHORT backtrack
[],
890 match_func_t match_func
,
891 const void *match_data
)
895 hb_apply_context_t::skipping_iterator_t
&skippy_iter
= c
->iter_context
;
896 skippy_iter
.reset (c
->buffer
->backtrack_len (), count
);
897 skippy_iter
.set_match_func (match_func
, match_data
, backtrack
);
899 for (unsigned int i
= 0; i
< count
; i
++)
900 if (!skippy_iter
.prev ())
901 return TRACE_RETURN (false);
903 return TRACE_RETURN (true);
906 static inline bool match_lookahead (hb_apply_context_t
*c
,
908 const USHORT lookahead
[],
909 match_func_t match_func
,
910 const void *match_data
,
915 hb_apply_context_t::skipping_iterator_t
&skippy_iter
= c
->iter_context
;
916 skippy_iter
.reset (c
->buffer
->idx
+ offset
- 1, count
);
917 skippy_iter
.set_match_func (match_func
, match_data
, lookahead
);
919 for (unsigned int i
= 0; i
< count
; i
++)
920 if (!skippy_iter
.next ())
921 return TRACE_RETURN (false);
923 return TRACE_RETURN (true);
930 inline bool sanitize (hb_sanitize_context_t
*c
) const
932 TRACE_SANITIZE (this);
933 return TRACE_RETURN (c
->check_struct (this));
936 USHORT sequenceIndex
; /* Index into current glyph
937 * sequence--first glyph = 0 */
938 USHORT lookupListIndex
; /* Lookup to apply to that
939 * position--zero--based */
941 DEFINE_SIZE_STATIC (4);
945 template <typename context_t
>
946 static inline void recurse_lookups (context_t
*c
,
947 unsigned int lookupCount
,
948 const LookupRecord lookupRecord
[] /* Array of LookupRecords--in design order */)
950 for (unsigned int i
= 0; i
< lookupCount
; i
++)
951 c
->recurse (lookupRecord
[i
].lookupListIndex
);
954 static inline bool apply_lookup (hb_apply_context_t
*c
,
955 unsigned int count
, /* Including the first glyph */
956 unsigned int match_positions
[MAX_CONTEXT_LENGTH
], /* Including the first glyph */
957 unsigned int lookupCount
,
958 const LookupRecord lookupRecord
[], /* Array of LookupRecords--in design order */
959 unsigned int match_length
)
963 hb_buffer_t
*buffer
= c
->buffer
;
966 /* All positions are distance from beginning of *output* buffer.
969 unsigned int bl
= buffer
->backtrack_len ();
970 end
= bl
+ match_length
;
972 int delta
= bl
- buffer
->idx
;
973 /* Convert positions to new indexing. */
974 for (unsigned int j
= 0; j
< count
; j
++)
975 match_positions
[j
] += delta
;
978 for (unsigned int i
= 0; i
< lookupCount
; i
++)
980 unsigned int idx
= lookupRecord
[i
].sequenceIndex
;
984 buffer
->move_to (match_positions
[idx
]);
986 unsigned int orig_len
= buffer
->backtrack_len () + buffer
->lookahead_len ();
987 if (!c
->recurse (lookupRecord
[i
].lookupListIndex
))
990 unsigned int new_len
= buffer
->backtrack_len () + buffer
->lookahead_len ();
991 int delta
= new_len
- orig_len
;
996 /* Recursed lookup changed buffer len. Adjust. */
998 /* end can't go back past the current match position.
999 * Note: this is only true because we do NOT allow MultipleSubst
1000 * with zero sequence len. */
1001 end
= MAX ((int) match_positions
[idx
] + 1, int (end
) + delta
);
1003 unsigned int next
= idx
+ 1; /* next now is the position after the recursed lookup. */
1007 if (unlikely (delta
+ count
> MAX_CONTEXT_LENGTH
))
1012 /* NOTE: delta is negative. */
1013 delta
= MAX (delta
, (int) next
- (int) count
);
1018 memmove (match_positions
+ next
+ delta
, match_positions
+ next
,
1019 (count
- next
) * sizeof (match_positions
[0]));
1023 /* Fill in new entries. */
1024 for (unsigned int j
= idx
+ 1; j
< next
; j
++)
1025 match_positions
[j
] = match_positions
[j
- 1] + 1;
1027 /* And fixup the rest. */
1028 for (; next
< count
; next
++)
1029 match_positions
[next
] += delta
;
1032 buffer
->move_to (end
);
1034 return TRACE_RETURN (true);
1039 /* Contextual lookups */
1041 struct ContextClosureLookupContext
1043 ContextClosureFuncs funcs
;
1044 const void *intersects_data
;
1047 struct ContextCollectGlyphsLookupContext
1049 ContextCollectGlyphsFuncs funcs
;
1050 const void *collect_data
;
1053 struct ContextApplyLookupContext
1055 ContextApplyFuncs funcs
;
1056 const void *match_data
;
1059 static inline void context_closure_lookup (hb_closure_context_t
*c
,
1060 unsigned int inputCount
, /* Including the first glyph (not matched) */
1061 const USHORT input
[], /* Array of input values--start with second glyph */
1062 unsigned int lookupCount
,
1063 const LookupRecord lookupRecord
[],
1064 ContextClosureLookupContext
&lookup_context
)
1066 if (intersects_array (c
,
1067 inputCount
? inputCount
- 1 : 0, input
,
1068 lookup_context
.funcs
.intersects
, lookup_context
.intersects_data
))
1070 lookupCount
, lookupRecord
);
1073 static inline void context_collect_glyphs_lookup (hb_collect_glyphs_context_t
*c
,
1074 unsigned int inputCount
, /* Including the first glyph (not matched) */
1075 const USHORT input
[], /* Array of input values--start with second glyph */
1076 unsigned int lookupCount
,
1077 const LookupRecord lookupRecord
[],
1078 ContextCollectGlyphsLookupContext
&lookup_context
)
1080 collect_array (c
, c
->input
,
1081 inputCount
? inputCount
- 1 : 0, input
,
1082 lookup_context
.funcs
.collect
, lookup_context
.collect_data
);
1084 lookupCount
, lookupRecord
);
1087 static inline bool context_would_apply_lookup (hb_would_apply_context_t
*c
,
1088 unsigned int inputCount
, /* Including the first glyph (not matched) */
1089 const USHORT input
[], /* Array of input values--start with second glyph */
1090 unsigned int lookupCount HB_UNUSED
,
1091 const LookupRecord lookupRecord
[] HB_UNUSED
,
1092 ContextApplyLookupContext
&lookup_context
)
1094 return would_match_input (c
,
1096 lookup_context
.funcs
.match
, lookup_context
.match_data
);
1098 static inline bool context_apply_lookup (hb_apply_context_t
*c
,
1099 unsigned int inputCount
, /* Including the first glyph (not matched) */
1100 const USHORT input
[], /* Array of input values--start with second glyph */
1101 unsigned int lookupCount
,
1102 const LookupRecord lookupRecord
[],
1103 ContextApplyLookupContext
&lookup_context
)
1105 unsigned int match_length
= 0;
1106 unsigned int match_positions
[MAX_CONTEXT_LENGTH
];
1107 return match_input (c
,
1109 lookup_context
.funcs
.match
, lookup_context
.match_data
,
1110 &match_length
, match_positions
)
1112 inputCount
, match_positions
,
1113 lookupCount
, lookupRecord
,
1119 inline void closure (hb_closure_context_t
*c
, ContextClosureLookupContext
&lookup_context
) const
1121 TRACE_CLOSURE (this);
1122 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (inputZ
, inputZ
[0].static_size
* (inputCount
? inputCount
- 1 : 0));
1123 context_closure_lookup (c
,
1125 lookupCount
, lookupRecord
,
1129 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
, ContextCollectGlyphsLookupContext
&lookup_context
) const
1131 TRACE_COLLECT_GLYPHS (this);
1132 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (inputZ
, inputZ
[0].static_size
* (inputCount
? inputCount
- 1 : 0));
1133 context_collect_glyphs_lookup (c
,
1135 lookupCount
, lookupRecord
,
1139 inline bool would_apply (hb_would_apply_context_t
*c
, ContextApplyLookupContext
&lookup_context
) const
1141 TRACE_WOULD_APPLY (this);
1142 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (inputZ
, inputZ
[0].static_size
* (inputCount
? inputCount
- 1 : 0));
1143 return TRACE_RETURN (context_would_apply_lookup (c
, inputCount
, inputZ
, lookupCount
, lookupRecord
, lookup_context
));
1146 inline bool apply (hb_apply_context_t
*c
, ContextApplyLookupContext
&lookup_context
) const
1149 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (inputZ
, inputZ
[0].static_size
* (inputCount
? inputCount
- 1 : 0));
1150 return TRACE_RETURN (context_apply_lookup (c
, inputCount
, inputZ
, lookupCount
, lookupRecord
, lookup_context
));
1154 inline bool sanitize (hb_sanitize_context_t
*c
) const
1156 TRACE_SANITIZE (this);
1157 return inputCount
.sanitize (c
)
1158 && lookupCount
.sanitize (c
)
1159 && c
->check_range (inputZ
,
1160 inputZ
[0].static_size
* inputCount
1161 + lookupRecordX
[0].static_size
* lookupCount
);
1165 USHORT inputCount
; /* Total number of glyphs in input
1166 * glyph sequence--includes the first
1168 USHORT lookupCount
; /* Number of LookupRecords */
1169 USHORT inputZ
[VAR
]; /* Array of match inputs--start with
1171 LookupRecord lookupRecordX
[VAR
]; /* Array of LookupRecords--in
1174 DEFINE_SIZE_ARRAY2 (4, inputZ
, lookupRecordX
);
1179 inline void closure (hb_closure_context_t
*c
, ContextClosureLookupContext
&lookup_context
) const
1181 TRACE_CLOSURE (this);
1182 unsigned int num_rules
= rule
.len
;
1183 for (unsigned int i
= 0; i
< num_rules
; i
++)
1184 (this+rule
[i
]).closure (c
, lookup_context
);
1187 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
, ContextCollectGlyphsLookupContext
&lookup_context
) const
1189 TRACE_COLLECT_GLYPHS (this);
1190 unsigned int num_rules
= rule
.len
;
1191 for (unsigned int i
= 0; i
< num_rules
; i
++)
1192 (this+rule
[i
]).collect_glyphs (c
, lookup_context
);
1195 inline bool would_apply (hb_would_apply_context_t
*c
, ContextApplyLookupContext
&lookup_context
) const
1197 TRACE_WOULD_APPLY (this);
1198 unsigned int num_rules
= rule
.len
;
1199 for (unsigned int i
= 0; i
< num_rules
; i
++)
1201 if ((this+rule
[i
]).would_apply (c
, lookup_context
))
1202 return TRACE_RETURN (true);
1204 return TRACE_RETURN (false);
1207 inline bool apply (hb_apply_context_t
*c
, ContextApplyLookupContext
&lookup_context
) const
1210 unsigned int num_rules
= rule
.len
;
1211 for (unsigned int i
= 0; i
< num_rules
; i
++)
1213 if ((this+rule
[i
]).apply (c
, lookup_context
))
1214 return TRACE_RETURN (true);
1216 return TRACE_RETURN (false);
1219 inline bool sanitize (hb_sanitize_context_t
*c
) const
1221 TRACE_SANITIZE (this);
1222 return TRACE_RETURN (rule
.sanitize (c
, this));
1227 rule
; /* Array of Rule tables
1228 * ordered by preference */
1230 DEFINE_SIZE_ARRAY (2, rule
);
1234 struct ContextFormat1
1236 inline void closure (hb_closure_context_t
*c
) const
1238 TRACE_CLOSURE (this);
1240 const Coverage
&cov
= (this+coverage
);
1242 struct ContextClosureLookupContext lookup_context
= {
1247 unsigned int count
= ruleSet
.len
;
1248 for (unsigned int i
= 0; i
< count
; i
++)
1249 if (cov
.intersects_coverage (c
->glyphs
, i
)) {
1250 const RuleSet
&rule_set
= this+ruleSet
[i
];
1251 rule_set
.closure (c
, lookup_context
);
1255 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
) const
1257 TRACE_COLLECT_GLYPHS (this);
1258 (this+coverage
).add_coverage (c
->input
);
1260 struct ContextCollectGlyphsLookupContext lookup_context
= {
1265 unsigned int count
= ruleSet
.len
;
1266 for (unsigned int i
= 0; i
< count
; i
++)
1267 (this+ruleSet
[i
]).collect_glyphs (c
, lookup_context
);
1270 inline bool would_apply (hb_would_apply_context_t
*c
) const
1272 TRACE_WOULD_APPLY (this);
1274 const RuleSet
&rule_set
= this+ruleSet
[(this+coverage
).get_coverage (c
->glyphs
[0])];
1275 struct ContextApplyLookupContext lookup_context
= {
1279 return TRACE_RETURN (rule_set
.would_apply (c
, lookup_context
));
1282 inline const Coverage
&get_coverage (void) const
1284 return this+coverage
;
1287 inline bool apply (hb_apply_context_t
*c
) const
1290 unsigned int index
= (this+coverage
).get_coverage (c
->buffer
->cur().codepoint
);
1291 if (likely (index
== NOT_COVERED
))
1292 return TRACE_RETURN (false);
1294 const RuleSet
&rule_set
= this+ruleSet
[index
];
1295 struct ContextApplyLookupContext lookup_context
= {
1299 return TRACE_RETURN (rule_set
.apply (c
, lookup_context
));
1302 inline bool sanitize (hb_sanitize_context_t
*c
) const
1304 TRACE_SANITIZE (this);
1305 return TRACE_RETURN (coverage
.sanitize (c
, this) && ruleSet
.sanitize (c
, this));
1309 USHORT format
; /* Format identifier--format = 1 */
1311 coverage
; /* Offset to Coverage table--from
1312 * beginning of table */
1313 OffsetArrayOf
<RuleSet
>
1314 ruleSet
; /* Array of RuleSet tables
1315 * ordered by Coverage Index */
1317 DEFINE_SIZE_ARRAY (6, ruleSet
);
1321 struct ContextFormat2
1323 inline void closure (hb_closure_context_t
*c
) const
1325 TRACE_CLOSURE (this);
1326 if (!(this+coverage
).intersects (c
->glyphs
))
1329 const ClassDef
&class_def
= this+classDef
;
1331 struct ContextClosureLookupContext lookup_context
= {
1336 unsigned int count
= ruleSet
.len
;
1337 for (unsigned int i
= 0; i
< count
; i
++)
1338 if (class_def
.intersects_class (c
->glyphs
, i
)) {
1339 const RuleSet
&rule_set
= this+ruleSet
[i
];
1340 rule_set
.closure (c
, lookup_context
);
1344 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
) const
1346 TRACE_COLLECT_GLYPHS (this);
1347 (this+coverage
).add_coverage (c
->input
);
1349 const ClassDef
&class_def
= this+classDef
;
1350 struct ContextCollectGlyphsLookupContext lookup_context
= {
1355 unsigned int count
= ruleSet
.len
;
1356 for (unsigned int i
= 0; i
< count
; i
++)
1357 (this+ruleSet
[i
]).collect_glyphs (c
, lookup_context
);
1360 inline bool would_apply (hb_would_apply_context_t
*c
) const
1362 TRACE_WOULD_APPLY (this);
1364 const ClassDef
&class_def
= this+classDef
;
1365 unsigned int index
= class_def
.get_class (c
->glyphs
[0]);
1366 const RuleSet
&rule_set
= this+ruleSet
[index
];
1367 struct ContextApplyLookupContext lookup_context
= {
1371 return TRACE_RETURN (rule_set
.would_apply (c
, lookup_context
));
1374 inline const Coverage
&get_coverage (void) const
1376 return this+coverage
;
1379 inline bool apply (hb_apply_context_t
*c
) const
1382 unsigned int index
= (this+coverage
).get_coverage (c
->buffer
->cur().codepoint
);
1383 if (likely (index
== NOT_COVERED
)) return TRACE_RETURN (false);
1385 const ClassDef
&class_def
= this+classDef
;
1386 index
= class_def
.get_class (c
->buffer
->cur().codepoint
);
1387 const RuleSet
&rule_set
= this+ruleSet
[index
];
1388 struct ContextApplyLookupContext lookup_context
= {
1392 return TRACE_RETURN (rule_set
.apply (c
, lookup_context
));
1395 inline bool sanitize (hb_sanitize_context_t
*c
) const
1397 TRACE_SANITIZE (this);
1398 return TRACE_RETURN (coverage
.sanitize (c
, this) && classDef
.sanitize (c
, this) && ruleSet
.sanitize (c
, this));
1402 USHORT format
; /* Format identifier--format = 2 */
1404 coverage
; /* Offset to Coverage table--from
1405 * beginning of table */
1407 classDef
; /* Offset to glyph ClassDef table--from
1408 * beginning of table */
1409 OffsetArrayOf
<RuleSet
>
1410 ruleSet
; /* Array of RuleSet tables
1411 * ordered by class */
1413 DEFINE_SIZE_ARRAY (8, ruleSet
);
1417 struct ContextFormat3
1419 inline void closure (hb_closure_context_t
*c
) const
1421 TRACE_CLOSURE (this);
1422 if (!(this+coverageZ
[0]).intersects (c
->glyphs
))
1425 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (coverageZ
, coverageZ
[0].static_size
* glyphCount
);
1426 struct ContextClosureLookupContext lookup_context
= {
1427 {intersects_coverage
},
1430 context_closure_lookup (c
,
1431 glyphCount
, (const USHORT
*) (coverageZ
+ 1),
1432 lookupCount
, lookupRecord
,
1436 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
) const
1438 TRACE_COLLECT_GLYPHS (this);
1439 (this+coverageZ
[0]).add_coverage (c
->input
);
1441 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (coverageZ
, coverageZ
[0].static_size
* glyphCount
);
1442 struct ContextCollectGlyphsLookupContext lookup_context
= {
1447 context_collect_glyphs_lookup (c
,
1448 glyphCount
, (const USHORT
*) (coverageZ
+ 1),
1449 lookupCount
, lookupRecord
,
1453 inline bool would_apply (hb_would_apply_context_t
*c
) const
1455 TRACE_WOULD_APPLY (this);
1457 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (coverageZ
, coverageZ
[0].static_size
* glyphCount
);
1458 struct ContextApplyLookupContext lookup_context
= {
1462 return TRACE_RETURN (context_would_apply_lookup (c
, glyphCount
, (const USHORT
*) (coverageZ
+ 1), lookupCount
, lookupRecord
, lookup_context
));
1465 inline const Coverage
&get_coverage (void) const
1467 return this+coverageZ
[0];
1470 inline bool apply (hb_apply_context_t
*c
) const
1473 unsigned int index
= (this+coverageZ
[0]).get_coverage (c
->buffer
->cur().codepoint
);
1474 if (likely (index
== NOT_COVERED
)) return TRACE_RETURN (false);
1476 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (coverageZ
, coverageZ
[0].static_size
* glyphCount
);
1477 struct ContextApplyLookupContext lookup_context
= {
1481 return TRACE_RETURN (context_apply_lookup (c
, glyphCount
, (const USHORT
*) (coverageZ
+ 1), lookupCount
, lookupRecord
, lookup_context
));
1484 inline bool sanitize (hb_sanitize_context_t
*c
) const
1486 TRACE_SANITIZE (this);
1487 if (!c
->check_struct (this)) return TRACE_RETURN (false);
1488 unsigned int count
= glyphCount
;
1489 if (!count
) return TRACE_RETURN (false); /* We want to access coverageZ[0] freely. */
1490 if (!c
->check_array (coverageZ
, coverageZ
[0].static_size
, count
)) return TRACE_RETURN (false);
1491 for (unsigned int i
= 0; i
< count
; i
++)
1492 if (!coverageZ
[i
].sanitize (c
, this)) return TRACE_RETURN (false);
1493 const LookupRecord
*lookupRecord
= &StructAtOffset
<LookupRecord
> (coverageZ
, coverageZ
[0].static_size
* count
);
1494 return TRACE_RETURN (c
->check_array (lookupRecord
, lookupRecord
[0].static_size
, lookupCount
));
1498 USHORT format
; /* Format identifier--format = 3 */
1499 USHORT glyphCount
; /* Number of glyphs in the input glyph
1501 USHORT lookupCount
; /* Number of LookupRecords */
1503 coverageZ
[VAR
]; /* Array of offsets to Coverage
1504 * table in glyph sequence order */
1505 LookupRecord lookupRecordX
[VAR
]; /* Array of LookupRecords--in
1508 DEFINE_SIZE_ARRAY2 (6, coverageZ
, lookupRecordX
);
1513 template <typename context_t
>
1514 inline typename
context_t::return_t
dispatch (context_t
*c
) const
1516 TRACE_DISPATCH (this, u
.format
);
1517 if (unlikely (!c
->may_dispatch (this, &u
.format
))) TRACE_RETURN (c
->default_return_value ());
1519 case 1: return TRACE_RETURN (c
->dispatch (u
.format1
));
1520 case 2: return TRACE_RETURN (c
->dispatch (u
.format2
));
1521 case 3: return TRACE_RETURN (c
->dispatch (u
.format3
));
1522 default:return TRACE_RETURN (c
->default_return_value ());
1528 USHORT format
; /* Format identifier */
1529 ContextFormat1 format1
;
1530 ContextFormat2 format2
;
1531 ContextFormat3 format3
;
1536 /* Chaining Contextual lookups */
1538 struct ChainContextClosureLookupContext
1540 ContextClosureFuncs funcs
;
1541 const void *intersects_data
[3];
1544 struct ChainContextCollectGlyphsLookupContext
1546 ContextCollectGlyphsFuncs funcs
;
1547 const void *collect_data
[3];
1550 struct ChainContextApplyLookupContext
1552 ContextApplyFuncs funcs
;
1553 const void *match_data
[3];
1556 static inline void chain_context_closure_lookup (hb_closure_context_t
*c
,
1557 unsigned int backtrackCount
,
1558 const USHORT backtrack
[],
1559 unsigned int inputCount
, /* Including the first glyph (not matched) */
1560 const USHORT input
[], /* Array of input values--start with second glyph */
1561 unsigned int lookaheadCount
,
1562 const USHORT lookahead
[],
1563 unsigned int lookupCount
,
1564 const LookupRecord lookupRecord
[],
1565 ChainContextClosureLookupContext
&lookup_context
)
1567 if (intersects_array (c
,
1568 backtrackCount
, backtrack
,
1569 lookup_context
.funcs
.intersects
, lookup_context
.intersects_data
[0])
1570 && intersects_array (c
,
1571 inputCount
? inputCount
- 1 : 0, input
,
1572 lookup_context
.funcs
.intersects
, lookup_context
.intersects_data
[1])
1573 && intersects_array (c
,
1574 lookaheadCount
, lookahead
,
1575 lookup_context
.funcs
.intersects
, lookup_context
.intersects_data
[2]))
1577 lookupCount
, lookupRecord
);
1580 static inline void chain_context_collect_glyphs_lookup (hb_collect_glyphs_context_t
*c
,
1581 unsigned int backtrackCount
,
1582 const USHORT backtrack
[],
1583 unsigned int inputCount
, /* Including the first glyph (not matched) */
1584 const USHORT input
[], /* Array of input values--start with second glyph */
1585 unsigned int lookaheadCount
,
1586 const USHORT lookahead
[],
1587 unsigned int lookupCount
,
1588 const LookupRecord lookupRecord
[],
1589 ChainContextCollectGlyphsLookupContext
&lookup_context
)
1591 collect_array (c
, c
->before
,
1592 backtrackCount
, backtrack
,
1593 lookup_context
.funcs
.collect
, lookup_context
.collect_data
[0]);
1594 collect_array (c
, c
->input
,
1595 inputCount
? inputCount
- 1 : 0, input
,
1596 lookup_context
.funcs
.collect
, lookup_context
.collect_data
[1]);
1597 collect_array (c
, c
->after
,
1598 lookaheadCount
, lookahead
,
1599 lookup_context
.funcs
.collect
, lookup_context
.collect_data
[2]);
1601 lookupCount
, lookupRecord
);
1604 static inline bool chain_context_would_apply_lookup (hb_would_apply_context_t
*c
,
1605 unsigned int backtrackCount
,
1606 const USHORT backtrack
[] HB_UNUSED
,
1607 unsigned int inputCount
, /* Including the first glyph (not matched) */
1608 const USHORT input
[], /* Array of input values--start with second glyph */
1609 unsigned int lookaheadCount
,
1610 const USHORT lookahead
[] HB_UNUSED
,
1611 unsigned int lookupCount HB_UNUSED
,
1612 const LookupRecord lookupRecord
[] HB_UNUSED
,
1613 ChainContextApplyLookupContext
&lookup_context
)
1615 return (c
->zero_context
? !backtrackCount
&& !lookaheadCount
: true)
1616 && would_match_input (c
,
1618 lookup_context
.funcs
.match
, lookup_context
.match_data
[1]);
1621 static inline bool chain_context_apply_lookup (hb_apply_context_t
*c
,
1622 unsigned int backtrackCount
,
1623 const USHORT backtrack
[],
1624 unsigned int inputCount
, /* Including the first glyph (not matched) */
1625 const USHORT input
[], /* Array of input values--start with second glyph */
1626 unsigned int lookaheadCount
,
1627 const USHORT lookahead
[],
1628 unsigned int lookupCount
,
1629 const LookupRecord lookupRecord
[],
1630 ChainContextApplyLookupContext
&lookup_context
)
1632 unsigned int match_length
= 0;
1633 unsigned int match_positions
[MAX_CONTEXT_LENGTH
];
1634 return match_input (c
,
1636 lookup_context
.funcs
.match
, lookup_context
.match_data
[1],
1637 &match_length
, match_positions
)
1638 && match_backtrack (c
,
1639 backtrackCount
, backtrack
,
1640 lookup_context
.funcs
.match
, lookup_context
.match_data
[0])
1641 && match_lookahead (c
,
1642 lookaheadCount
, lookahead
,
1643 lookup_context
.funcs
.match
, lookup_context
.match_data
[2],
1646 inputCount
, match_positions
,
1647 lookupCount
, lookupRecord
,
1653 inline void closure (hb_closure_context_t
*c
, ChainContextClosureLookupContext
&lookup_context
) const
1655 TRACE_CLOSURE (this);
1656 const HeadlessArrayOf
<USHORT
> &input
= StructAfter
<HeadlessArrayOf
<USHORT
> > (backtrack
);
1657 const ArrayOf
<USHORT
> &lookahead
= StructAfter
<ArrayOf
<USHORT
> > (input
);
1658 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
1659 chain_context_closure_lookup (c
,
1660 backtrack
.len
, backtrack
.array
,
1661 input
.len
, input
.array
,
1662 lookahead
.len
, lookahead
.array
,
1663 lookup
.len
, lookup
.array
,
1667 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
, ChainContextCollectGlyphsLookupContext
&lookup_context
) const
1669 TRACE_COLLECT_GLYPHS (this);
1670 const HeadlessArrayOf
<USHORT
> &input
= StructAfter
<HeadlessArrayOf
<USHORT
> > (backtrack
);
1671 const ArrayOf
<USHORT
> &lookahead
= StructAfter
<ArrayOf
<USHORT
> > (input
);
1672 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
1673 chain_context_collect_glyphs_lookup (c
,
1674 backtrack
.len
, backtrack
.array
,
1675 input
.len
, input
.array
,
1676 lookahead
.len
, lookahead
.array
,
1677 lookup
.len
, lookup
.array
,
1681 inline bool would_apply (hb_would_apply_context_t
*c
, ChainContextApplyLookupContext
&lookup_context
) const
1683 TRACE_WOULD_APPLY (this);
1684 const HeadlessArrayOf
<USHORT
> &input
= StructAfter
<HeadlessArrayOf
<USHORT
> > (backtrack
);
1685 const ArrayOf
<USHORT
> &lookahead
= StructAfter
<ArrayOf
<USHORT
> > (input
);
1686 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
1687 return TRACE_RETURN (chain_context_would_apply_lookup (c
,
1688 backtrack
.len
, backtrack
.array
,
1689 input
.len
, input
.array
,
1690 lookahead
.len
, lookahead
.array
, lookup
.len
,
1691 lookup
.array
, lookup_context
));
1694 inline bool apply (hb_apply_context_t
*c
, ChainContextApplyLookupContext
&lookup_context
) const
1697 const HeadlessArrayOf
<USHORT
> &input
= StructAfter
<HeadlessArrayOf
<USHORT
> > (backtrack
);
1698 const ArrayOf
<USHORT
> &lookahead
= StructAfter
<ArrayOf
<USHORT
> > (input
);
1699 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
1700 return TRACE_RETURN (chain_context_apply_lookup (c
,
1701 backtrack
.len
, backtrack
.array
,
1702 input
.len
, input
.array
,
1703 lookahead
.len
, lookahead
.array
, lookup
.len
,
1704 lookup
.array
, lookup_context
));
1707 inline bool sanitize (hb_sanitize_context_t
*c
) const
1709 TRACE_SANITIZE (this);
1710 if (!backtrack
.sanitize (c
)) return TRACE_RETURN (false);
1711 const HeadlessArrayOf
<USHORT
> &input
= StructAfter
<HeadlessArrayOf
<USHORT
> > (backtrack
);
1712 if (!input
.sanitize (c
)) return TRACE_RETURN (false);
1713 const ArrayOf
<USHORT
> &lookahead
= StructAfter
<ArrayOf
<USHORT
> > (input
);
1714 if (!lookahead
.sanitize (c
)) return TRACE_RETURN (false);
1715 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
1716 return TRACE_RETURN (lookup
.sanitize (c
));
1721 backtrack
; /* Array of backtracking values
1722 * (to be matched before the input
1724 HeadlessArrayOf
<USHORT
>
1725 inputX
; /* Array of input values (start with
1728 lookaheadX
; /* Array of lookahead values's (to be
1729 * matched after the input sequence) */
1730 ArrayOf
<LookupRecord
>
1731 lookupX
; /* Array of LookupRecords--in
1734 DEFINE_SIZE_MIN (8);
1739 inline void closure (hb_closure_context_t
*c
, ChainContextClosureLookupContext
&lookup_context
) const
1741 TRACE_CLOSURE (this);
1742 unsigned int num_rules
= rule
.len
;
1743 for (unsigned int i
= 0; i
< num_rules
; i
++)
1744 (this+rule
[i
]).closure (c
, lookup_context
);
1747 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
, ChainContextCollectGlyphsLookupContext
&lookup_context
) const
1749 TRACE_COLLECT_GLYPHS (this);
1750 unsigned int num_rules
= rule
.len
;
1751 for (unsigned int i
= 0; i
< num_rules
; i
++)
1752 (this+rule
[i
]).collect_glyphs (c
, lookup_context
);
1755 inline bool would_apply (hb_would_apply_context_t
*c
, ChainContextApplyLookupContext
&lookup_context
) const
1757 TRACE_WOULD_APPLY (this);
1758 unsigned int num_rules
= rule
.len
;
1759 for (unsigned int i
= 0; i
< num_rules
; i
++)
1760 if ((this+rule
[i
]).would_apply (c
, lookup_context
))
1761 return TRACE_RETURN (true);
1763 return TRACE_RETURN (false);
1766 inline bool apply (hb_apply_context_t
*c
, ChainContextApplyLookupContext
&lookup_context
) const
1769 unsigned int num_rules
= rule
.len
;
1770 for (unsigned int i
= 0; i
< num_rules
; i
++)
1771 if ((this+rule
[i
]).apply (c
, lookup_context
))
1772 return TRACE_RETURN (true);
1774 return TRACE_RETURN (false);
1777 inline bool sanitize (hb_sanitize_context_t
*c
) const
1779 TRACE_SANITIZE (this);
1780 return TRACE_RETURN (rule
.sanitize (c
, this));
1784 OffsetArrayOf
<ChainRule
>
1785 rule
; /* Array of ChainRule tables
1786 * ordered by preference */
1788 DEFINE_SIZE_ARRAY (2, rule
);
1791 struct ChainContextFormat1
1793 inline void closure (hb_closure_context_t
*c
) const
1795 TRACE_CLOSURE (this);
1796 const Coverage
&cov
= (this+coverage
);
1798 struct ChainContextClosureLookupContext lookup_context
= {
1803 unsigned int count
= ruleSet
.len
;
1804 for (unsigned int i
= 0; i
< count
; i
++)
1805 if (cov
.intersects_coverage (c
->glyphs
, i
)) {
1806 const ChainRuleSet
&rule_set
= this+ruleSet
[i
];
1807 rule_set
.closure (c
, lookup_context
);
1811 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
) const
1813 TRACE_COLLECT_GLYPHS (this);
1814 (this+coverage
).add_coverage (c
->input
);
1816 struct ChainContextCollectGlyphsLookupContext lookup_context
= {
1821 unsigned int count
= ruleSet
.len
;
1822 for (unsigned int i
= 0; i
< count
; i
++)
1823 (this+ruleSet
[i
]).collect_glyphs (c
, lookup_context
);
1826 inline bool would_apply (hb_would_apply_context_t
*c
) const
1828 TRACE_WOULD_APPLY (this);
1830 const ChainRuleSet
&rule_set
= this+ruleSet
[(this+coverage
).get_coverage (c
->glyphs
[0])];
1831 struct ChainContextApplyLookupContext lookup_context
= {
1835 return TRACE_RETURN (rule_set
.would_apply (c
, lookup_context
));
1838 inline const Coverage
&get_coverage (void) const
1840 return this+coverage
;
1843 inline bool apply (hb_apply_context_t
*c
) const
1846 unsigned int index
= (this+coverage
).get_coverage (c
->buffer
->cur().codepoint
);
1847 if (likely (index
== NOT_COVERED
)) return TRACE_RETURN (false);
1849 const ChainRuleSet
&rule_set
= this+ruleSet
[index
];
1850 struct ChainContextApplyLookupContext lookup_context
= {
1854 return TRACE_RETURN (rule_set
.apply (c
, lookup_context
));
1857 inline bool sanitize (hb_sanitize_context_t
*c
) const
1859 TRACE_SANITIZE (this);
1860 return TRACE_RETURN (coverage
.sanitize (c
, this) && ruleSet
.sanitize (c
, this));
1864 USHORT format
; /* Format identifier--format = 1 */
1866 coverage
; /* Offset to Coverage table--from
1867 * beginning of table */
1868 OffsetArrayOf
<ChainRuleSet
>
1869 ruleSet
; /* Array of ChainRuleSet tables
1870 * ordered by Coverage Index */
1872 DEFINE_SIZE_ARRAY (6, ruleSet
);
1875 struct ChainContextFormat2
1877 inline void closure (hb_closure_context_t
*c
) const
1879 TRACE_CLOSURE (this);
1880 if (!(this+coverage
).intersects (c
->glyphs
))
1883 const ClassDef
&backtrack_class_def
= this+backtrackClassDef
;
1884 const ClassDef
&input_class_def
= this+inputClassDef
;
1885 const ClassDef
&lookahead_class_def
= this+lookaheadClassDef
;
1887 struct ChainContextClosureLookupContext lookup_context
= {
1889 {&backtrack_class_def
,
1891 &lookahead_class_def
}
1894 unsigned int count
= ruleSet
.len
;
1895 for (unsigned int i
= 0; i
< count
; i
++)
1896 if (input_class_def
.intersects_class (c
->glyphs
, i
)) {
1897 const ChainRuleSet
&rule_set
= this+ruleSet
[i
];
1898 rule_set
.closure (c
, lookup_context
);
1902 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
) const
1904 TRACE_COLLECT_GLYPHS (this);
1905 (this+coverage
).add_coverage (c
->input
);
1907 const ClassDef
&backtrack_class_def
= this+backtrackClassDef
;
1908 const ClassDef
&input_class_def
= this+inputClassDef
;
1909 const ClassDef
&lookahead_class_def
= this+lookaheadClassDef
;
1911 struct ChainContextCollectGlyphsLookupContext lookup_context
= {
1913 {&backtrack_class_def
,
1915 &lookahead_class_def
}
1918 unsigned int count
= ruleSet
.len
;
1919 for (unsigned int i
= 0; i
< count
; i
++)
1920 (this+ruleSet
[i
]).collect_glyphs (c
, lookup_context
);
1923 inline bool would_apply (hb_would_apply_context_t
*c
) const
1925 TRACE_WOULD_APPLY (this);
1927 const ClassDef
&backtrack_class_def
= this+backtrackClassDef
;
1928 const ClassDef
&input_class_def
= this+inputClassDef
;
1929 const ClassDef
&lookahead_class_def
= this+lookaheadClassDef
;
1931 unsigned int index
= input_class_def
.get_class (c
->glyphs
[0]);
1932 const ChainRuleSet
&rule_set
= this+ruleSet
[index
];
1933 struct ChainContextApplyLookupContext lookup_context
= {
1935 {&backtrack_class_def
,
1937 &lookahead_class_def
}
1939 return TRACE_RETURN (rule_set
.would_apply (c
, lookup_context
));
1942 inline const Coverage
&get_coverage (void) const
1944 return this+coverage
;
1947 inline bool apply (hb_apply_context_t
*c
) const
1950 unsigned int index
= (this+coverage
).get_coverage (c
->buffer
->cur().codepoint
);
1951 if (likely (index
== NOT_COVERED
)) return TRACE_RETURN (false);
1953 const ClassDef
&backtrack_class_def
= this+backtrackClassDef
;
1954 const ClassDef
&input_class_def
= this+inputClassDef
;
1955 const ClassDef
&lookahead_class_def
= this+lookaheadClassDef
;
1957 index
= input_class_def
.get_class (c
->buffer
->cur().codepoint
);
1958 const ChainRuleSet
&rule_set
= this+ruleSet
[index
];
1959 struct ChainContextApplyLookupContext lookup_context
= {
1961 {&backtrack_class_def
,
1963 &lookahead_class_def
}
1965 return TRACE_RETURN (rule_set
.apply (c
, lookup_context
));
1968 inline bool sanitize (hb_sanitize_context_t
*c
) const
1970 TRACE_SANITIZE (this);
1971 return TRACE_RETURN (coverage
.sanitize (c
, this) && backtrackClassDef
.sanitize (c
, this) &&
1972 inputClassDef
.sanitize (c
, this) && lookaheadClassDef
.sanitize (c
, this) &&
1973 ruleSet
.sanitize (c
, this));
1977 USHORT format
; /* Format identifier--format = 2 */
1979 coverage
; /* Offset to Coverage table--from
1980 * beginning of table */
1982 backtrackClassDef
; /* Offset to glyph ClassDef table
1983 * containing backtrack sequence
1984 * data--from beginning of table */
1986 inputClassDef
; /* Offset to glyph ClassDef
1987 * table containing input sequence
1988 * data--from beginning of table */
1990 lookaheadClassDef
; /* Offset to glyph ClassDef table
1991 * containing lookahead sequence
1992 * data--from beginning of table */
1993 OffsetArrayOf
<ChainRuleSet
>
1994 ruleSet
; /* Array of ChainRuleSet tables
1995 * ordered by class */
1997 DEFINE_SIZE_ARRAY (12, ruleSet
);
2000 struct ChainContextFormat3
2002 inline void closure (hb_closure_context_t
*c
) const
2004 TRACE_CLOSURE (this);
2005 const OffsetArrayOf
<Coverage
> &input
= StructAfter
<OffsetArrayOf
<Coverage
> > (backtrack
);
2007 if (!(this+input
[0]).intersects (c
->glyphs
))
2010 const OffsetArrayOf
<Coverage
> &lookahead
= StructAfter
<OffsetArrayOf
<Coverage
> > (input
);
2011 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
2012 struct ChainContextClosureLookupContext lookup_context
= {
2013 {intersects_coverage
},
2016 chain_context_closure_lookup (c
,
2017 backtrack
.len
, (const USHORT
*) backtrack
.array
,
2018 input
.len
, (const USHORT
*) input
.array
+ 1,
2019 lookahead
.len
, (const USHORT
*) lookahead
.array
,
2020 lookup
.len
, lookup
.array
,
2024 inline void collect_glyphs (hb_collect_glyphs_context_t
*c
) const
2026 TRACE_COLLECT_GLYPHS (this);
2027 const OffsetArrayOf
<Coverage
> &input
= StructAfter
<OffsetArrayOf
<Coverage
> > (backtrack
);
2029 (this+input
[0]).add_coverage (c
->input
);
2031 const OffsetArrayOf
<Coverage
> &lookahead
= StructAfter
<OffsetArrayOf
<Coverage
> > (input
);
2032 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
2033 struct ChainContextCollectGlyphsLookupContext lookup_context
= {
2037 chain_context_collect_glyphs_lookup (c
,
2038 backtrack
.len
, (const USHORT
*) backtrack
.array
,
2039 input
.len
, (const USHORT
*) input
.array
+ 1,
2040 lookahead
.len
, (const USHORT
*) lookahead
.array
,
2041 lookup
.len
, lookup
.array
,
2045 inline bool would_apply (hb_would_apply_context_t
*c
) const
2047 TRACE_WOULD_APPLY (this);
2049 const OffsetArrayOf
<Coverage
> &input
= StructAfter
<OffsetArrayOf
<Coverage
> > (backtrack
);
2050 const OffsetArrayOf
<Coverage
> &lookahead
= StructAfter
<OffsetArrayOf
<Coverage
> > (input
);
2051 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
2052 struct ChainContextApplyLookupContext lookup_context
= {
2056 return TRACE_RETURN (chain_context_would_apply_lookup (c
,
2057 backtrack
.len
, (const USHORT
*) backtrack
.array
,
2058 input
.len
, (const USHORT
*) input
.array
+ 1,
2059 lookahead
.len
, (const USHORT
*) lookahead
.array
,
2060 lookup
.len
, lookup
.array
, lookup_context
));
2063 inline const Coverage
&get_coverage (void) const
2065 const OffsetArrayOf
<Coverage
> &input
= StructAfter
<OffsetArrayOf
<Coverage
> > (backtrack
);
2066 return this+input
[0];
2069 inline bool apply (hb_apply_context_t
*c
) const
2072 const OffsetArrayOf
<Coverage
> &input
= StructAfter
<OffsetArrayOf
<Coverage
> > (backtrack
);
2074 unsigned int index
= (this+input
[0]).get_coverage (c
->buffer
->cur().codepoint
);
2075 if (likely (index
== NOT_COVERED
)) return TRACE_RETURN (false);
2077 const OffsetArrayOf
<Coverage
> &lookahead
= StructAfter
<OffsetArrayOf
<Coverage
> > (input
);
2078 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
2079 struct ChainContextApplyLookupContext lookup_context
= {
2083 return TRACE_RETURN (chain_context_apply_lookup (c
,
2084 backtrack
.len
, (const USHORT
*) backtrack
.array
,
2085 input
.len
, (const USHORT
*) input
.array
+ 1,
2086 lookahead
.len
, (const USHORT
*) lookahead
.array
,
2087 lookup
.len
, lookup
.array
, lookup_context
));
2090 inline bool sanitize (hb_sanitize_context_t
*c
) const
2092 TRACE_SANITIZE (this);
2093 if (!backtrack
.sanitize (c
, this)) return TRACE_RETURN (false);
2094 const OffsetArrayOf
<Coverage
> &input
= StructAfter
<OffsetArrayOf
<Coverage
> > (backtrack
);
2095 if (!input
.sanitize (c
, this)) return TRACE_RETURN (false);
2096 if (!input
.len
) return TRACE_RETURN (false); /* To be consistent with Context. */
2097 const OffsetArrayOf
<Coverage
> &lookahead
= StructAfter
<OffsetArrayOf
<Coverage
> > (input
);
2098 if (!lookahead
.sanitize (c
, this)) return TRACE_RETURN (false);
2099 const ArrayOf
<LookupRecord
> &lookup
= StructAfter
<ArrayOf
<LookupRecord
> > (lookahead
);
2100 return TRACE_RETURN (lookup
.sanitize (c
));
2104 USHORT format
; /* Format identifier--format = 3 */
2105 OffsetArrayOf
<Coverage
>
2106 backtrack
; /* Array of coverage tables
2107 * in backtracking sequence, in glyph
2109 OffsetArrayOf
<Coverage
>
2110 inputX
; /* Array of coverage
2111 * tables in input sequence, in glyph
2113 OffsetArrayOf
<Coverage
>
2114 lookaheadX
; /* Array of coverage tables
2115 * in lookahead sequence, in glyph
2117 ArrayOf
<LookupRecord
>
2118 lookupX
; /* Array of LookupRecords--in
2121 DEFINE_SIZE_MIN (10);
2126 template <typename context_t
>
2127 inline typename
context_t::return_t
dispatch (context_t
*c
) const
2129 TRACE_DISPATCH (this, u
.format
);
2130 if (unlikely (!c
->may_dispatch (this, &u
.format
))) TRACE_RETURN (c
->default_return_value ());
2132 case 1: return TRACE_RETURN (c
->dispatch (u
.format1
));
2133 case 2: return TRACE_RETURN (c
->dispatch (u
.format2
));
2134 case 3: return TRACE_RETURN (c
->dispatch (u
.format3
));
2135 default:return TRACE_RETURN (c
->default_return_value ());
2141 USHORT format
; /* Format identifier */
2142 ChainContextFormat1 format1
;
2143 ChainContextFormat2 format2
;
2144 ChainContextFormat3 format3
;
2149 template <typename T
>
2150 struct ExtensionFormat1
2152 inline unsigned int get_type (void) const { return extensionLookupType
; }
2154 template <typename X
>
2155 inline const X
& get_subtable (void) const
2157 unsigned int offset
= extensionOffset
;
2158 if (unlikely (!offset
)) return Null(typename
T::LookupSubTable
);
2159 return StructAtOffset
<typename
T::LookupSubTable
> (this, offset
);
2162 template <typename context_t
>
2163 inline typename
context_t::return_t
dispatch (context_t
*c
) const
2165 TRACE_DISPATCH (this, format
);
2166 if (unlikely (!c
->may_dispatch (this, this))) TRACE_RETURN (c
->default_return_value ());
2167 return TRACE_RETURN (get_subtable
<typename
T::LookupSubTable
> ().dispatch (c
, get_type ()));
2170 /* This is called from may_dispatch() above with hb_sanitize_context_t. */
2171 inline bool sanitize (hb_sanitize_context_t
*c
) const
2173 TRACE_SANITIZE (this);
2174 return TRACE_RETURN (c
->check_struct (this) && extensionOffset
!= 0);
2178 USHORT format
; /* Format identifier. Set to 1. */
2179 USHORT extensionLookupType
; /* Lookup type of subtable referenced
2180 * by ExtensionOffset (i.e. the
2181 * extension subtable). */
2182 ULONG extensionOffset
; /* Offset to the extension subtable,
2183 * of lookup type subtable. */
2185 DEFINE_SIZE_STATIC (8);
2188 template <typename T
>
2191 inline unsigned int get_type (void) const
2194 case 1: return u
.format1
.get_type ();
2198 template <typename X
>
2199 inline const X
& get_subtable (void) const
2202 case 1: return u
.format1
.template get_subtable
<typename
T::LookupSubTable
> ();
2203 default:return Null(typename
T::LookupSubTable
);
2207 template <typename context_t
>
2208 inline typename
context_t::return_t
dispatch (context_t
*c
) const
2210 TRACE_DISPATCH (this, u
.format
);
2211 if (unlikely (!c
->may_dispatch (this, &u
.format
))) TRACE_RETURN (c
->default_return_value ());
2213 case 1: return TRACE_RETURN (u
.format1
.dispatch (c
));
2214 default:return TRACE_RETURN (c
->default_return_value ());
2220 USHORT format
; /* Format identifier */
2221 ExtensionFormat1
<T
> format1
;
2232 static const hb_tag_t GSUBTag
= HB_OT_TAG_GSUB
;
2233 static const hb_tag_t GPOSTag
= HB_OT_TAG_GPOS
;
2235 inline unsigned int get_script_count (void) const
2236 { return (this+scriptList
).len
; }
2237 inline const Tag
& get_script_tag (unsigned int i
) const
2238 { return (this+scriptList
).get_tag (i
); }
2239 inline unsigned int get_script_tags (unsigned int start_offset
,
2240 unsigned int *script_count
/* IN/OUT */,
2241 hb_tag_t
*script_tags
/* OUT */) const
2242 { return (this+scriptList
).get_tags (start_offset
, script_count
, script_tags
); }
2243 inline const Script
& get_script (unsigned int i
) const
2244 { return (this+scriptList
)[i
]; }
2245 inline bool find_script_index (hb_tag_t tag
, unsigned int *index
) const
2246 { return (this+scriptList
).find_index (tag
, index
); }
2248 inline unsigned int get_feature_count (void) const
2249 { return (this+featureList
).len
; }
2250 inline hb_tag_t
get_feature_tag (unsigned int i
) const
2251 { return i
== Index::NOT_FOUND_INDEX
? HB_TAG_NONE
: (this+featureList
).get_tag (i
); }
2252 inline unsigned int get_feature_tags (unsigned int start_offset
,
2253 unsigned int *feature_count
/* IN/OUT */,
2254 hb_tag_t
*feature_tags
/* OUT */) const
2255 { return (this+featureList
).get_tags (start_offset
, feature_count
, feature_tags
); }
2256 inline const Feature
& get_feature (unsigned int i
) const
2257 { return (this+featureList
)[i
]; }
2258 inline bool find_feature_index (hb_tag_t tag
, unsigned int *index
) const
2259 { return (this+featureList
).find_index (tag
, index
); }
2261 inline unsigned int get_lookup_count (void) const
2262 { return (this+lookupList
).len
; }
2263 inline const Lookup
& get_lookup (unsigned int i
) const
2264 { return (this+lookupList
)[i
]; }
2266 inline bool sanitize (hb_sanitize_context_t
*c
) const
2268 TRACE_SANITIZE (this);
2269 return TRACE_RETURN (version
.sanitize (c
) && likely (version
.major
== 1) &&
2270 scriptList
.sanitize (c
, this) &&
2271 featureList
.sanitize (c
, this) &&
2272 lookupList
.sanitize (c
, this));
2276 FixedVersion version
; /* Version of the GSUB/GPOS table--initially set
2278 OffsetTo
<ScriptList
>
2279 scriptList
; /* ScriptList table */
2280 OffsetTo
<FeatureList
>
2281 featureList
; /* FeatureList table */
2282 OffsetTo
<LookupList
>
2283 lookupList
; /* LookupList table */
2285 DEFINE_SIZE_STATIC (10);
2289 } /* namespace OT */
2292 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */