The Tor Browser / file comparison

comparison: gfx/harfbuzz/src/hb-ot-layout-gsubgpos-private.hh

gfx/harfbuzz/src/hb-ot-layout-gsubgpos-private.hh

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:5fcbe106d90c
1 /*
2 * Copyright © 2007,2008,2009,2010 Red Hat, Inc.
3 * Copyright © 2010,2012 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 * Red Hat Author(s): Behdad Esfahbod
26 * Google Author(s): Behdad Esfahbod
27 */
28
29 #ifndef HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH
30 #define HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH
31
32 #include "hb-buffer-private.hh"
33 #include "hb-ot-layout-gdef-table.hh"
34 #include "hb-set-private.hh"
35
36
37 namespace OT {
38
39
40
41 #define TRACE_DISPATCH(this) \
42 hb_auto_trace_t<context_t::max_debug_depth, typename context_t::return_t> trace \
43 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
44 "");
45
46 #ifndef HB_DEBUG_CLOSURE
47 #define HB_DEBUG_CLOSURE (HB_DEBUG+0)
48 #endif
49
50 #define TRACE_CLOSURE(this) \
51 hb_auto_trace_t<HB_DEBUG_CLOSURE, hb_void_t> trace \
52 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
53 "");
54
55 struct hb_closure_context_t
56 {
57 inline const char *get_name (void) { return "CLOSURE"; }
58 static const unsigned int max_debug_depth = HB_DEBUG_CLOSURE;
59 typedef hb_void_t return_t;
60 typedef return_t (*recurse_func_t) (hb_closure_context_t *c, unsigned int lookup_index);
61 template <typename T>
62 inline return_t dispatch (const T &obj) { obj.closure (this); return HB_VOID; }
63 static return_t default_return_value (void) { return HB_VOID; }
64 bool stop_sublookup_iteration (return_t r HB_UNUSED) const { return false; }
65 return_t recurse (unsigned int lookup_index)
66 {
67 if (unlikely (nesting_level_left == 0 || !recurse_func))
68 return default_return_value ();
69
70 nesting_level_left--;
71 recurse_func (this, lookup_index);
72 nesting_level_left++;
73 return HB_VOID;
74 }
75
76 hb_face_t *face;
77 hb_set_t *glyphs;
78 recurse_func_t recurse_func;
79 unsigned int nesting_level_left;
80 unsigned int debug_depth;
81
82 hb_closure_context_t (hb_face_t *face_,
83 hb_set_t *glyphs_,
84 unsigned int nesting_level_left_ = MAX_NESTING_LEVEL) :
85 face (face_),
86 glyphs (glyphs_),
87 recurse_func (NULL),
88 nesting_level_left (nesting_level_left_),
89 debug_depth (0) {}
90
91 void set_recurse_func (recurse_func_t func) { recurse_func = func; }
92 };
93
94
95
96 #ifndef HB_DEBUG_WOULD_APPLY
97 #define HB_DEBUG_WOULD_APPLY (HB_DEBUG+0)
98 #endif
99
100 #define TRACE_WOULD_APPLY(this) \
101 hb_auto_trace_t<HB_DEBUG_WOULD_APPLY, bool> trace \
102 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
103 "%d glyphs", c->len);
104
105 struct hb_would_apply_context_t
106 {
107 inline const char *get_name (void) { return "WOULD_APPLY"; }
108 static const unsigned int max_debug_depth = HB_DEBUG_WOULD_APPLY;
109 typedef bool return_t;
110 template <typename T>
111 inline return_t dispatch (const T &obj) { return obj.would_apply (this); }
112 static return_t default_return_value (void) { return false; }
113 bool stop_sublookup_iteration (return_t r) const { return r; }
114
115 hb_face_t *face;
116 const hb_codepoint_t *glyphs;
117 unsigned int len;
118 bool zero_context;
119 unsigned int debug_depth;
120
121 hb_would_apply_context_t (hb_face_t *face_,
122 const hb_codepoint_t *glyphs_,
123 unsigned int len_,
124 bool zero_context_) :
125 face (face_),
126 glyphs (glyphs_),
127 len (len_),
128 zero_context (zero_context_),
129 debug_depth (0) {}
130 };
131
132
133
134 #ifndef HB_DEBUG_COLLECT_GLYPHS
135 #define HB_DEBUG_COLLECT_GLYPHS (HB_DEBUG+0)
136 #endif
137
138 #define TRACE_COLLECT_GLYPHS(this) \
139 hb_auto_trace_t<HB_DEBUG_COLLECT_GLYPHS, hb_void_t> trace \
140 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
141 "");
142
143 struct hb_collect_glyphs_context_t
144 {
145 inline const char *get_name (void) { return "COLLECT_GLYPHS"; }
146 static const unsigned int max_debug_depth = HB_DEBUG_COLLECT_GLYPHS;
147 typedef hb_void_t return_t;
148 typedef return_t (*recurse_func_t) (hb_collect_glyphs_context_t *c, unsigned int lookup_index);
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)
154 {
155 if (unlikely (nesting_level_left == 0 || !recurse_func))
156 return default_return_value ();
157
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.
161 *
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.
166 */
167
168 if (output == hb_set_get_empty ())
169 return HB_VOID;
170
171 hb_set_t *old_before = before;
172 hb_set_t *old_input = input;
173 hb_set_t *old_after = after;
174 before = input = after = hb_set_get_empty ();
175
176 nesting_level_left--;
177 recurse_func (this, lookup_index);
178 nesting_level_left++;
179
180 before = old_before;
181 input = old_input;
182 after = old_after;
183
184 return HB_VOID;
185 }
186
187 hb_face_t *face;
188 hb_set_t *before;
189 hb_set_t *input;
190 hb_set_t *after;
191 hb_set_t *output;
192 recurse_func_t recurse_func;
193 unsigned int nesting_level_left;
194 unsigned int debug_depth;
195
196 hb_collect_glyphs_context_t (hb_face_t *face_,
197 hb_set_t *glyphs_before, /* OUT. May be NULL */
198 hb_set_t *glyphs_input, /* OUT. May be NULL */
199 hb_set_t *glyphs_after, /* OUT. May be NULL */
200 hb_set_t *glyphs_output, /* OUT. May be NULL */
201 unsigned int nesting_level_left_ = MAX_NESTING_LEVEL) :
202 face (face_),
203 before (glyphs_before ? glyphs_before : hb_set_get_empty ()),
204 input (glyphs_input ? glyphs_input : hb_set_get_empty ()),
205 after (glyphs_after ? glyphs_after : hb_set_get_empty ()),
206 output (glyphs_output ? glyphs_output : hb_set_get_empty ()),
207 recurse_func (NULL),
208 nesting_level_left (nesting_level_left_),
209 debug_depth (0) {}
210
211 void set_recurse_func (recurse_func_t func) { recurse_func = func; }
212 };
213
214
215
216 struct hb_get_coverage_context_t
217 {
218 inline const char *get_name (void) { return "GET_COVERAGE"; }
219 static const unsigned int max_debug_depth = 0;
220 typedef const Coverage &return_t;
221 template <typename T>
222 inline return_t dispatch (const T &obj) { return obj.get_coverage (); }
223 static return_t default_return_value (void) { return Null(Coverage); }
224
225 hb_get_coverage_context_t (void) :
226 debug_depth (0) {}
227
228 unsigned int debug_depth;
229 };
230
231
232
233 #ifndef HB_DEBUG_APPLY
234 #define HB_DEBUG_APPLY (HB_DEBUG+0)
235 #endif
236
237 #define TRACE_APPLY(this) \
238 hb_auto_trace_t<HB_DEBUG_APPLY, bool> trace \
239 (&c->debug_depth, c->get_name (), this, HB_FUNC, \
240 "idx %d codepoint %u", c->buffer->idx, c->buffer->cur().codepoint);
241
242 struct hb_apply_context_t
243 {
244 inline const char *get_name (void) { return "APPLY"; }
245 static const unsigned int max_debug_depth = HB_DEBUG_APPLY;
246 typedef bool return_t;
247 typedef return_t (*recurse_func_t) (hb_apply_context_t *c, unsigned int lookup_index);
248 template <typename T>
249 inline return_t dispatch (const T &obj) { return obj.apply (this); }
250 static return_t default_return_value (void) { return false; }
251 bool stop_sublookup_iteration (return_t r) const { return r; }
252 return_t recurse (unsigned int lookup_index)
253 {
254 if (unlikely (nesting_level_left == 0 || !recurse_func))
255 return default_return_value ();
256
257 nesting_level_left--;
258 bool ret = recurse_func (this, lookup_index);
259 nesting_level_left++;
260 return ret;
261 }
262
263 unsigned int table_index; /* GSUB/GPOS */
264 hb_font_t *font;
265 hb_face_t *face;
266 hb_buffer_t *buffer;
267 hb_direction_t direction;
268 hb_mask_t lookup_mask;
269 bool auto_zwj;
270 recurse_func_t recurse_func;
271 unsigned int nesting_level_left;
272 unsigned int lookup_props;
273 const GDEF &gdef;
274 bool has_glyph_classes;
275 unsigned int debug_depth;
276
277
278 hb_apply_context_t (unsigned int table_index_,
279 hb_font_t *font_,
280 hb_buffer_t *buffer_) :
281 table_index (table_index_),
282 font (font_), face (font->face), buffer (buffer_),
283 direction (buffer_->props.direction),
284 lookup_mask (1),
285 auto_zwj (true),
286 recurse_func (NULL),
287 nesting_level_left (MAX_NESTING_LEVEL),
288 lookup_props (0),
289 gdef (*hb_ot_layout_from_face (face)->gdef),
290 has_glyph_classes (gdef.has_glyph_classes ()),
291 debug_depth (0) {}
292
293 inline void set_lookup_mask (hb_mask_t mask) { lookup_mask = mask; }
294 inline void set_auto_zwj (bool auto_zwj_) { auto_zwj = auto_zwj_; }
295 inline void set_recurse_func (recurse_func_t func) { recurse_func = func; }
296 inline void set_lookup_props (unsigned int lookup_props_) { lookup_props = lookup_props_; }
297 inline void set_lookup (const Lookup &l) { lookup_props = l.get_props (); }
298
299 struct matcher_t
300 {
301 inline matcher_t (void) :
302 lookup_props (0),
303 ignore_zwnj (false),
304 ignore_zwj (false),
305 mask (-1),
306 #define arg1(arg) (arg) /* Remove the macro to see why it's needed! */
307 syllable arg1(0),
308 #undef arg1
309 match_func (NULL),
310 match_data (NULL) {};
311
312 typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
313
314 inline void set_ignore_zwnj (bool ignore_zwnj_) { ignore_zwnj = ignore_zwnj_; }
315 inline void set_ignore_zwj (bool ignore_zwj_) { ignore_zwj = ignore_zwj_; }
316 inline void set_lookup_props (unsigned int lookup_props_) { lookup_props = lookup_props_; }
317 inline void set_mask (hb_mask_t mask_) { mask = mask_; }
318 inline void set_syllable (uint8_t syllable_) { syllable = syllable_; }
319 inline void set_match_func (match_func_t match_func_,
320 const void *match_data_)
321 { match_func = match_func_; match_data = match_data_; }
322
323 enum may_match_t {
324 MATCH_NO,
325 MATCH_YES,
326 MATCH_MAYBE
327 };
328
329 inline may_match_t may_match (const hb_glyph_info_t &info,
330 const USHORT *glyph_data) const
331 {
332 if (!(info.mask & mask) ||
333 (syllable && syllable != info.syllable ()))
334 return MATCH_NO;
335
336 if (match_func)
337 return match_func (info.codepoint, *glyph_data, match_data) ? MATCH_YES : MATCH_NO;
338
339 return MATCH_MAYBE;
340 }
341
342 enum may_skip_t {
343 SKIP_NO,
344 SKIP_YES,
345 SKIP_MAYBE
346 };
347
348 inline may_skip_t
349 may_skip (const hb_apply_context_t *c,
350 const hb_glyph_info_t &info) const
351 {
352 unsigned int property;
353
354 property = _hb_glyph_info_get_glyph_props (&info);
355
356 if (!c->match_properties (info.codepoint, property, lookup_props))
357 return SKIP_YES;
358
359 if (unlikely (_hb_glyph_info_is_default_ignorable (&info) &&
360 (ignore_zwnj || !_hb_glyph_info_is_zwnj (&info)) &&
361 (ignore_zwj || !_hb_glyph_info_is_zwj (&info)) &&
362 !_hb_glyph_info_ligated (&info)))
363 return SKIP_MAYBE;
364
365 return SKIP_NO;
366 }
367
368 protected:
369 unsigned int lookup_props;
370 bool ignore_zwnj;
371 bool ignore_zwj;
372 hb_mask_t mask;
373 uint8_t syllable;
374 match_func_t match_func;
375 const void *match_data;
376 };
377
378 struct skipping_forward_iterator_t
379 {
380 inline skipping_forward_iterator_t (hb_apply_context_t *c_,
381 unsigned int start_index_,
382 unsigned int num_items_,
383 bool context_match = false) :
384 idx (start_index_),
385 c (c_),
386 match_glyph_data (NULL),
387 num_items (num_items_),
388 end (c->buffer->len)
389 {
390 matcher.set_lookup_props (c->lookup_props);
391 /* Ignore ZWNJ if we are matching GSUB context, or matching GPOS. */
392 matcher.set_ignore_zwnj (context_match || c->table_index == 1);
393 /* Ignore ZWJ if we are matching GSUB context, or matching GPOS, or if asked to. */
394 matcher.set_ignore_zwj (context_match || c->table_index == 1 || c->auto_zwj);
395 if (!context_match)
396 matcher.set_mask (c->lookup_mask);
397 matcher.set_syllable (start_index_ == c->buffer->idx ? c->buffer->cur().syllable () : 0);
398 }
399 inline void set_lookup_props (unsigned int lookup_props) { matcher.set_lookup_props (lookup_props); }
400 inline void set_syllable (unsigned int syllable) { matcher.set_syllable (syllable); }
401 inline void set_match_func (matcher_t::match_func_t match_func,
402 const void *match_data,
403 const USHORT glyph_data[])
404 {
405 matcher.set_match_func (match_func, match_data);
406 match_glyph_data = glyph_data;
407 }
408
409 inline bool has_no_chance (void) const { return unlikely (num_items && idx + num_items >= end); }
410 inline void reject (void) { num_items++; match_glyph_data--; }
411 inline bool next (void)
412 {
413 assert (num_items > 0);
414 while (!has_no_chance ())
415 {
416 idx++;
417 const hb_glyph_info_t &info = c->buffer->info[idx];
418
419 matcher_t::may_skip_t skip = matcher.may_skip (c, info);
420 if (unlikely (skip == matcher_t::SKIP_YES))
421 continue;
422
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))
427 {
428 num_items--;
429 match_glyph_data++;
430 return true;
431 }
432
433 if (skip == matcher_t::SKIP_NO)
434 return false;
435 }
436 return false;
437 }
438
439 unsigned int idx;
440 protected:
441 hb_apply_context_t *c;
442 matcher_t matcher;
443 const USHORT *match_glyph_data;
444
445 unsigned int num_items;
446 unsigned int end;
447 };
448
449 struct skipping_backward_iterator_t
450 {
451 inline skipping_backward_iterator_t (hb_apply_context_t *c_,
452 unsigned int start_index_,
453 unsigned int num_items_,
454 bool context_match = false) :
455 idx (start_index_),
456 c (c_),
457 match_glyph_data (NULL),
458 num_items (num_items_)
459 {
460 matcher.set_lookup_props (c->lookup_props);
461 /* Ignore ZWNJ if we are matching GSUB context, or matching GPOS. */
462 matcher.set_ignore_zwnj (context_match || c->table_index == 1);
463 /* Ignore ZWJ if we are matching GSUB context, or matching GPOS, or if asked to. */
464 matcher.set_ignore_zwj (context_match || c->table_index == 1 || c->auto_zwj);
465 if (!context_match)
466 matcher.set_mask (c->lookup_mask);
467 matcher.set_syllable (start_index_ == c->buffer->idx ? c->buffer->cur().syllable () : 0);
468 }
469 inline void set_lookup_props (unsigned int lookup_props) { matcher.set_lookup_props (lookup_props); }
470 inline void set_syllable (unsigned int syllable) { matcher.set_syllable (syllable); }
471 inline void set_match_func (matcher_t::match_func_t match_func,
472 const void *match_data,
473 const USHORT glyph_data[])
474 {
475 matcher.set_match_func (match_func, match_data);
476 match_glyph_data = glyph_data;
477 }
478
479 inline bool has_no_chance (void) const { return unlikely (idx < num_items); }
480 inline void reject (void) { num_items++; }
481 inline bool prev (void)
482 {
483 assert (num_items > 0);
484 while (!has_no_chance ())
485 {
486 idx--;
487 const hb_glyph_info_t &info = c->buffer->out_info[idx];
488
489 matcher_t::may_skip_t skip = matcher.may_skip (c, info);
490
491 if (unlikely (skip == matcher_t::SKIP_YES))
492 continue;
493
494 matcher_t::may_match_t match = matcher.may_match (info, match_glyph_data);
495 if (match == matcher_t::MATCH_YES ||
496 (match == matcher_t::MATCH_MAYBE &&
497 skip == matcher_t::SKIP_NO))
498 {
499 num_items--;
500 match_glyph_data++;
501 return true;
502 }
503
504 if (skip == matcher_t::SKIP_NO)
505 return false;
506 }
507 return false;
508 }
509
510 unsigned int idx;
511 protected:
512 hb_apply_context_t *c;
513 matcher_t matcher;
514 const USHORT *match_glyph_data;
515
516 unsigned int num_items;
517 };
518
519 inline bool
520 match_properties_mark (hb_codepoint_t glyph,
521 unsigned int glyph_props,
522 unsigned int lookup_props) const
523 {
524 /* If using mark filtering sets, the high short of
525 * lookup_props has the set index.
526 */
527 if (lookup_props & LookupFlag::UseMarkFilteringSet)
528 return gdef.mark_set_covers (lookup_props >> 16, glyph);
529
530 /* The second byte of lookup_props has the meaning
531 * "ignore marks of attachment type different than
532 * the attachment type specified."
533 */
534 if (lookup_props & LookupFlag::MarkAttachmentType)
535 return (lookup_props & LookupFlag::MarkAttachmentType) == (glyph_props & LookupFlag::MarkAttachmentType);
536
537 return true;
538 }
539
540 inline bool
541 match_properties (hb_codepoint_t glyph,
542 unsigned int glyph_props,
543 unsigned int lookup_props) const
544 {
545 /* Not covered, if, for example, glyph class is ligature and
546 * lookup_props includes LookupFlags::IgnoreLigatures
547 */
548 if (glyph_props & lookup_props & LookupFlag::IgnoreFlags)
549 return false;
550
551 if (unlikely (glyph_props & HB_OT_LAYOUT_GLYPH_PROPS_MARK))
552 return match_properties_mark (glyph, glyph_props, lookup_props);
553
554 return true;
555 }
556
557 inline bool
558 check_glyph_property (hb_glyph_info_t *info,
559 unsigned int lookup_props) const
560 {
561 unsigned int property;
562
563 property = _hb_glyph_info_get_glyph_props (info);
564
565 return match_properties (info->codepoint, property, lookup_props);
566 }
567
568 inline void _set_glyph_props (hb_codepoint_t glyph_index,
569 unsigned int class_guess = 0,
570 bool ligature = false) const
571 {
572 unsigned int add_in = _hb_glyph_info_get_glyph_props (&buffer->cur()) &
573 HB_OT_LAYOUT_GLYPH_PROPS_PRESERVE;
574 add_in |= HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED;
575 if (ligature)
576 add_in |= HB_OT_LAYOUT_GLYPH_PROPS_LIGATED;
577 if (likely (has_glyph_classes))
578 _hb_glyph_info_set_glyph_props (&buffer->cur(), add_in | gdef.get_glyph_props (glyph_index));
579 else if (class_guess)
580 _hb_glyph_info_set_glyph_props (&buffer->cur(), add_in | class_guess);
581 }
582
583 inline void replace_glyph (hb_codepoint_t glyph_index) const
584 {
585 _set_glyph_props (glyph_index);
586 buffer->replace_glyph (glyph_index);
587 }
588 inline void replace_glyph_inplace (hb_codepoint_t glyph_index) const
589 {
590 _set_glyph_props (glyph_index);
591 buffer->cur().codepoint = glyph_index;
592 }
593 inline void replace_glyph_with_ligature (hb_codepoint_t glyph_index,
594 unsigned int class_guess) const
595 {
596 _set_glyph_props (glyph_index, class_guess, true);
597 buffer->replace_glyph (glyph_index);
598 }
599 inline void output_glyph (hb_codepoint_t glyph_index,
600 unsigned int class_guess) const
601 {
602 _set_glyph_props (glyph_index, class_guess);
603 buffer->output_glyph (glyph_index);
604 }
605 };
606
607
608
609 typedef bool (*intersects_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
610 typedef void (*collect_glyphs_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
611 typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
612
613 struct ContextClosureFuncs
614 {
615 intersects_func_t intersects;
616 };
617 struct ContextCollectGlyphsFuncs
618 {
619 collect_glyphs_func_t collect;
620 };
621 struct ContextApplyFuncs
622 {
623 match_func_t match;
624 };
625
626
627 static inline bool intersects_glyph (hb_set_t *glyphs, const USHORT &value, const void *data HB_UNUSED)
628 {
629 return glyphs->has (value);
630 }
631 static inline bool intersects_class (hb_set_t *glyphs, const USHORT &value, const void *data)
632 {
633 const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
634 return class_def.intersects_class (glyphs, value);
635 }
636 static inline bool intersects_coverage (hb_set_t *glyphs, const USHORT &value, const void *data)
637 {
638 const OffsetTo<Coverage> &coverage = (const OffsetTo<Coverage>&)value;
639 return (data+coverage).intersects (glyphs);
640 }
641
642 static inline bool intersects_array (hb_closure_context_t *c,
643 unsigned int count,
644 const USHORT values[],
645 intersects_func_t intersects_func,
646 const void *intersects_data)
647 {
648 for (unsigned int i = 0; i < count; i++)
649 if (likely (!intersects_func (c->glyphs, values[i], intersects_data)))
650 return false;
651 return true;
652 }
653
654
655 static inline void collect_glyph (hb_set_t *glyphs, const USHORT &value, const void *data HB_UNUSED)
656 {
657 glyphs->add (value);
658 }
659 static inline void collect_class (hb_set_t *glyphs, const USHORT &value, const void *data)
660 {
661 const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
662 class_def.add_class (glyphs, value);
663 }
664 static inline void collect_coverage (hb_set_t *glyphs, const USHORT &value, const void *data)
665 {
666 const OffsetTo<Coverage> &coverage = (const OffsetTo<Coverage>&)value;
667 (data+coverage).add_coverage (glyphs);
668 }
669 static inline void collect_array (hb_collect_glyphs_context_t *c HB_UNUSED,
670 hb_set_t *glyphs,
671 unsigned int count,
672 const USHORT values[],
673 collect_glyphs_func_t collect_func,
674 const void *collect_data)
675 {
676 for (unsigned int i = 0; i < count; i++)
677 collect_func (glyphs, values[i], collect_data);
678 }
679
680
681 static inline bool match_glyph (hb_codepoint_t glyph_id, const USHORT &value, const void *data HB_UNUSED)
682 {
683 return glyph_id == value;
684 }
685 static inline bool match_class (hb_codepoint_t glyph_id, const USHORT &value, const void *data)
686 {
687 const ClassDef &class_def = *reinterpret_cast<const ClassDef *>(data);
688 return class_def.get_class (glyph_id) == value;
689 }
690 static inline bool match_coverage (hb_codepoint_t glyph_id, const USHORT &value, const void *data)
691 {
692 const OffsetTo<Coverage> &coverage = (const OffsetTo<Coverage>&)value;
693 return (data+coverage).get_coverage (glyph_id) != NOT_COVERED;
694 }
695
696 static inline bool would_match_input (hb_would_apply_context_t *c,
697 unsigned int count, /* Including the first glyph (not matched) */
698 const USHORT input[], /* Array of input values--start with second glyph */
699 match_func_t match_func,
700 const void *match_data)
701 {
702 if (count != c->len)
703 return false;
704
705 for (unsigned int i = 1; i < count; i++)
706 if (likely (!match_func (c->glyphs[i], input[i - 1], match_data)))
707 return false;
708
709 return true;
710 }
711 static inline bool match_input (hb_apply_context_t *c,
712 unsigned int count, /* Including the first glyph (not matched) */
713 const USHORT input[], /* Array of input values--start with second glyph */
714 match_func_t match_func,
715 const void *match_data,
716 unsigned int *end_offset,
717 unsigned int match_positions[MAX_CONTEXT_LENGTH],
718 bool *p_is_mark_ligature = NULL,
719 unsigned int *p_total_component_count = NULL)
720 {
721 TRACE_APPLY (NULL);
722
723 if (unlikely (count > MAX_CONTEXT_LENGTH)) TRACE_RETURN (false);
724
725 hb_buffer_t *buffer = c->buffer;
726
727 hb_apply_context_t::skipping_forward_iterator_t skippy_iter (c, buffer->idx, count - 1);
728 skippy_iter.set_match_func (match_func, match_data, input);
729 if (skippy_iter.has_no_chance ()) return TRACE_RETURN (false);
730
731 /*
732 * This is perhaps the trickiest part of OpenType... Remarks:
733 *
734 * - If all components of the ligature were marks, we call this a mark ligature.
735 *
736 * - If there is no GDEF, and the ligature is NOT a mark ligature, we categorize
737 * it as a ligature glyph.
738 *
739 * - Ligatures cannot be formed across glyphs attached to different components
740 * of previous ligatures. Eg. the sequence is LAM,SHADDA,LAM,FATHA,HEH, and
741 * LAM,LAM,HEH form a ligature, leaving SHADDA,FATHA next to eachother.
742 * However, it would be wrong to ligate that SHADDA,FATHA sequence.o
743 * There is an exception to this: If a ligature tries ligating with marks that
744 * belong to it itself, go ahead, assuming that the font designer knows what
745 * they are doing (otherwise it can break Indic stuff when a matra wants to
746 * ligate with a conjunct...)
747 */
748
749 bool is_mark_ligature = _hb_glyph_info_is_mark (&buffer->cur());
750
751 unsigned int total_component_count = 0;
752 total_component_count += _hb_glyph_info_get_lig_num_comps (&buffer->cur());
753
754 unsigned int first_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
755 unsigned int first_lig_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
756
757 match_positions[0] = buffer->idx;
758 for (unsigned int i = 1; i < count; i++)
759 {
760 if (!skippy_iter.next ()) return TRACE_RETURN (false);
761
762 match_positions[i] = skippy_iter.idx;
763
764 unsigned int this_lig_id = _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx]);
765 unsigned int this_lig_comp = _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]);
766
767 if (first_lig_id && first_lig_comp) {
768 /* If first component was attached to a previous ligature component,
769 * all subsequent components should be attached to the same ligature
770 * component, otherwise we shouldn't ligate them. */
771 if (first_lig_id != this_lig_id || first_lig_comp != this_lig_comp)
772 return TRACE_RETURN (false);
773 } else {
774 /* If first component was NOT attached to a previous ligature component,
775 * all subsequent components should also NOT be attached to any ligature
776 * component, unless they are attached to the first component itself! */
777 if (this_lig_id && this_lig_comp && (this_lig_id != first_lig_id))
778 return TRACE_RETURN (false);
779 }
780
781 is_mark_ligature = is_mark_ligature && _hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx]);
782 total_component_count += _hb_glyph_info_get_lig_num_comps (&buffer->info[skippy_iter.idx]);
783 }
784
785 *end_offset = skippy_iter.idx - buffer->idx + 1;
786
787 if (p_is_mark_ligature)
788 *p_is_mark_ligature = is_mark_ligature;
789
790 if (p_total_component_count)
791 *p_total_component_count = total_component_count;
792
793 return TRACE_RETURN (true);
794 }
795 static inline void ligate_input (hb_apply_context_t *c,
796 unsigned int count, /* Including the first glyph */
797 unsigned int match_positions[MAX_CONTEXT_LENGTH], /* Including the first glyph */
798 unsigned int match_length,
799 hb_codepoint_t lig_glyph,
800 bool is_mark_ligature,
801 unsigned int total_component_count)
802 {
803 TRACE_APPLY (NULL);
804
805 hb_buffer_t *buffer = c->buffer;
806
807 buffer->merge_clusters (buffer->idx, buffer->idx + match_length);
808
809 /*
810 * - If it *is* a mark ligature, we don't allocate a new ligature id, and leave
811 * the ligature to keep its old ligature id. This will allow it to attach to
812 * a base ligature in GPOS. Eg. if the sequence is: LAM,LAM,SHADDA,FATHA,HEH,
813 * and LAM,LAM,HEH for a ligature, they will leave SHADDA and FATHA wit a
814 * ligature id and component value of 2. Then if SHADDA,FATHA form a ligature
815 * later, we don't want them to lose their ligature id/component, otherwise
816 * GPOS will fail to correctly position the mark ligature on top of the
817 * LAM,LAM,HEH ligature. See:
818 * https://bugzilla.gnome.org/show_bug.cgi?id=676343
819 *
820 * - If a ligature is formed of components that some of which are also ligatures
821 * themselves, and those ligature components had marks attached to *their*
822 * components, we have to attach the marks to the new ligature component
823 * positions! Now *that*'s tricky! And these marks may be following the
824 * last component of the whole sequence, so we should loop forward looking
825 * for them and update them.
826 *
827 * Eg. the sequence is LAM,LAM,SHADDA,FATHA,HEH, and the font first forms a
828 * 'calt' ligature of LAM,HEH, leaving the SHADDA and FATHA with a ligature
829 * id and component == 1. Now, during 'liga', the LAM and the LAM-HEH ligature
830 * form a LAM-LAM-HEH ligature. We need to reassign the SHADDA and FATHA to
831 * the new ligature with a component value of 2.
832 *
833 * This in fact happened to a font... See:
834 * https://bugzilla.gnome.org/show_bug.cgi?id=437633
835 */
836
837 unsigned int klass = is_mark_ligature ? 0 : HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE;
838 unsigned int lig_id = is_mark_ligature ? 0 : _hb_allocate_lig_id (buffer);
839 unsigned int last_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
840 unsigned int last_num_components = _hb_glyph_info_get_lig_num_comps (&buffer->cur());
841 unsigned int components_so_far = last_num_components;
842
843 if (!is_mark_ligature)
844 {
845 _hb_glyph_info_set_lig_props_for_ligature (&buffer->cur(), lig_id, total_component_count);
846 if (_hb_glyph_info_get_general_category (&buffer->cur()) == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)
847 {
848 _hb_glyph_info_set_general_category (&buffer->cur(), HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER);
849 _hb_glyph_info_set_modified_combining_class (&buffer->cur(), 0);
850 }
851 }
852 c->replace_glyph_with_ligature (lig_glyph, klass);
853
854 for (unsigned int i = 1; i < count; i++)
855 {
856 while (buffer->idx < match_positions[i])
857 {
858 if (!is_mark_ligature) {
859 unsigned int new_lig_comp = components_so_far - last_num_components +
860 MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->cur()), 1u), last_num_components);
861 _hb_glyph_info_set_lig_props_for_mark (&buffer->cur(), lig_id, new_lig_comp);
862 }
863 buffer->next_glyph ();
864 }
865
866 last_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
867 last_num_components = _hb_glyph_info_get_lig_num_comps (&buffer->cur());
868 components_so_far += last_num_components;
869
870 /* Skip the base glyph */
871 buffer->idx++;
872 }
873
874 if (!is_mark_ligature && last_lig_id) {
875 /* Re-adjust components for any marks following. */
876 for (unsigned int i = buffer->idx; i < buffer->len; i++) {
877 if (last_lig_id == _hb_glyph_info_get_lig_id (&buffer->info[i])) {
878 unsigned int new_lig_comp = components_so_far - last_num_components +
879 MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->info[i]), 1u), last_num_components);
880 _hb_glyph_info_set_lig_props_for_mark (&buffer->info[i], lig_id, new_lig_comp);
881 } else
882 break;
883 }
884 }
885 }
886
887 static inline bool match_backtrack (hb_apply_context_t *c,
888 unsigned int count,
889 const USHORT backtrack[],
890 match_func_t match_func,
891 const void *match_data)
892 {
893 TRACE_APPLY (NULL);
894
895 hb_apply_context_t::skipping_backward_iterator_t skippy_iter (c, c->buffer->backtrack_len (), count, true);
896 skippy_iter.set_match_func (match_func, match_data, backtrack);
897 if (skippy_iter.has_no_chance ()) return TRACE_RETURN (false);
898
899 for (unsigned int i = 0; i < count; i++)
900 if (!skippy_iter.prev ())
901 return TRACE_RETURN (false);
902
903 return TRACE_RETURN (true);
904 }
905
906 static inline bool match_lookahead (hb_apply_context_t *c,
907 unsigned int count,
908 const USHORT lookahead[],
909 match_func_t match_func,
910 const void *match_data,
911 unsigned int offset)
912 {
913 TRACE_APPLY (NULL);
914
915 hb_apply_context_t::skipping_forward_iterator_t skippy_iter (c, c->buffer->idx + offset - 1, count, true);
916 skippy_iter.set_match_func (match_func, match_data, lookahead);
917 if (skippy_iter.has_no_chance ()) return TRACE_RETURN (false);
918
919 for (unsigned int i = 0; i < count; i++)
920 if (!skippy_iter.next ())
921 return TRACE_RETURN (false);
922
923 return TRACE_RETURN (true);
924 }
925
926
927
928 struct LookupRecord
929 {
930 inline bool sanitize (hb_sanitize_context_t *c) {
931 TRACE_SANITIZE (this);
932 return TRACE_RETURN (c->check_struct (this));
933 }
934
935 USHORT sequenceIndex; /* Index into current glyph
936 * sequence--first glyph = 0 */
937 USHORT lookupListIndex; /* Lookup to apply to that
938 * position--zero--based */
939 public:
940 DEFINE_SIZE_STATIC (4);
941 };
942
943
944 template <typename context_t>
945 static inline void recurse_lookups (context_t *c,
946 unsigned int lookupCount,
947 const LookupRecord lookupRecord[] /* Array of LookupRecords--in design order */)
948 {
949 for (unsigned int i = 0; i < lookupCount; i++)
950 c->recurse (lookupRecord[i].lookupListIndex);
951 }
952
953 static inline bool apply_lookup (hb_apply_context_t *c,
954 unsigned int count, /* Including the first glyph */
955 unsigned int match_positions[MAX_CONTEXT_LENGTH], /* Including the first glyph */
956 unsigned int lookupCount,
957 const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
958 unsigned int match_length)
959 {
960 TRACE_APPLY (NULL);
961
962 hb_buffer_t *buffer = c->buffer;
963 unsigned int end;
964
965 /* All positions are distance from beginning of *output* buffer.
966 * Adjust. */
967 {
968 unsigned int bl = buffer->backtrack_len ();
969 end = bl + match_length;
970
971 int delta = bl - buffer->idx;
972 /* Convert positions to new indexing. */
973 for (unsigned int j = 0; j < count; j++)
974 match_positions[j] += delta;
975 }
976
977 for (unsigned int i = 0; i < lookupCount; i++)
978 {
979 unsigned int idx = lookupRecord[i].sequenceIndex;
980 if (idx >= count)
981 continue;
982
983 buffer->move_to (match_positions[idx]);
984
985 unsigned int orig_len = buffer->backtrack_len () + buffer->lookahead_len ();
986 if (!c->recurse (lookupRecord[i].lookupListIndex))
987 continue;
988
989 unsigned int new_len = buffer->backtrack_len () + buffer->lookahead_len ();
990 int delta = new_len - orig_len;
991
992 if (!delta)
993 continue;
994
995 /* Recursed lookup changed buffer len. Adjust. */
996
997 /* end can't go back past the current match position. */
998 end = MAX ((int) match_positions[idx] + 1, int (end) + delta);
999
1000 unsigned int next = idx + 1; /* next now is the position after the recursed lookup. */
1001
1002 if (delta > 0)
1003 {
1004 if (unlikely (delta + count > MAX_CONTEXT_LENGTH))
1005 break;
1006 }
1007 else
1008 {
1009 /* NOTE: delta is negative. */
1010 delta = MAX (delta, (int) next - (int) count);
1011 next -= delta;
1012 }
1013
1014 /* Shift! */
1015 memmove (match_positions + next + delta, match_positions + next,
1016 (count - next) * sizeof (match_positions[0]));
1017 next += delta;
1018 count += delta;
1019
1020 /* Fill in new entries. */
1021 for (unsigned int j = idx + 1; j < next; j++)
1022 match_positions[j] = match_positions[j - 1] + 1;
1023
1024 /* And fixup the rest. */
1025 for (; next < count; next++)
1026 match_positions[next] += delta;
1027 }
1028
1029 buffer->move_to (end);
1030
1031 return TRACE_RETURN (true);
1032 }
1033
1034
1035
1036 /* Contextual lookups */
1037
1038 struct ContextClosureLookupContext
1039 {
1040 ContextClosureFuncs funcs;
1041 const void *intersects_data;
1042 };
1043
1044 struct ContextCollectGlyphsLookupContext
1045 {
1046 ContextCollectGlyphsFuncs funcs;
1047 const void *collect_data;
1048 };
1049
1050 struct ContextApplyLookupContext
1051 {
1052 ContextApplyFuncs funcs;
1053 const void *match_data;
1054 };
1055
1056 static inline void context_closure_lookup (hb_closure_context_t *c,
1057 unsigned int inputCount, /* Including the first glyph (not matched) */
1058 const USHORT input[], /* Array of input values--start with second glyph */
1059 unsigned int lookupCount,
1060 const LookupRecord lookupRecord[],
1061 ContextClosureLookupContext &lookup_context)
1062 {
1063 if (intersects_array (c,
1064 inputCount ? inputCount - 1 : 0, input,
1065 lookup_context.funcs.intersects, lookup_context.intersects_data))
1066 recurse_lookups (c,
1067 lookupCount, lookupRecord);
1068 }
1069
1070 static inline void context_collect_glyphs_lookup (hb_collect_glyphs_context_t *c,
1071 unsigned int inputCount, /* Including the first glyph (not matched) */
1072 const USHORT input[], /* Array of input values--start with second glyph */
1073 unsigned int lookupCount,
1074 const LookupRecord lookupRecord[],
1075 ContextCollectGlyphsLookupContext &lookup_context)
1076 {
1077 collect_array (c, c->input,
1078 inputCount ? inputCount - 1 : 0, input,
1079 lookup_context.funcs.collect, lookup_context.collect_data);
1080 recurse_lookups (c,
1081 lookupCount, lookupRecord);
1082 }
1083
1084 static inline bool context_would_apply_lookup (hb_would_apply_context_t *c,
1085 unsigned int inputCount, /* Including the first glyph (not matched) */
1086 const USHORT input[], /* Array of input values--start with second glyph */
1087 unsigned int lookupCount HB_UNUSED,
1088 const LookupRecord lookupRecord[] HB_UNUSED,
1089 ContextApplyLookupContext &lookup_context)
1090 {
1091 return would_match_input (c,
1092 inputCount, input,
1093 lookup_context.funcs.match, lookup_context.match_data);
1094 }
1095 static inline bool context_apply_lookup (hb_apply_context_t *c,
1096 unsigned int inputCount, /* Including the first glyph (not matched) */
1097 const USHORT input[], /* Array of input values--start with second glyph */
1098 unsigned int lookupCount,
1099 const LookupRecord lookupRecord[],
1100 ContextApplyLookupContext &lookup_context)
1101 {
1102 unsigned int match_length = 0;
1103 unsigned int match_positions[MAX_CONTEXT_LENGTH];
1104 return match_input (c,
1105 inputCount, input,
1106 lookup_context.funcs.match, lookup_context.match_data,
1107 &match_length, match_positions)
1108 && apply_lookup (c,
1109 inputCount, match_positions,
1110 lookupCount, lookupRecord,
1111 match_length);
1112 }
1113
1114 struct Rule
1115 {
1116 inline void closure (hb_closure_context_t *c, ContextClosureLookupContext &lookup_context) const
1117 {
1118 TRACE_CLOSURE (this);
1119 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
1120 context_closure_lookup (c,
1121 inputCount, input,
1122 lookupCount, lookupRecord,
1123 lookup_context);
1124 }
1125
1126 inline void collect_glyphs (hb_collect_glyphs_context_t *c, ContextCollectGlyphsLookupContext &lookup_context) const
1127 {
1128 TRACE_COLLECT_GLYPHS (this);
1129 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
1130 context_collect_glyphs_lookup (c,
1131 inputCount, input,
1132 lookupCount, lookupRecord,
1133 lookup_context);
1134 }
1135
1136 inline bool would_apply (hb_would_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
1137 {
1138 TRACE_WOULD_APPLY (this);
1139 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
1140 return TRACE_RETURN (context_would_apply_lookup (c, inputCount, input, lookupCount, lookupRecord, lookup_context));
1141 }
1142
1143 inline bool apply (hb_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
1144 {
1145 TRACE_APPLY (this);
1146 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
1147 return TRACE_RETURN (context_apply_lookup (c, inputCount, input, lookupCount, lookupRecord, lookup_context));
1148 }
1149
1150 public:
1151 inline bool sanitize (hb_sanitize_context_t *c) {
1152 TRACE_SANITIZE (this);
1153 return inputCount.sanitize (c)
1154 && lookupCount.sanitize (c)
1155 && c->check_range (input,
1156 input[0].static_size * inputCount
1157 + lookupRecordX[0].static_size * lookupCount);
1158 }
1159
1160 protected:
1161 USHORT inputCount; /* Total number of glyphs in input
1162 * glyph sequence--includes the first
1163 * glyph */
1164 USHORT lookupCount; /* Number of LookupRecords */
1165 USHORT input[VAR]; /* Array of match inputs--start with
1166 * second glyph */
1167 LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in
1168 * design order */
1169 public:
1170 DEFINE_SIZE_ARRAY2 (4, input, lookupRecordX);
1171 };
1172
1173 struct RuleSet
1174 {
1175 inline void closure (hb_closure_context_t *c, ContextClosureLookupContext &lookup_context) const
1176 {
1177 TRACE_CLOSURE (this);
1178 unsigned int num_rules = rule.len;
1179 for (unsigned int i = 0; i < num_rules; i++)
1180 (this+rule[i]).closure (c, lookup_context);
1181 }
1182
1183 inline void collect_glyphs (hb_collect_glyphs_context_t *c, ContextCollectGlyphsLookupContext &lookup_context) const
1184 {
1185 TRACE_COLLECT_GLYPHS (this);
1186 unsigned int num_rules = rule.len;
1187 for (unsigned int i = 0; i < num_rules; i++)
1188 (this+rule[i]).collect_glyphs (c, lookup_context);
1189 }
1190
1191 inline bool would_apply (hb_would_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
1192 {
1193 TRACE_WOULD_APPLY (this);
1194 unsigned int num_rules = rule.len;
1195 for (unsigned int i = 0; i < num_rules; i++)
1196 {
1197 if ((this+rule[i]).would_apply (c, lookup_context))
1198 return TRACE_RETURN (true);
1199 }
1200 return TRACE_RETURN (false);
1201 }
1202
1203 inline bool apply (hb_apply_context_t *c, ContextApplyLookupContext &lookup_context) const
1204 {
1205 TRACE_APPLY (this);
1206 unsigned int num_rules = rule.len;
1207 for (unsigned int i = 0; i < num_rules; i++)
1208 {
1209 if ((this+rule[i]).apply (c, lookup_context))
1210 return TRACE_RETURN (true);
1211 }
1212 return TRACE_RETURN (false);
1213 }
1214
1215 inline bool sanitize (hb_sanitize_context_t *c) {
1216 TRACE_SANITIZE (this);
1217 return TRACE_RETURN (rule.sanitize (c, this));
1218 }
1219
1220 protected:
1221 OffsetArrayOf<Rule>
1222 rule; /* Array of Rule tables
1223 * ordered by preference */
1224 public:
1225 DEFINE_SIZE_ARRAY (2, rule);
1226 };
1227
1228
1229 struct ContextFormat1
1230 {
1231 inline void closure (hb_closure_context_t *c) const
1232 {
1233 TRACE_CLOSURE (this);
1234
1235 const Coverage &cov = (this+coverage);
1236
1237 struct ContextClosureLookupContext lookup_context = {
1238 {intersects_glyph},
1239 NULL
1240 };
1241
1242 unsigned int count = ruleSet.len;
1243 for (unsigned int i = 0; i < count; i++)
1244 if (cov.intersects_coverage (c->glyphs, i)) {
1245 const RuleSet &rule_set = this+ruleSet[i];
1246 rule_set.closure (c, lookup_context);
1247 }
1248 }
1249
1250 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1251 {
1252 TRACE_COLLECT_GLYPHS (this);
1253 (this+coverage).add_coverage (c->input);
1254
1255 struct ContextCollectGlyphsLookupContext lookup_context = {
1256 {collect_glyph},
1257 NULL
1258 };
1259
1260 unsigned int count = ruleSet.len;
1261 for (unsigned int i = 0; i < count; i++)
1262 (this+ruleSet[i]).collect_glyphs (c, lookup_context);
1263 }
1264
1265 inline bool would_apply (hb_would_apply_context_t *c) const
1266 {
1267 TRACE_WOULD_APPLY (this);
1268
1269 const RuleSet &rule_set = this+ruleSet[(this+coverage).get_coverage (c->glyphs[0])];
1270 struct ContextApplyLookupContext lookup_context = {
1271 {match_glyph},
1272 NULL
1273 };
1274 return TRACE_RETURN (rule_set.would_apply (c, lookup_context));
1275 }
1276
1277 inline const Coverage &get_coverage (void) const
1278 {
1279 return this+coverage;
1280 }
1281
1282 inline bool apply (hb_apply_context_t *c) const
1283 {
1284 TRACE_APPLY (this);
1285 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
1286 if (likely (index == NOT_COVERED))
1287 return TRACE_RETURN (false);
1288
1289 const RuleSet &rule_set = this+ruleSet[index];
1290 struct ContextApplyLookupContext lookup_context = {
1291 {match_glyph},
1292 NULL
1293 };
1294 return TRACE_RETURN (rule_set.apply (c, lookup_context));
1295 }
1296
1297 inline bool sanitize (hb_sanitize_context_t *c) {
1298 TRACE_SANITIZE (this);
1299 return TRACE_RETURN (coverage.sanitize (c, this) && ruleSet.sanitize (c, this));
1300 }
1301
1302 protected:
1303 USHORT format; /* Format identifier--format = 1 */
1304 OffsetTo<Coverage>
1305 coverage; /* Offset to Coverage table--from
1306 * beginning of table */
1307 OffsetArrayOf<RuleSet>
1308 ruleSet; /* Array of RuleSet tables
1309 * ordered by Coverage Index */
1310 public:
1311 DEFINE_SIZE_ARRAY (6, ruleSet);
1312 };
1313
1314
1315 struct ContextFormat2
1316 {
1317 inline void closure (hb_closure_context_t *c) const
1318 {
1319 TRACE_CLOSURE (this);
1320 if (!(this+coverage).intersects (c->glyphs))
1321 return;
1322
1323 const ClassDef &class_def = this+classDef;
1324
1325 struct ContextClosureLookupContext lookup_context = {
1326 {intersects_class},
1327 &class_def
1328 };
1329
1330 unsigned int count = ruleSet.len;
1331 for (unsigned int i = 0; i < count; i++)
1332 if (class_def.intersects_class (c->glyphs, i)) {
1333 const RuleSet &rule_set = this+ruleSet[i];
1334 rule_set.closure (c, lookup_context);
1335 }
1336 }
1337
1338 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1339 {
1340 TRACE_COLLECT_GLYPHS (this);
1341 (this+coverage).add_coverage (c->input);
1342
1343 const ClassDef &class_def = this+classDef;
1344 struct ContextCollectGlyphsLookupContext lookup_context = {
1345 {collect_class},
1346 &class_def
1347 };
1348
1349 unsigned int count = ruleSet.len;
1350 for (unsigned int i = 0; i < count; i++)
1351 (this+ruleSet[i]).collect_glyphs (c, lookup_context);
1352 }
1353
1354 inline bool would_apply (hb_would_apply_context_t *c) const
1355 {
1356 TRACE_WOULD_APPLY (this);
1357
1358 const ClassDef &class_def = this+classDef;
1359 unsigned int index = class_def.get_class (c->glyphs[0]);
1360 const RuleSet &rule_set = this+ruleSet[index];
1361 struct ContextApplyLookupContext lookup_context = {
1362 {match_class},
1363 &class_def
1364 };
1365 return TRACE_RETURN (rule_set.would_apply (c, lookup_context));
1366 }
1367
1368 inline const Coverage &get_coverage (void) const
1369 {
1370 return this+coverage;
1371 }
1372
1373 inline bool apply (hb_apply_context_t *c) const
1374 {
1375 TRACE_APPLY (this);
1376 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
1377 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
1378
1379 const ClassDef &class_def = this+classDef;
1380 index = class_def.get_class (c->buffer->cur().codepoint);
1381 const RuleSet &rule_set = this+ruleSet[index];
1382 struct ContextApplyLookupContext lookup_context = {
1383 {match_class},
1384 &class_def
1385 };
1386 return TRACE_RETURN (rule_set.apply (c, lookup_context));
1387 }
1388
1389 inline bool sanitize (hb_sanitize_context_t *c) {
1390 TRACE_SANITIZE (this);
1391 return TRACE_RETURN (coverage.sanitize (c, this) && classDef.sanitize (c, this) && ruleSet.sanitize (c, this));
1392 }
1393
1394 protected:
1395 USHORT format; /* Format identifier--format = 2 */
1396 OffsetTo<Coverage>
1397 coverage; /* Offset to Coverage table--from
1398 * beginning of table */
1399 OffsetTo<ClassDef>
1400 classDef; /* Offset to glyph ClassDef table--from
1401 * beginning of table */
1402 OffsetArrayOf<RuleSet>
1403 ruleSet; /* Array of RuleSet tables
1404 * ordered by class */
1405 public:
1406 DEFINE_SIZE_ARRAY (8, ruleSet);
1407 };
1408
1409
1410 struct ContextFormat3
1411 {
1412 inline void closure (hb_closure_context_t *c) const
1413 {
1414 TRACE_CLOSURE (this);
1415 if (!(this+coverage[0]).intersects (c->glyphs))
1416 return;
1417
1418 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
1419 struct ContextClosureLookupContext lookup_context = {
1420 {intersects_coverage},
1421 this
1422 };
1423 context_closure_lookup (c,
1424 glyphCount, (const USHORT *) (coverage + 1),
1425 lookupCount, lookupRecord,
1426 lookup_context);
1427 }
1428
1429 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1430 {
1431 TRACE_COLLECT_GLYPHS (this);
1432 (this+coverage[0]).add_coverage (c->input);
1433
1434 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
1435 struct ContextCollectGlyphsLookupContext lookup_context = {
1436 {collect_coverage},
1437 this
1438 };
1439
1440 context_collect_glyphs_lookup (c,
1441 glyphCount, (const USHORT *) (coverage + 1),
1442 lookupCount, lookupRecord,
1443 lookup_context);
1444 }
1445
1446 inline bool would_apply (hb_would_apply_context_t *c) const
1447 {
1448 TRACE_WOULD_APPLY (this);
1449
1450 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
1451 struct ContextApplyLookupContext lookup_context = {
1452 {match_coverage},
1453 this
1454 };
1455 return TRACE_RETURN (context_would_apply_lookup (c, glyphCount, (const USHORT *) (coverage + 1), lookupCount, lookupRecord, lookup_context));
1456 }
1457
1458 inline const Coverage &get_coverage (void) const
1459 {
1460 return this+coverage[0];
1461 }
1462
1463 inline bool apply (hb_apply_context_t *c) const
1464 {
1465 TRACE_APPLY (this);
1466 unsigned int index = (this+coverage[0]).get_coverage (c->buffer->cur().codepoint);
1467 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
1468
1469 const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
1470 struct ContextApplyLookupContext lookup_context = {
1471 {match_coverage},
1472 this
1473 };
1474 return TRACE_RETURN (context_apply_lookup (c, glyphCount, (const USHORT *) (coverage + 1), lookupCount, lookupRecord, lookup_context));
1475 }
1476
1477 inline bool sanitize (hb_sanitize_context_t *c) {
1478 TRACE_SANITIZE (this);
1479 if (!c->check_struct (this)) return TRACE_RETURN (false);
1480 unsigned int count = glyphCount;
1481 if (!c->check_array (coverage, coverage[0].static_size, count)) return TRACE_RETURN (false);
1482 for (unsigned int i = 0; i < count; i++)
1483 if (!coverage[i].sanitize (c, this)) return TRACE_RETURN (false);
1484 LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * count);
1485 return TRACE_RETURN (c->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount));
1486 }
1487
1488 protected:
1489 USHORT format; /* Format identifier--format = 3 */
1490 USHORT glyphCount; /* Number of glyphs in the input glyph
1491 * sequence */
1492 USHORT lookupCount; /* Number of LookupRecords */
1493 OffsetTo<Coverage>
1494 coverage[VAR]; /* Array of offsets to Coverage
1495 * table in glyph sequence order */
1496 LookupRecord lookupRecordX[VAR]; /* Array of LookupRecords--in
1497 * design order */
1498 public:
1499 DEFINE_SIZE_ARRAY2 (6, coverage, lookupRecordX);
1500 };
1501
1502 struct Context
1503 {
1504 template <typename context_t>
1505 inline typename context_t::return_t dispatch (context_t *c) const
1506 {
1507 TRACE_DISPATCH (this);
1508 switch (u.format) {
1509 case 1: return TRACE_RETURN (c->dispatch (u.format1));
1510 case 2: return TRACE_RETURN (c->dispatch (u.format2));
1511 case 3: return TRACE_RETURN (c->dispatch (u.format3));
1512 default:return TRACE_RETURN (c->default_return_value ());
1513 }
1514 }
1515
1516 inline bool sanitize (hb_sanitize_context_t *c) {
1517 TRACE_SANITIZE (this);
1518 if (!u.format.sanitize (c)) return TRACE_RETURN (false);
1519 switch (u.format) {
1520 case 1: return TRACE_RETURN (u.format1.sanitize (c));
1521 case 2: return TRACE_RETURN (u.format2.sanitize (c));
1522 case 3: return TRACE_RETURN (u.format3.sanitize (c));
1523 default:return TRACE_RETURN (true);
1524 }
1525 }
1526
1527 protected:
1528 union {
1529 USHORT format; /* Format identifier */
1530 ContextFormat1 format1;
1531 ContextFormat2 format2;
1532 ContextFormat3 format3;
1533 } u;
1534 };
1535
1536
1537 /* Chaining Contextual lookups */
1538
1539 struct ChainContextClosureLookupContext
1540 {
1541 ContextClosureFuncs funcs;
1542 const void *intersects_data[3];
1543 };
1544
1545 struct ChainContextCollectGlyphsLookupContext
1546 {
1547 ContextCollectGlyphsFuncs funcs;
1548 const void *collect_data[3];
1549 };
1550
1551 struct ChainContextApplyLookupContext
1552 {
1553 ContextApplyFuncs funcs;
1554 const void *match_data[3];
1555 };
1556
1557 static inline void chain_context_closure_lookup (hb_closure_context_t *c,
1558 unsigned int backtrackCount,
1559 const USHORT backtrack[],
1560 unsigned int inputCount, /* Including the first glyph (not matched) */
1561 const USHORT input[], /* Array of input values--start with second glyph */
1562 unsigned int lookaheadCount,
1563 const USHORT lookahead[],
1564 unsigned int lookupCount,
1565 const LookupRecord lookupRecord[],
1566 ChainContextClosureLookupContext &lookup_context)
1567 {
1568 if (intersects_array (c,
1569 backtrackCount, backtrack,
1570 lookup_context.funcs.intersects, lookup_context.intersects_data[0])
1571 && intersects_array (c,
1572 inputCount ? inputCount - 1 : 0, input,
1573 lookup_context.funcs.intersects, lookup_context.intersects_data[1])
1574 && intersects_array (c,
1575 lookaheadCount, lookahead,
1576 lookup_context.funcs.intersects, lookup_context.intersects_data[2]))
1577 recurse_lookups (c,
1578 lookupCount, lookupRecord);
1579 }
1580
1581 static inline void chain_context_collect_glyphs_lookup (hb_collect_glyphs_context_t *c,
1582 unsigned int backtrackCount,
1583 const USHORT backtrack[],
1584 unsigned int inputCount, /* Including the first glyph (not matched) */
1585 const USHORT input[], /* Array of input values--start with second glyph */
1586 unsigned int lookaheadCount,
1587 const USHORT lookahead[],
1588 unsigned int lookupCount,
1589 const LookupRecord lookupRecord[],
1590 ChainContextCollectGlyphsLookupContext &lookup_context)
1591 {
1592 collect_array (c, c->before,
1593 backtrackCount, backtrack,
1594 lookup_context.funcs.collect, lookup_context.collect_data[0]);
1595 collect_array (c, c->input,
1596 inputCount ? inputCount - 1 : 0, input,
1597 lookup_context.funcs.collect, lookup_context.collect_data[1]);
1598 collect_array (c, c->after,
1599 lookaheadCount, lookahead,
1600 lookup_context.funcs.collect, lookup_context.collect_data[2]);
1601 recurse_lookups (c,
1602 lookupCount, lookupRecord);
1603 }
1604
1605 static inline bool chain_context_would_apply_lookup (hb_would_apply_context_t *c,
1606 unsigned int backtrackCount,
1607 const USHORT backtrack[] HB_UNUSED,
1608 unsigned int inputCount, /* Including the first glyph (not matched) */
1609 const USHORT input[], /* Array of input values--start with second glyph */
1610 unsigned int lookaheadCount,
1611 const USHORT lookahead[] HB_UNUSED,
1612 unsigned int lookupCount HB_UNUSED,
1613 const LookupRecord lookupRecord[] HB_UNUSED,
1614 ChainContextApplyLookupContext &lookup_context)
1615 {
1616 return (c->zero_context ? !backtrackCount && !lookaheadCount : true)
1617 && would_match_input (c,
1618 inputCount, input,
1619 lookup_context.funcs.match, lookup_context.match_data[1]);
1620 }
1621
1622 static inline bool chain_context_apply_lookup (hb_apply_context_t *c,
1623 unsigned int backtrackCount,
1624 const USHORT backtrack[],
1625 unsigned int inputCount, /* Including the first glyph (not matched) */
1626 const USHORT input[], /* Array of input values--start with second glyph */
1627 unsigned int lookaheadCount,
1628 const USHORT lookahead[],
1629 unsigned int lookupCount,
1630 const LookupRecord lookupRecord[],
1631 ChainContextApplyLookupContext &lookup_context)
1632 {
1633 unsigned int match_length = 0;
1634 unsigned int match_positions[MAX_CONTEXT_LENGTH];
1635 return match_input (c,
1636 inputCount, input,
1637 lookup_context.funcs.match, lookup_context.match_data[1],
1638 &match_length, match_positions)
1639 && match_backtrack (c,
1640 backtrackCount, backtrack,
1641 lookup_context.funcs.match, lookup_context.match_data[0])
1642 && match_lookahead (c,
1643 lookaheadCount, lookahead,
1644 lookup_context.funcs.match, lookup_context.match_data[2],
1645 match_length)
1646 && apply_lookup (c,
1647 inputCount, match_positions,
1648 lookupCount, lookupRecord,
1649 match_length);
1650 }
1651
1652 struct ChainRule
1653 {
1654 inline void closure (hb_closure_context_t *c, ChainContextClosureLookupContext &lookup_context) const
1655 {
1656 TRACE_CLOSURE (this);
1657 const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
1658 const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
1659 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
1660 chain_context_closure_lookup (c,
1661 backtrack.len, backtrack.array,
1662 input.len, input.array,
1663 lookahead.len, lookahead.array,
1664 lookup.len, lookup.array,
1665 lookup_context);
1666 }
1667
1668 inline void collect_glyphs (hb_collect_glyphs_context_t *c, ChainContextCollectGlyphsLookupContext &lookup_context) const
1669 {
1670 TRACE_COLLECT_GLYPHS (this);
1671 const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
1672 const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
1673 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
1674 chain_context_collect_glyphs_lookup (c,
1675 backtrack.len, backtrack.array,
1676 input.len, input.array,
1677 lookahead.len, lookahead.array,
1678 lookup.len, lookup.array,
1679 lookup_context);
1680 }
1681
1682 inline bool would_apply (hb_would_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
1683 {
1684 TRACE_WOULD_APPLY (this);
1685 const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
1686 const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
1687 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
1688 return TRACE_RETURN (chain_context_would_apply_lookup (c,
1689 backtrack.len, backtrack.array,
1690 input.len, input.array,
1691 lookahead.len, lookahead.array, lookup.len,
1692 lookup.array, lookup_context));
1693 }
1694
1695 inline bool apply (hb_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
1696 {
1697 TRACE_APPLY (this);
1698 const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
1699 const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
1700 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
1701 return TRACE_RETURN (chain_context_apply_lookup (c,
1702 backtrack.len, backtrack.array,
1703 input.len, input.array,
1704 lookahead.len, lookahead.array, lookup.len,
1705 lookup.array, lookup_context));
1706 }
1707
1708 inline bool sanitize (hb_sanitize_context_t *c) {
1709 TRACE_SANITIZE (this);
1710 if (!backtrack.sanitize (c)) return TRACE_RETURN (false);
1711 HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
1712 if (!input.sanitize (c)) return TRACE_RETURN (false);
1713 ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
1714 if (!lookahead.sanitize (c)) return TRACE_RETURN (false);
1715 ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
1716 return TRACE_RETURN (lookup.sanitize (c));
1717 }
1718
1719 protected:
1720 ArrayOf<USHORT>
1721 backtrack; /* Array of backtracking values
1722 * (to be matched before the input
1723 * sequence) */
1724 HeadlessArrayOf<USHORT>
1725 inputX; /* Array of input values (start with
1726 * second glyph) */
1727 ArrayOf<USHORT>
1728 lookaheadX; /* Array of lookahead values's (to be
1729 * matched after the input sequence) */
1730 ArrayOf<LookupRecord>
1731 lookupX; /* Array of LookupRecords--in
1732 * design order) */
1733 public:
1734 DEFINE_SIZE_MIN (8);
1735 };
1736
1737 struct ChainRuleSet
1738 {
1739 inline void closure (hb_closure_context_t *c, ChainContextClosureLookupContext &lookup_context) const
1740 {
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);
1745 }
1746
1747 inline void collect_glyphs (hb_collect_glyphs_context_t *c, ChainContextCollectGlyphsLookupContext &lookup_context) const
1748 {
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);
1753 }
1754
1755 inline bool would_apply (hb_would_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
1756 {
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);
1762
1763 return TRACE_RETURN (false);
1764 }
1765
1766 inline bool apply (hb_apply_context_t *c, ChainContextApplyLookupContext &lookup_context) const
1767 {
1768 TRACE_APPLY (this);
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);
1773
1774 return TRACE_RETURN (false);
1775 }
1776
1777 inline bool sanitize (hb_sanitize_context_t *c) {
1778 TRACE_SANITIZE (this);
1779 return TRACE_RETURN (rule.sanitize (c, this));
1780 }
1781
1782 protected:
1783 OffsetArrayOf<ChainRule>
1784 rule; /* Array of ChainRule tables
1785 * ordered by preference */
1786 public:
1787 DEFINE_SIZE_ARRAY (2, rule);
1788 };
1789
1790 struct ChainContextFormat1
1791 {
1792 inline void closure (hb_closure_context_t *c) const
1793 {
1794 TRACE_CLOSURE (this);
1795 const Coverage &cov = (this+coverage);
1796
1797 struct ChainContextClosureLookupContext lookup_context = {
1798 {intersects_glyph},
1799 {NULL, NULL, NULL}
1800 };
1801
1802 unsigned int count = ruleSet.len;
1803 for (unsigned int i = 0; i < count; i++)
1804 if (cov.intersects_coverage (c->glyphs, i)) {
1805 const ChainRuleSet &rule_set = this+ruleSet[i];
1806 rule_set.closure (c, lookup_context);
1807 }
1808 }
1809
1810 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1811 {
1812 TRACE_COLLECT_GLYPHS (this);
1813 (this+coverage).add_coverage (c->input);
1814
1815 struct ChainContextCollectGlyphsLookupContext lookup_context = {
1816 {collect_glyph},
1817 {NULL, NULL, NULL}
1818 };
1819
1820 unsigned int count = ruleSet.len;
1821 for (unsigned int i = 0; i < count; i++)
1822 (this+ruleSet[i]).collect_glyphs (c, lookup_context);
1823 }
1824
1825 inline bool would_apply (hb_would_apply_context_t *c) const
1826 {
1827 TRACE_WOULD_APPLY (this);
1828
1829 const ChainRuleSet &rule_set = this+ruleSet[(this+coverage).get_coverage (c->glyphs[0])];
1830 struct ChainContextApplyLookupContext lookup_context = {
1831 {match_glyph},
1832 {NULL, NULL, NULL}
1833 };
1834 return TRACE_RETURN (rule_set.would_apply (c, lookup_context));
1835 }
1836
1837 inline const Coverage &get_coverage (void) const
1838 {
1839 return this+coverage;
1840 }
1841
1842 inline bool apply (hb_apply_context_t *c) const
1843 {
1844 TRACE_APPLY (this);
1845 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
1846 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
1847
1848 const ChainRuleSet &rule_set = this+ruleSet[index];
1849 struct ChainContextApplyLookupContext lookup_context = {
1850 {match_glyph},
1851 {NULL, NULL, NULL}
1852 };
1853 return TRACE_RETURN (rule_set.apply (c, lookup_context));
1854 }
1855
1856 inline bool sanitize (hb_sanitize_context_t *c) {
1857 TRACE_SANITIZE (this);
1858 return TRACE_RETURN (coverage.sanitize (c, this) && ruleSet.sanitize (c, this));
1859 }
1860
1861 protected:
1862 USHORT format; /* Format identifier--format = 1 */
1863 OffsetTo<Coverage>
1864 coverage; /* Offset to Coverage table--from
1865 * beginning of table */
1866 OffsetArrayOf<ChainRuleSet>
1867 ruleSet; /* Array of ChainRuleSet tables
1868 * ordered by Coverage Index */
1869 public:
1870 DEFINE_SIZE_ARRAY (6, ruleSet);
1871 };
1872
1873 struct ChainContextFormat2
1874 {
1875 inline void closure (hb_closure_context_t *c) const
1876 {
1877 TRACE_CLOSURE (this);
1878 if (!(this+coverage).intersects (c->glyphs))
1879 return;
1880
1881 const ClassDef &backtrack_class_def = this+backtrackClassDef;
1882 const ClassDef &input_class_def = this+inputClassDef;
1883 const ClassDef &lookahead_class_def = this+lookaheadClassDef;
1884
1885 struct ChainContextClosureLookupContext lookup_context = {
1886 {intersects_class},
1887 {&backtrack_class_def,
1888 &input_class_def,
1889 &lookahead_class_def}
1890 };
1891
1892 unsigned int count = ruleSet.len;
1893 for (unsigned int i = 0; i < count; i++)
1894 if (input_class_def.intersects_class (c->glyphs, i)) {
1895 const ChainRuleSet &rule_set = this+ruleSet[i];
1896 rule_set.closure (c, lookup_context);
1897 }
1898 }
1899
1900 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1901 {
1902 TRACE_COLLECT_GLYPHS (this);
1903 (this+coverage).add_coverage (c->input);
1904
1905 const ClassDef &backtrack_class_def = this+backtrackClassDef;
1906 const ClassDef &input_class_def = this+inputClassDef;
1907 const ClassDef &lookahead_class_def = this+lookaheadClassDef;
1908
1909 struct ChainContextCollectGlyphsLookupContext lookup_context = {
1910 {collect_class},
1911 {&backtrack_class_def,
1912 &input_class_def,
1913 &lookahead_class_def}
1914 };
1915
1916 unsigned int count = ruleSet.len;
1917 for (unsigned int i = 0; i < count; i++)
1918 (this+ruleSet[i]).collect_glyphs (c, lookup_context);
1919 }
1920
1921 inline bool would_apply (hb_would_apply_context_t *c) const
1922 {
1923 TRACE_WOULD_APPLY (this);
1924
1925 const ClassDef &backtrack_class_def = this+backtrackClassDef;
1926 const ClassDef &input_class_def = this+inputClassDef;
1927 const ClassDef &lookahead_class_def = this+lookaheadClassDef;
1928
1929 unsigned int index = input_class_def.get_class (c->glyphs[0]);
1930 const ChainRuleSet &rule_set = this+ruleSet[index];
1931 struct ChainContextApplyLookupContext lookup_context = {
1932 {match_class},
1933 {&backtrack_class_def,
1934 &input_class_def,
1935 &lookahead_class_def}
1936 };
1937 return TRACE_RETURN (rule_set.would_apply (c, lookup_context));
1938 }
1939
1940 inline const Coverage &get_coverage (void) const
1941 {
1942 return this+coverage;
1943 }
1944
1945 inline bool apply (hb_apply_context_t *c) const
1946 {
1947 TRACE_APPLY (this);
1948 unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
1949 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
1950
1951 const ClassDef &backtrack_class_def = this+backtrackClassDef;
1952 const ClassDef &input_class_def = this+inputClassDef;
1953 const ClassDef &lookahead_class_def = this+lookaheadClassDef;
1954
1955 index = input_class_def.get_class (c->buffer->cur().codepoint);
1956 const ChainRuleSet &rule_set = this+ruleSet[index];
1957 struct ChainContextApplyLookupContext lookup_context = {
1958 {match_class},
1959 {&backtrack_class_def,
1960 &input_class_def,
1961 &lookahead_class_def}
1962 };
1963 return TRACE_RETURN (rule_set.apply (c, lookup_context));
1964 }
1965
1966 inline bool sanitize (hb_sanitize_context_t *c) {
1967 TRACE_SANITIZE (this);
1968 return TRACE_RETURN (coverage.sanitize (c, this) && backtrackClassDef.sanitize (c, this) &&
1969 inputClassDef.sanitize (c, this) && lookaheadClassDef.sanitize (c, this) &&
1970 ruleSet.sanitize (c, this));
1971 }
1972
1973 protected:
1974 USHORT format; /* Format identifier--format = 2 */
1975 OffsetTo<Coverage>
1976 coverage; /* Offset to Coverage table--from
1977 * beginning of table */
1978 OffsetTo<ClassDef>
1979 backtrackClassDef; /* Offset to glyph ClassDef table
1980 * containing backtrack sequence
1981 * data--from beginning of table */
1982 OffsetTo<ClassDef>
1983 inputClassDef; /* Offset to glyph ClassDef
1984 * table containing input sequence
1985 * data--from beginning of table */
1986 OffsetTo<ClassDef>
1987 lookaheadClassDef; /* Offset to glyph ClassDef table
1988 * containing lookahead sequence
1989 * data--from beginning of table */
1990 OffsetArrayOf<ChainRuleSet>
1991 ruleSet; /* Array of ChainRuleSet tables
1992 * ordered by class */
1993 public:
1994 DEFINE_SIZE_ARRAY (12, ruleSet);
1995 };
1996
1997 struct ChainContextFormat3
1998 {
1999 inline void closure (hb_closure_context_t *c) const
2000 {
2001 TRACE_CLOSURE (this);
2002 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
2003
2004 if (!(this+input[0]).intersects (c->glyphs))
2005 return;
2006
2007 const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
2008 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
2009 struct ChainContextClosureLookupContext lookup_context = {
2010 {intersects_coverage},
2011 {this, this, this}
2012 };
2013 chain_context_closure_lookup (c,
2014 backtrack.len, (const USHORT *) backtrack.array,
2015 input.len, (const USHORT *) input.array + 1,
2016 lookahead.len, (const USHORT *) lookahead.array,
2017 lookup.len, lookup.array,
2018 lookup_context);
2019 }
2020
2021 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
2022 {
2023 TRACE_COLLECT_GLYPHS (this);
2024 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
2025
2026 (this+input[0]).add_coverage (c->input);
2027
2028 const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
2029 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
2030 struct ChainContextCollectGlyphsLookupContext lookup_context = {
2031 {collect_coverage},
2032 {this, this, this}
2033 };
2034 chain_context_collect_glyphs_lookup (c,
2035 backtrack.len, (const USHORT *) backtrack.array,
2036 input.len, (const USHORT *) input.array + 1,
2037 lookahead.len, (const USHORT *) lookahead.array,
2038 lookup.len, lookup.array,
2039 lookup_context);
2040 }
2041
2042 inline bool would_apply (hb_would_apply_context_t *c) const
2043 {
2044 TRACE_WOULD_APPLY (this);
2045
2046 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
2047 const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
2048 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
2049 struct ChainContextApplyLookupContext lookup_context = {
2050 {match_coverage},
2051 {this, this, this}
2052 };
2053 return TRACE_RETURN (chain_context_would_apply_lookup (c,
2054 backtrack.len, (const USHORT *) backtrack.array,
2055 input.len, (const USHORT *) input.array + 1,
2056 lookahead.len, (const USHORT *) lookahead.array,
2057 lookup.len, lookup.array, lookup_context));
2058 }
2059
2060 inline const Coverage &get_coverage (void) const
2061 {
2062 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
2063 return this+input[0];
2064 }
2065
2066 inline bool apply (hb_apply_context_t *c) const
2067 {
2068 TRACE_APPLY (this);
2069 const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
2070
2071 unsigned int index = (this+input[0]).get_coverage (c->buffer->cur().codepoint);
2072 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
2073
2074 const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
2075 const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
2076 struct ChainContextApplyLookupContext lookup_context = {
2077 {match_coverage},
2078 {this, this, this}
2079 };
2080 return TRACE_RETURN (chain_context_apply_lookup (c,
2081 backtrack.len, (const USHORT *) backtrack.array,
2082 input.len, (const USHORT *) input.array + 1,
2083 lookahead.len, (const USHORT *) lookahead.array,
2084 lookup.len, lookup.array, lookup_context));
2085 }
2086
2087 inline bool sanitize (hb_sanitize_context_t *c) {
2088 TRACE_SANITIZE (this);
2089 if (!backtrack.sanitize (c, this)) return TRACE_RETURN (false);
2090 OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
2091 if (!input.sanitize (c, this)) return TRACE_RETURN (false);
2092 OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
2093 if (!lookahead.sanitize (c, this)) return TRACE_RETURN (false);
2094 ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
2095 return TRACE_RETURN (lookup.sanitize (c));
2096 }
2097
2098 protected:
2099 USHORT format; /* Format identifier--format = 3 */
2100 OffsetArrayOf<Coverage>
2101 backtrack; /* Array of coverage tables
2102 * in backtracking sequence, in glyph
2103 * sequence order */
2104 OffsetArrayOf<Coverage>
2105 inputX ; /* Array of coverage
2106 * tables in input sequence, in glyph
2107 * sequence order */
2108 OffsetArrayOf<Coverage>
2109 lookaheadX; /* Array of coverage tables
2110 * in lookahead sequence, in glyph
2111 * sequence order */
2112 ArrayOf<LookupRecord>
2113 lookupX; /* Array of LookupRecords--in
2114 * design order) */
2115 public:
2116 DEFINE_SIZE_MIN (10);
2117 };
2118
2119 struct ChainContext
2120 {
2121 template <typename context_t>
2122 inline typename context_t::return_t dispatch (context_t *c) const
2123 {
2124 TRACE_DISPATCH (this);
2125 switch (u.format) {
2126 case 1: return TRACE_RETURN (c->dispatch (u.format1));
2127 case 2: return TRACE_RETURN (c->dispatch (u.format2));
2128 case 3: return TRACE_RETURN (c->dispatch (u.format3));
2129 default:return TRACE_RETURN (c->default_return_value ());
2130 }
2131 }
2132
2133 inline bool sanitize (hb_sanitize_context_t *c) {
2134 TRACE_SANITIZE (this);
2135 if (!u.format.sanitize (c)) return TRACE_RETURN (false);
2136 switch (u.format) {
2137 case 1: return TRACE_RETURN (u.format1.sanitize (c));
2138 case 2: return TRACE_RETURN (u.format2.sanitize (c));
2139 case 3: return TRACE_RETURN (u.format3.sanitize (c));
2140 default:return TRACE_RETURN (true);
2141 }
2142 }
2143
2144 protected:
2145 union {
2146 USHORT format; /* Format identifier */
2147 ChainContextFormat1 format1;
2148 ChainContextFormat2 format2;
2149 ChainContextFormat3 format3;
2150 } u;
2151 };
2152
2153
2154 struct ExtensionFormat1
2155 {
2156 inline unsigned int get_type (void) const { return extensionLookupType; }
2157 inline unsigned int get_offset (void) const { return extensionOffset; }
2158
2159 inline bool sanitize (hb_sanitize_context_t *c) {
2160 TRACE_SANITIZE (this);
2161 return TRACE_RETURN (c->check_struct (this));
2162 }
2163
2164 protected:
2165 USHORT format; /* Format identifier. Set to 1. */
2166 USHORT extensionLookupType; /* Lookup type of subtable referenced
2167 * by ExtensionOffset (i.e. the
2168 * extension subtable). */
2169 ULONG extensionOffset; /* Offset to the extension subtable,
2170 * of lookup type subtable. */
2171 public:
2172 DEFINE_SIZE_STATIC (8);
2173 };
2174
2175 template <typename T>
2176 struct Extension
2177 {
2178 inline unsigned int get_type (void) const
2179 {
2180 switch (u.format) {
2181 case 1: return u.format1.get_type ();
2182 default:return 0;
2183 }
2184 }
2185 inline unsigned int get_offset (void) const
2186 {
2187 switch (u.format) {
2188 case 1: return u.format1.get_offset ();
2189 default:return 0;
2190 }
2191 }
2192
2193 template <typename X>
2194 inline const X& get_subtable (void) const
2195 {
2196 unsigned int offset = get_offset ();
2197 if (unlikely (!offset)) return Null(typename T::LookupSubTable);
2198 return StructAtOffset<typename T::LookupSubTable> (this, offset);
2199 }
2200
2201 template <typename context_t>
2202 inline typename context_t::return_t dispatch (context_t *c) const
2203 {
2204 return get_subtable<typename T::LookupSubTable> ().dispatch (c, get_type ());
2205 }
2206
2207 inline bool sanitize_self (hb_sanitize_context_t *c) {
2208 TRACE_SANITIZE (this);
2209 if (!u.format.sanitize (c)) return TRACE_RETURN (false);
2210 switch (u.format) {
2211 case 1: return TRACE_RETURN (u.format1.sanitize (c));
2212 default:return TRACE_RETURN (true);
2213 }
2214 }
2215
2216 inline bool sanitize (hb_sanitize_context_t *c) {
2217 TRACE_SANITIZE (this);
2218 if (!sanitize_self (c)) return TRACE_RETURN (false);
2219 unsigned int offset = get_offset ();
2220 if (unlikely (!offset)) return TRACE_RETURN (true);
2221 return TRACE_RETURN (StructAtOffset<typename T::LookupSubTable> (this, offset).sanitize (c, get_type ()));
2222 }
2223
2224 protected:
2225 union {
2226 USHORT format; /* Format identifier */
2227 ExtensionFormat1 format1;
2228 } u;
2229 };
2230
2231
2232 /*
2233 * GSUB/GPOS Common
2234 */
2235
2236 struct GSUBGPOS
2237 {
2238 static const hb_tag_t GSUBTag = HB_OT_TAG_GSUB;
2239 static const hb_tag_t GPOSTag = HB_OT_TAG_GPOS;
2240
2241 inline unsigned int get_script_count (void) const
2242 { return (this+scriptList).len; }
2243 inline const Tag& get_script_tag (unsigned int i) const
2244 { return (this+scriptList).get_tag (i); }
2245 inline unsigned int get_script_tags (unsigned int start_offset,
2246 unsigned int *script_count /* IN/OUT */,
2247 hb_tag_t *script_tags /* OUT */) const
2248 { return (this+scriptList).get_tags (start_offset, script_count, script_tags); }
2249 inline const Script& get_script (unsigned int i) const
2250 { return (this+scriptList)[i]; }
2251 inline bool find_script_index (hb_tag_t tag, unsigned int *index) const
2252 { return (this+scriptList).find_index (tag, index); }
2253
2254 inline unsigned int get_feature_count (void) const
2255 { return (this+featureList).len; }
2256 inline const Tag& get_feature_tag (unsigned int i) const
2257 { return (this+featureList).get_tag (i); }
2258 inline unsigned int get_feature_tags (unsigned int start_offset,
2259 unsigned int *feature_count /* IN/OUT */,
2260 hb_tag_t *feature_tags /* OUT */) const
2261 { return (this+featureList).get_tags (start_offset, feature_count, feature_tags); }
2262 inline const Feature& get_feature (unsigned int i) const
2263 { return (this+featureList)[i]; }
2264 inline bool find_feature_index (hb_tag_t tag, unsigned int *index) const
2265 { return (this+featureList).find_index (tag, index); }
2266
2267 inline unsigned int get_lookup_count (void) const
2268 { return (this+lookupList).len; }
2269 inline const Lookup& get_lookup (unsigned int i) const
2270 { return (this+lookupList)[i]; }
2271
2272 inline bool sanitize (hb_sanitize_context_t *c) {
2273 TRACE_SANITIZE (this);
2274 return TRACE_RETURN (version.sanitize (c) && likely (version.major == 1) &&
2275 scriptList.sanitize (c, this) &&
2276 featureList.sanitize (c, this) &&
2277 lookupList.sanitize (c, this));
2278 }
2279
2280 protected:
2281 FixedVersion version; /* Version of the GSUB/GPOS table--initially set
2282 * to 0x00010000 */
2283 OffsetTo<ScriptList>
2284 scriptList; /* ScriptList table */
2285 OffsetTo<FeatureList>
2286 featureList; /* FeatureList table */
2287 OffsetTo<LookupList>
2288 lookupList; /* LookupList table */
2289 public:
2290 DEFINE_SIZE_STATIC (10);
2291 };
2292
2293
2294 } /* namespace OT */
2295
2296
2297 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial