diff options
Diffstat (limited to 'src/3rdparty/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh')
| -rw-r--r-- | src/3rdparty/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh | 1526 |
1 files changed, 33 insertions, 1493 deletions
diff --git a/src/3rdparty/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh b/src/3rdparty/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh index fc21cb056e..fd8a68be02 100644 --- a/src/3rdparty/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh +++ b/src/3rdparty/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh @@ -29,1525 +29,65 @@ #ifndef HB_OT_LAYOUT_GSUB_TABLE_HH #define HB_OT_LAYOUT_GSUB_TABLE_HH -#include "hb-ot-layout-gsubgpos.hh" - +#include "OT/Layout/GSUB/GSUB.hh" namespace OT { +namespace Layout { +namespace GSUB_impl { -typedef hb_pair_t<hb_codepoint_t, hb_codepoint_t> hb_codepoint_pair_t; - -template<typename Iterator> -static inline void SingleSubst_serialize (hb_serialize_context_t *c, - Iterator it); - - -struct SingleSubstFormat1 -{ - bool intersects (const hb_set_t *glyphs) const - { return (this+coverage).intersects (glyphs); } - - void closure (hb_closure_context_t *c) const - { - unsigned d = deltaGlyphID; - + hb_iter (this+coverage) - | hb_filter (*c->glyphs) - | hb_map ([d] (hb_codepoint_t g) { return (g + d) & 0xFFFFu; }) - | hb_sink (c->output) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - if (unlikely (!(this+coverage).add_coverage (c->input))) return; - unsigned d = deltaGlyphID; - + hb_iter (this+coverage) - | hb_map ([d] (hb_codepoint_t g) { return (g + d) & 0xFFFFu; }) - | hb_sink (c->output) - ; - } - - const Coverage &get_coverage () const { return this+coverage; } - - bool would_apply (hb_would_apply_context_t *c) const - { return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - hb_codepoint_t glyph_id = c->buffer->cur().codepoint; - unsigned int index = (this+coverage).get_coverage (glyph_id); - if (likely (index == NOT_COVERED)) return_trace (false); - - /* According to the Adobe Annotated OpenType Suite, result is always - * limited to 16bit. */ - glyph_id = (glyph_id + deltaGlyphID) & 0xFFFFu; - c->replace_glyph (glyph_id); - - return_trace (true); - } - - template<typename Iterator, - hb_requires (hb_is_sorted_source_of (Iterator, hb_codepoint_t))> - bool serialize (hb_serialize_context_t *c, - Iterator glyphs, - unsigned delta) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs))) return_trace (false); - c->check_assign (deltaGlyphID, delta); - return_trace (true); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset_gsub (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - hb_codepoint_t delta = deltaGlyphID; - - auto it = - + hb_iter (this+coverage) - | hb_filter (glyphset) - | hb_map_retains_sorting ([&] (hb_codepoint_t g) { - return hb_codepoint_pair_t (g, - (g + delta) & 0xFFFF); }) - | hb_filter (glyphset, hb_second) - | hb_map_retains_sorting ([&] (hb_codepoint_pair_t p) -> hb_codepoint_pair_t - { return hb_pair (glyph_map[p.first], glyph_map[p.second]); }) - ; - - bool ret = bool (it); - SingleSubst_serialize (c->serializer, it); - return_trace (ret); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (coverage.sanitize (c, this) && deltaGlyphID.sanitize (c)); - } - - protected: - HBUINT16 format; /* Format identifier--format = 1 */ - OffsetTo<Coverage> - coverage; /* Offset to Coverage table--from - * beginning of Substitution table */ - HBUINT16 deltaGlyphID; /* Add to original GlyphID to get - * substitute GlyphID, modulo 0x10000 */ - public: - DEFINE_SIZE_STATIC (6); -}; - -struct SingleSubstFormat2 -{ - bool intersects (const hb_set_t *glyphs) const - { return (this+coverage).intersects (glyphs); } - - void closure (hb_closure_context_t *c) const - { - + hb_zip (this+coverage, substitute) - | hb_filter (*c->glyphs, hb_first) - | hb_map (hb_second) - | hb_sink (c->output) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - if (unlikely (!(this+coverage).add_coverage (c->input))) return; - + hb_zip (this+coverage, substitute) - | hb_map (hb_second) - | hb_sink (c->output) - ; - } - - const Coverage &get_coverage () const { return this+coverage; } - - bool would_apply (hb_would_apply_context_t *c) const - { return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint); - if (likely (index == NOT_COVERED)) return_trace (false); - - if (unlikely (index >= substitute.len)) return_trace (false); - - c->replace_glyph (substitute[index]); - - return_trace (true); - } - - template<typename Iterator, - hb_requires (hb_is_sorted_source_of (Iterator, - hb_codepoint_pair_t))> - bool serialize (hb_serialize_context_t *c, - Iterator it) - { - TRACE_SERIALIZE (this); - auto substitutes = - + it - | hb_map (hb_second) - ; - auto glyphs = - + it - | hb_map_retains_sorting (hb_first) - ; - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!substitute.serialize (c, substitutes))) return_trace (false); - if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs))) return_trace (false); - return_trace (true); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset_gsub (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - auto it = - + hb_zip (this+coverage, substitute) - | hb_filter (glyphset, hb_first) - | hb_filter (glyphset, hb_second) - | hb_map_retains_sorting ([&] (hb_pair_t<hb_codepoint_t, const HBGlyphID &> p) -> hb_codepoint_pair_t - { return hb_pair (glyph_map[p.first], glyph_map[p.second]); }) - ; - - bool ret = bool (it); - SingleSubst_serialize (c->serializer, it); - return_trace (ret); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (coverage.sanitize (c, this) && substitute.sanitize (c)); - } - - protected: - HBUINT16 format; /* Format identifier--format = 2 */ - OffsetTo<Coverage> - coverage; /* Offset to Coverage table--from - * beginning of Substitution table */ - ArrayOf<HBGlyphID> - substitute; /* Array of substitute - * GlyphIDs--ordered by Coverage Index */ - public: - DEFINE_SIZE_ARRAY (6, substitute); -}; - -struct SingleSubst -{ - - template<typename Iterator, - hb_requires (hb_is_sorted_source_of (Iterator, - const hb_codepoint_pair_t))> - bool serialize (hb_serialize_context_t *c, - Iterator glyphs) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (u.format))) return_trace (false); - unsigned format = 2; - unsigned delta = 0; - if (glyphs) - { - format = 1; - auto get_delta = [=] (hb_codepoint_pair_t _) { - return (unsigned) (_.second - _.first) & 0xFFFF; - }; - delta = get_delta (*glyphs); - if (!hb_all (++(+glyphs), delta, get_delta)) format = 2; - } - u.format = format; - switch (u.format) { - case 1: return_trace (u.format1.serialize (c, - + glyphs - | hb_map_retains_sorting (hb_first), - delta)); - case 2: return_trace (u.format2.serialize (c, glyphs)); - default:return_trace (false); - } - } - - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const - { - TRACE_DISPATCH (this, u.format); - if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); - switch (u.format) { - case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...)); - case 2: return_trace (c->dispatch (u.format2, hb_forward<Ts> (ds)...)); - default:return_trace (c->default_return_value ()); - } - } - - protected: - union { - HBUINT16 format; /* Format identifier */ - SingleSubstFormat1 format1; - SingleSubstFormat2 format2; - } u; -}; - -template<typename Iterator> -static inline void -SingleSubst_serialize (hb_serialize_context_t *c, - Iterator it) -{ c->start_embed<SingleSubst> ()->serialize (c, it); } - -struct Sequence -{ - bool intersects (const hb_set_t *glyphs) const - { return hb_all (substitute, glyphs); } - - void closure (hb_closure_context_t *c) const - { c->output->add_array (substitute.arrayZ, substitute.len); } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { c->output->add_array (substitute.arrayZ, substitute.len); } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - unsigned int count = substitute.len; - - /* Special-case to make it in-place and not consider this - * as a "multiplied" substitution. */ - if (unlikely (count == 1)) - { - c->replace_glyph (substitute.arrayZ[0]); - return_trace (true); - } - /* Spec disallows this, but Uniscribe allows it. - * https://github.com/harfbuzz/harfbuzz/issues/253 */ - else if (unlikely (count == 0)) - { - c->buffer->delete_glyph (); - return_trace (true); - } - - unsigned int klass = _hb_glyph_info_is_ligature (&c->buffer->cur()) ? - HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0; - - for (unsigned int i = 0; i < count; i++) { - _hb_glyph_info_set_lig_props_for_component (&c->buffer->cur(), i); - c->output_glyph_for_component (substitute.arrayZ[i], klass); - } - c->buffer->skip_glyph (); - - return_trace (true); - } - - template <typename Iterator, - hb_requires (hb_is_source_of (Iterator, hb_codepoint_t))> - bool serialize (hb_serialize_context_t *c, - Iterator subst) - { - TRACE_SERIALIZE (this); - return_trace (substitute.serialize (c, subst)); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - if (!intersects (&glyphset)) return_trace (false); - - auto it = - + hb_iter (substitute) - | hb_map (glyph_map) - ; - - auto *out = c->serializer->start_embed (*this); - return_trace (out->serialize (c->serializer, it)); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (substitute.sanitize (c)); - } - - protected: - ArrayOf<HBGlyphID> - substitute; /* String of GlyphIDs to substitute */ - public: - DEFINE_SIZE_ARRAY (2, substitute); -}; - -struct MultipleSubstFormat1 -{ - bool intersects (const hb_set_t *glyphs) const - { return (this+coverage).intersects (glyphs); } - - void closure (hb_closure_context_t *c) const - { - + hb_zip (this+coverage, sequence) - | hb_filter (*c->glyphs, hb_first) - | hb_map (hb_second) - | hb_map (hb_add (this)) - | hb_apply ([c] (const Sequence &_) { _.closure (c); }) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - if (unlikely (!(this+coverage).add_coverage (c->input))) return; - + hb_zip (this+coverage, sequence) - | hb_map (hb_second) - | hb_map (hb_add (this)) - | hb_apply ([c] (const Sequence &_) { _.collect_glyphs (c); }) - ; - } - - const Coverage &get_coverage () const { return this+coverage; } - - bool would_apply (hb_would_apply_context_t *c) const - { return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - - unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint); - if (likely (index == NOT_COVERED)) return_trace (false); - - return_trace ((this+sequence[index]).apply (c)); - } - - bool serialize (hb_serialize_context_t *c, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const unsigned int> substitute_len_list, - hb_array_t<const HBGlyphID> substitute_glyphs_list) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!sequence.serialize (c, glyphs.length))) return_trace (false); - for (unsigned int i = 0; i < glyphs.length; i++) - { - unsigned int substitute_len = substitute_len_list[i]; - if (unlikely (!sequence[i].serialize (c, this) - .serialize (c, substitute_glyphs_list.sub_array (0, substitute_len)))) - return_trace (false); - substitute_glyphs_list += substitute_len; - } - return_trace (coverage.serialize (c, this).serialize (c, glyphs)); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - auto *out = c->serializer->start_embed (*this); - if (unlikely (!c->serializer->extend_min (out))) return_trace (false); - out->format = format; - - hb_sorted_vector_t<hb_codepoint_t> new_coverage; - + hb_zip (this+coverage, sequence) - | hb_filter (glyphset, hb_first) - | hb_filter (subset_offset_array (c, out->sequence, this, out), hb_second) - | hb_map (hb_first) - | hb_map (glyph_map) - | hb_sink (new_coverage) - ; - out->coverage.serialize (c->serializer, out) - .serialize (c->serializer, new_coverage.iter ()); - return_trace (bool (new_coverage)); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (coverage.sanitize (c, this) && sequence.sanitize (c, this)); - } - - protected: - HBUINT16 format; /* Format identifier--format = 1 */ - OffsetTo<Coverage> - coverage; /* Offset to Coverage table--from - * beginning of Substitution table */ - OffsetArrayOf<Sequence> - sequence; /* Array of Sequence tables - * ordered by Coverage Index */ - public: - DEFINE_SIZE_ARRAY (6, sequence); -}; - -struct MultipleSubst -{ - bool serialize (hb_serialize_context_t *c, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const unsigned int> substitute_len_list, - hb_array_t<const HBGlyphID> substitute_glyphs_list) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (u.format))) return_trace (false); - unsigned int format = 1; - u.format = format; - switch (u.format) { - case 1: return_trace (u.format1.serialize (c, glyphs, substitute_len_list, substitute_glyphs_list)); - default:return_trace (false); - } - } - - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const - { - TRACE_DISPATCH (this, u.format); - if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); - switch (u.format) { - case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...)); - default:return_trace (c->default_return_value ()); - } - } - - protected: - union { - HBUINT16 format; /* Format identifier */ - MultipleSubstFormat1 format1; - } u; -}; - -struct AlternateSet -{ - bool intersects (const hb_set_t *glyphs) const - { return hb_any (alternates, glyphs); } - - void closure (hb_closure_context_t *c) const - { c->output->add_array (alternates.arrayZ, alternates.len); } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { c->output->add_array (alternates.arrayZ, alternates.len); } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - unsigned int count = alternates.len; - - if (unlikely (!count)) return_trace (false); - - hb_mask_t glyph_mask = c->buffer->cur().mask; - hb_mask_t lookup_mask = c->lookup_mask; - - /* Note: This breaks badly if two features enabled this lookup together. */ - unsigned int shift = hb_ctz (lookup_mask); - unsigned int alt_index = ((lookup_mask & glyph_mask) >> shift); - - /* If alt_index is MAX_VALUE, randomize feature if it is the rand feature. */ - if (alt_index == HB_OT_MAP_MAX_VALUE && c->random) - alt_index = c->random_number () % count + 1; - - if (unlikely (alt_index > count || alt_index == 0)) return_trace (false); - - c->replace_glyph (alternates[alt_index - 1]); - - return_trace (true); - } - - template <typename Iterator, - hb_requires (hb_is_source_of (Iterator, hb_codepoint_t))> - bool serialize (hb_serialize_context_t *c, - Iterator alts) - { - TRACE_SERIALIZE (this); - return_trace (alternates.serialize (c, alts)); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - auto it = - + hb_iter (alternates) - | hb_filter (glyphset) - | hb_map (glyph_map) - ; - - auto *out = c->serializer->start_embed (*this); - return_trace (out->serialize (c->serializer, it) && - out->alternates); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (alternates.sanitize (c)); - } - - protected: - ArrayOf<HBGlyphID> - alternates; /* Array of alternate GlyphIDs--in - * arbitrary order */ - public: - DEFINE_SIZE_ARRAY (2, alternates); -}; - -struct AlternateSubstFormat1 -{ - bool intersects (const hb_set_t *glyphs) const - { return (this+coverage).intersects (glyphs); } - - void closure (hb_closure_context_t *c) const - { - + hb_zip (this+coverage, alternateSet) - | hb_map (hb_second) - | hb_map (hb_add (this)) - | hb_apply ([c] (const AlternateSet &_) { _.closure (c); }) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - if (unlikely (!(this+coverage).add_coverage (c->input))) return; - + hb_zip (this+coverage, alternateSet) - | hb_map (hb_second) - | hb_map (hb_add (this)) - | hb_apply ([c] (const AlternateSet &_) { _.collect_glyphs (c); }) - ; - } - - const Coverage &get_coverage () const { return this+coverage; } - - bool would_apply (hb_would_apply_context_t *c) const - { return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - - unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint); - if (likely (index == NOT_COVERED)) return_trace (false); - - return_trace ((this+alternateSet[index]).apply (c)); - } - - bool serialize (hb_serialize_context_t *c, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const unsigned int> alternate_len_list, - hb_array_t<const HBGlyphID> alternate_glyphs_list) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!alternateSet.serialize (c, glyphs.length))) return_trace (false); - for (unsigned int i = 0; i < glyphs.length; i++) - { - unsigned int alternate_len = alternate_len_list[i]; - if (unlikely (!alternateSet[i].serialize (c, this) - .serialize (c, alternate_glyphs_list.sub_array (0, alternate_len)))) - return_trace (false); - alternate_glyphs_list += alternate_len; - } - return_trace (coverage.serialize (c, this).serialize (c, glyphs)); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - auto *out = c->serializer->start_embed (*this); - if (unlikely (!c->serializer->extend_min (out))) return_trace (false); - out->format = format; - - hb_sorted_vector_t<hb_codepoint_t> new_coverage; - + hb_zip (this+coverage, alternateSet) - | hb_filter (glyphset, hb_first) - | hb_filter (subset_offset_array (c, out->alternateSet, this, out), hb_second) - | hb_map (hb_first) - | hb_map (glyph_map) - | hb_sink (new_coverage) - ; - out->coverage.serialize (c->serializer, out) - .serialize (c->serializer, new_coverage.iter ()); - return_trace (bool (new_coverage)); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (coverage.sanitize (c, this) && alternateSet.sanitize (c, this)); - } - - protected: - HBUINT16 format; /* Format identifier--format = 1 */ - OffsetTo<Coverage> - coverage; /* Offset to Coverage table--from - * beginning of Substitution table */ - OffsetArrayOf<AlternateSet> - alternateSet; /* Array of AlternateSet tables - * ordered by Coverage Index */ - public: - DEFINE_SIZE_ARRAY (6, alternateSet); -}; - -struct AlternateSubst -{ - bool serialize (hb_serialize_context_t *c, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const unsigned int> alternate_len_list, - hb_array_t<const HBGlyphID> alternate_glyphs_list) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (u.format))) return_trace (false); - unsigned int format = 1; - u.format = format; - switch (u.format) { - case 1: return_trace (u.format1.serialize (c, glyphs, alternate_len_list, alternate_glyphs_list)); - default:return_trace (false); - } - } - - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const - { - TRACE_DISPATCH (this, u.format); - if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); - switch (u.format) { - case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...)); - default:return_trace (c->default_return_value ()); - } - } - - protected: - union { - HBUINT16 format; /* Format identifier */ - AlternateSubstFormat1 format1; - } u; -}; - - -struct Ligature -{ - bool intersects (const hb_set_t *glyphs) const - { return hb_all (component, glyphs); } - - void closure (hb_closure_context_t *c) const - { - if (!intersects (c->glyphs)) return; - c->output->add (ligGlyph); - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - c->input->add_array (component.arrayZ, component.get_length ()); - c->output->add (ligGlyph); - } - - bool would_apply (hb_would_apply_context_t *c) const - { - if (c->len != component.lenP1) - return false; - - for (unsigned int i = 1; i < c->len; i++) - if (likely (c->glyphs[i] != component[i])) - return false; - - return true; - } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - unsigned int count = component.lenP1; - - if (unlikely (!count)) return_trace (false); - - /* Special-case to make it in-place and not consider this - * as a "ligated" substitution. */ - if (unlikely (count == 1)) - { - c->replace_glyph (ligGlyph); - return_trace (true); - } - - unsigned int total_component_count = 0; - - unsigned int match_length = 0; - unsigned int match_positions[HB_MAX_CONTEXT_LENGTH]; - - if (likely (!match_input (c, count, - &component[1], - match_glyph, - nullptr, - &match_length, - match_positions, - &total_component_count))) - return_trace (false); - - ligate_input (c, - count, - match_positions, - match_length, - ligGlyph, - total_component_count); - - return_trace (true); - } - - template <typename Iterator, - hb_requires (hb_is_source_of (Iterator, hb_codepoint_t))> - bool serialize (hb_serialize_context_t *c, - hb_codepoint_t ligature, - Iterator components /* Starting from second */) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - ligGlyph = ligature; - if (unlikely (!component.serialize (c, components))) return_trace (false); - return_trace (true); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - if (!intersects (&glyphset) || !glyphset.has (ligGlyph)) return_trace (false); - - auto it = - + hb_iter (component) - | hb_map (glyph_map) - ; - - auto *out = c->serializer->start_embed (*this); - return_trace (out->serialize (c->serializer, - glyph_map[ligGlyph], - it)); - } - - public: - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (ligGlyph.sanitize (c) && component.sanitize (c)); - } - - protected: - HBGlyphID ligGlyph; /* GlyphID of ligature to substitute */ - HeadlessArrayOf<HBGlyphID> - component; /* Array of component GlyphIDs--start - * with the second component--ordered - * in writing direction */ - public: - DEFINE_SIZE_ARRAY (4, component); -}; - -struct LigatureSet -{ - bool intersects (const hb_set_t *glyphs) const - { - return - + hb_iter (ligature) - | hb_map (hb_add (this)) - | hb_map ([glyphs] (const Ligature &_) { return _.intersects (glyphs); }) - | hb_any - ; - } - - void closure (hb_closure_context_t *c) const - { - + hb_iter (ligature) - | hb_map (hb_add (this)) - | hb_apply ([c] (const Ligature &_) { _.closure (c); }) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - + hb_iter (ligature) - | hb_map (hb_add (this)) - | hb_apply ([c] (const Ligature &_) { _.collect_glyphs (c); }) - ; - } - - bool would_apply (hb_would_apply_context_t *c) const - { - return - + hb_iter (ligature) - | hb_map (hb_add (this)) - | hb_map ([c] (const Ligature &_) { return _.would_apply (c); }) - | hb_any - ; - } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - unsigned int num_ligs = ligature.len; - for (unsigned int i = 0; i < num_ligs; i++) - { - const Ligature &lig = this+ligature[i]; - if (lig.apply (c)) return_trace (true); - } - - return_trace (false); - } - - bool serialize (hb_serialize_context_t *c, - hb_array_t<const HBGlyphID> ligatures, - hb_array_t<const unsigned int> component_count_list, - hb_array_t<const HBGlyphID> &component_list /* Starting from second for each ligature */) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!ligature.serialize (c, ligatures.length))) return_trace (false); - for (unsigned int i = 0; i < ligatures.length; i++) - { - unsigned int component_count = (unsigned) hb_max ((int) component_count_list[i] - 1, 0); - if (unlikely (!ligature[i].serialize (c, this) - .serialize (c, - ligatures[i], - component_list.sub_array (0, component_count)))) - return_trace (false); - component_list += component_count; - } - return_trace (true); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - auto *out = c->serializer->start_embed (*this); - if (unlikely (!c->serializer->extend_min (out))) return_trace (false); - - + hb_iter (ligature) - | hb_filter (subset_offset_array (c, out->ligature, this, out)) - | hb_drain - ; - return_trace (bool (out->ligature)); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (ligature.sanitize (c, this)); - } - - protected: - OffsetArrayOf<Ligature> - ligature; /* Array LigatureSet tables - * ordered by preference */ - public: - DEFINE_SIZE_ARRAY (2, ligature); -}; - -struct LigatureSubstFormat1 -{ - bool intersects (const hb_set_t *glyphs) const - { - return - + hb_zip (this+coverage, ligatureSet) - | hb_filter (*glyphs, hb_first) - | hb_map (hb_second) - | hb_map ([this, glyphs] (const OffsetTo<LigatureSet> &_) - { return (this+_).intersects (glyphs); }) - | hb_any - ; - } - - void closure (hb_closure_context_t *c) const - { - + hb_zip (this+coverage, ligatureSet) - | hb_filter (*c->glyphs, hb_first) - | hb_map (hb_second) - | hb_map (hb_add (this)) - | hb_apply ([c] (const LigatureSet &_) { _.closure (c); }) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - if (unlikely (!(this+coverage).add_coverage (c->input))) return; - - + hb_zip (this+coverage, ligatureSet) - | hb_map (hb_second) - | hb_map (hb_add (this)) - | hb_apply ([c] (const LigatureSet &_) { _.collect_glyphs (c); }) - ; - } - - const Coverage &get_coverage () const { return this+coverage; } - - bool would_apply (hb_would_apply_context_t *c) const - { - unsigned int index = (this+coverage).get_coverage (c->glyphs[0]); - if (likely (index == NOT_COVERED)) return false; - - const LigatureSet &lig_set = this+ligatureSet[index]; - return lig_set.would_apply (c); - } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - - unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint); - if (likely (index == NOT_COVERED)) return_trace (false); - - const LigatureSet &lig_set = this+ligatureSet[index]; - return_trace (lig_set.apply (c)); - } - - bool serialize (hb_serialize_context_t *c, - hb_sorted_array_t<const HBGlyphID> first_glyphs, - hb_array_t<const unsigned int> ligature_per_first_glyph_count_list, - hb_array_t<const HBGlyphID> ligatures_list, - hb_array_t<const unsigned int> component_count_list, - hb_array_t<const HBGlyphID> component_list /* Starting from second for each ligature */) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!ligatureSet.serialize (c, first_glyphs.length))) return_trace (false); - for (unsigned int i = 0; i < first_glyphs.length; i++) - { - unsigned int ligature_count = ligature_per_first_glyph_count_list[i]; - if (unlikely (!ligatureSet[i].serialize (c, this) - .serialize (c, - ligatures_list.sub_array (0, ligature_count), - component_count_list.sub_array (0, ligature_count), - component_list))) return_trace (false); - ligatures_list += ligature_count; - component_count_list += ligature_count; - } - return_trace (coverage.serialize (c, this).serialize (c, first_glyphs)); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - const hb_set_t &glyphset = *c->plan->glyphset (); - const hb_map_t &glyph_map = *c->plan->glyph_map; - - auto *out = c->serializer->start_embed (*this); - if (unlikely (!c->serializer->extend_min (out))) return_trace (false); - out->format = format; - - hb_sorted_vector_t<hb_codepoint_t> new_coverage; - + hb_zip (this+coverage, ligatureSet) - | hb_filter (glyphset, hb_first) - | hb_filter (subset_offset_array (c, out->ligatureSet, this, out), hb_second) - | hb_map (hb_first) - | hb_map (glyph_map) - | hb_sink (new_coverage) - ; - out->coverage.serialize (c->serializer, out) - .serialize (c->serializer, new_coverage.iter ()); - return_trace (bool (new_coverage)); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - return_trace (coverage.sanitize (c, this) && ligatureSet.sanitize (c, this)); - } - - protected: - HBUINT16 format; /* Format identifier--format = 1 */ - OffsetTo<Coverage> - coverage; /* Offset to Coverage table--from - * beginning of Substitution table */ - OffsetArrayOf<LigatureSet> - ligatureSet; /* Array LigatureSet tables - * ordered by Coverage Index */ - public: - DEFINE_SIZE_ARRAY (6, ligatureSet); -}; - -struct LigatureSubst -{ - bool serialize (hb_serialize_context_t *c, - hb_sorted_array_t<const HBGlyphID> first_glyphs, - hb_array_t<const unsigned int> ligature_per_first_glyph_count_list, - hb_array_t<const HBGlyphID> ligatures_list, - hb_array_t<const unsigned int> component_count_list, - hb_array_t<const HBGlyphID> component_list /* Starting from second for each ligature */) - { - TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (u.format))) return_trace (false); - unsigned int format = 1; - u.format = format; - switch (u.format) { - case 1: return_trace (u.format1.serialize (c, - first_glyphs, - ligature_per_first_glyph_count_list, - ligatures_list, - component_count_list, - component_list)); - default:return_trace (false); - } - } - - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const - { - TRACE_DISPATCH (this, u.format); - if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); - switch (u.format) { - case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...)); - default:return_trace (c->default_return_value ()); - } - } - - protected: - union { - HBUINT16 format; /* Format identifier */ - LigatureSubstFormat1 format1; - } u; -}; - - -struct ContextSubst : Context {}; - -struct ChainContextSubst : ChainContext {}; - -struct ExtensionSubst : Extension<ExtensionSubst> -{ - typedef struct SubstLookupSubTable SubTable; - - bool is_reverse () const; -}; - - -struct ReverseChainSingleSubstFormat1 -{ - bool intersects (const hb_set_t *glyphs) const - { - if (!(this+coverage).intersects (glyphs)) - return false; - - const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack); - - unsigned int count; - - count = backtrack.len; - for (unsigned int i = 0; i < count; i++) - if (!(this+backtrack[i]).intersects (glyphs)) - return false; - - count = lookahead.len; - for (unsigned int i = 0; i < count; i++) - if (!(this+lookahead[i]).intersects (glyphs)) - return false; - - return true; - } - - void closure (hb_closure_context_t *c) const - { - if (!intersects (c->glyphs)) return; - - const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack); - const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead); - - + hb_zip (this+coverage, substitute) - | hb_filter (*c->glyphs, hb_first) - | hb_map (hb_second) - | hb_sink (c->output) - ; - } - - void collect_glyphs (hb_collect_glyphs_context_t *c) const - { - if (unlikely (!(this+coverage).add_coverage (c->input))) return; - - unsigned int count; - - count = backtrack.len; - for (unsigned int i = 0; i < count; i++) - if (unlikely (!(this+backtrack[i]).add_coverage (c->before))) return; - - const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack); - count = lookahead.len; - for (unsigned int i = 0; i < count; i++) - if (unlikely (!(this+lookahead[i]).add_coverage (c->after))) return; - - const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead); - count = substitute.len; - c->output->add_array (substitute.arrayZ, substitute.len); - } - - const Coverage &get_coverage () const { return this+coverage; } - - bool would_apply (hb_would_apply_context_t *c) const - { return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - if (unlikely (c->nesting_level_left != HB_MAX_NESTING_LEVEL)) - return_trace (false); /* No chaining to this type */ - - unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint); - if (likely (index == NOT_COVERED)) return_trace (false); - - const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack); - const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead); - - unsigned int start_index = 0, end_index = 0; - if (match_backtrack (c, - backtrack.len, (HBUINT16 *) backtrack.arrayZ, - match_coverage, this, - &start_index) && - match_lookahead (c, - lookahead.len, (HBUINT16 *) lookahead.arrayZ, - match_coverage, this, - 1, &end_index)) - { - c->buffer->unsafe_to_break_from_outbuffer (start_index, end_index); - c->replace_glyph_inplace (substitute[index]); - /* Note: We DON'T decrease buffer->idx. The main loop does it - * for us. This is useful for preventing surprises if someone - * calls us through a Context lookup. */ - return_trace (true); - } - - return_trace (false); - } - - bool subset (hb_subset_context_t *c) const - { - TRACE_SUBSET (this); - // TODO(subset) - return_trace (false); - } - - bool sanitize (hb_sanitize_context_t *c) const - { - TRACE_SANITIZE (this); - if (!(coverage.sanitize (c, this) && backtrack.sanitize (c, this))) - return_trace (false); - const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage>> (backtrack); - if (!lookahead.sanitize (c, this)) - return_trace (false); - const ArrayOf<HBGlyphID> &substitute = StructAfter<ArrayOf<HBGlyphID>> (lookahead); - return_trace (substitute.sanitize (c)); - } - - protected: - HBUINT16 format; /* Format identifier--format = 1 */ - OffsetTo<Coverage> - coverage; /* Offset to Coverage table--from - * beginning of table */ - OffsetArrayOf<Coverage> - backtrack; /* Array of coverage tables - * in backtracking sequence, in glyph - * sequence order */ - OffsetArrayOf<Coverage> - lookaheadX; /* Array of coverage tables - * in lookahead sequence, in glyph - * sequence order */ - ArrayOf<HBGlyphID> - substituteX; /* Array of substitute - * GlyphIDs--ordered by Coverage Index */ - public: - DEFINE_SIZE_MIN (10); -}; - -struct ReverseChainSingleSubst -{ - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const - { - TRACE_DISPATCH (this, u.format); - if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); - switch (u.format) { - case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...)); - default:return_trace (c->default_return_value ()); - } - } - - protected: - union { - HBUINT16 format; /* Format identifier */ - ReverseChainSingleSubstFormat1 format1; - } u; -}; - - - -/* - * SubstLookup - */ - -struct SubstLookupSubTable -{ - friend struct Lookup; - friend struct SubstLookup; - - enum Type { - Single = 1, - Multiple = 2, - Alternate = 3, - Ligature = 4, - Context = 5, - ChainContext = 6, - Extension = 7, - ReverseChainSingle = 8 - }; - - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type, Ts&&... ds) const - { - TRACE_DISPATCH (this, lookup_type); - switch (lookup_type) { - case Single: return_trace (u.single.dispatch (c, hb_forward<Ts> (ds)...)); - case Multiple: return_trace (u.multiple.dispatch (c, hb_forward<Ts> (ds)...)); - case Alternate: return_trace (u.alternate.dispatch (c, hb_forward<Ts> (ds)...)); - case Ligature: return_trace (u.ligature.dispatch (c, hb_forward<Ts> (ds)...)); - case Context: return_trace (u.context.dispatch (c, hb_forward<Ts> (ds)...)); - case ChainContext: return_trace (u.chainContext.dispatch (c, hb_forward<Ts> (ds)...)); - case Extension: return_trace (u.extension.dispatch (c, hb_forward<Ts> (ds)...)); - case ReverseChainSingle: return_trace (u.reverseChainContextSingle.dispatch (c, hb_forward<Ts> (ds)...)); - default: return_trace (c->default_return_value ()); - } - } - - protected: - union { - SingleSubst single; - MultipleSubst multiple; - AlternateSubst alternate; - LigatureSubst ligature; - ContextSubst context; - ChainContextSubst chainContext; - ExtensionSubst extension; - ReverseChainSingleSubst reverseChainContextSingle; - } u; - public: - DEFINE_SIZE_MIN (0); -}; - - -struct SubstLookup : Lookup -{ - typedef SubstLookupSubTable SubTable; - - const SubTable& get_subtable (unsigned int i) const - { return Lookup::get_subtable<SubTable> (i); } - - HB_INTERNAL static bool lookup_type_is_reverse (unsigned int lookup_type) - { return lookup_type == SubTable::ReverseChainSingle; } - - bool is_reverse () const - { - unsigned int type = get_type (); - if (unlikely (type == SubTable::Extension)) - return CastR<ExtensionSubst> (get_subtable(0)).is_reverse (); - return lookup_type_is_reverse (type); - } - - bool apply (hb_ot_apply_context_t *c) const - { - TRACE_APPLY (this); - return_trace (dispatch (c)); - } - - bool intersects (const hb_set_t *glyphs) const - { - hb_intersects_context_t c (glyphs); - return dispatch (&c); - } - - hb_closure_context_t::return_t closure (hb_closure_context_t *c, unsigned int this_index) const - { - if (!c->should_visit_lookup (this_index)) - return hb_closure_context_t::default_return_value (); - - c->set_recurse_func (dispatch_closure_recurse_func); - - hb_closure_context_t::return_t ret = dispatch (c); - - c->flush (); - - return ret; - } - - hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const - { - c->set_recurse_func (dispatch_recurse_func<hb_collect_glyphs_context_t>); - return dispatch (c); - } - - template <typename set_t> - void add_coverage (set_t *glyphs) const - { - hb_add_coverage_context_t<set_t> c (glyphs); - dispatch (&c); - } - - bool would_apply (hb_would_apply_context_t *c, - const hb_ot_layout_lookup_accelerator_t *accel) const - { - if (unlikely (!c->len)) return false; - if (!accel->may_have (c->glyphs[0])) return false; - return dispatch (c); - } - - HB_INTERNAL static bool apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index); - - SubTable& serialize_subtable (hb_serialize_context_t *c, - unsigned int i) - { return get_subtables<SubTable> ()[i].serialize (c, this); } - - bool serialize_single (hb_serialize_context_t *c, - uint32_t lookup_props, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const HBGlyphID> substitutes) - { - TRACE_SERIALIZE (this); - if (unlikely (!Lookup::serialize (c, SubTable::Single, lookup_props, 1))) return_trace (false); - return_trace (serialize_subtable (c, 0).u.single. - serialize (c, hb_zip (glyphs, substitutes))); - } - - bool serialize_multiple (hb_serialize_context_t *c, - uint32_t lookup_props, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const unsigned int> substitute_len_list, - hb_array_t<const HBGlyphID> substitute_glyphs_list) - { - TRACE_SERIALIZE (this); - if (unlikely (!Lookup::serialize (c, SubTable::Multiple, lookup_props, 1))) return_trace (false); - return_trace (serialize_subtable (c, 0).u.multiple. - serialize (c, - glyphs, - substitute_len_list, - substitute_glyphs_list)); - } - - bool serialize_alternate (hb_serialize_context_t *c, - uint32_t lookup_props, - hb_sorted_array_t<const HBGlyphID> glyphs, - hb_array_t<const unsigned int> alternate_len_list, - hb_array_t<const HBGlyphID> alternate_glyphs_list) - { - TRACE_SERIALIZE (this); - if (unlikely (!Lookup::serialize (c, SubTable::Alternate, lookup_props, 1))) return_trace (false); - return_trace (serialize_subtable (c, 0).u.alternate. - serialize (c, - glyphs, - alternate_len_list, - alternate_glyphs_list)); - } - - bool serialize_ligature (hb_serialize_context_t *c, - uint32_t lookup_props, - hb_sorted_array_t<const HBGlyphID> first_glyphs, - hb_array_t<const unsigned int> ligature_per_first_glyph_count_list, - hb_array_t<const HBGlyphID> ligatures_list, - hb_array_t<const unsigned int> component_count_list, - hb_array_t<const HBGlyphID> component_list /* Starting from second for each ligature */) - { - TRACE_SERIALIZE (this); - if (unlikely (!Lookup::serialize (c, SubTable::Ligature, lookup_props, 1))) return_trace (false); - return_trace (serialize_subtable (c, 0).u.ligature. - serialize (c, - first_glyphs, - ligature_per_first_glyph_count_list, - ligatures_list, - component_count_list, - component_list)); - } - - template <typename context_t> - HB_INTERNAL static typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index); - - HB_INTERNAL static hb_closure_context_t::return_t dispatch_closure_recurse_func (hb_closure_context_t *c, unsigned int lookup_index) - { - if (!c->should_visit_lookup (lookup_index)) - return hb_empty_t (); - - hb_closure_context_t::return_t ret = dispatch_recurse_func (c, lookup_index); - - /* While in theory we should flush here, it will cause timeouts because a recursive - * lookup can keep growing the glyph set. Skip, and outer loop will retry up to - * HB_CLOSURE_MAX_STAGES time, which should be enough for every realistic font. */ - //c->flush (); - - return ret; - } - - template <typename context_t, typename ...Ts> - typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const - { return Lookup::dispatch<SubTable> (c, hb_forward<Ts> (ds)...); } - - bool subset (hb_subset_context_t *c) const - { return Lookup::subset<SubTable> (c); } - - bool sanitize (hb_sanitize_context_t *c) const - { return Lookup::sanitize<SubTable> (c); } -}; - -/* - * GSUB -- Glyph Substitution - * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub - */ - -struct GSUB : GSUBGPOS -{ - static constexpr hb_tag_t tableTag = HB_OT_TAG_GSUB; - - const SubstLookup& get_lookup (unsigned int i) const - { return CastR<SubstLookup> (GSUBGPOS::get_lookup (i)); } - - bool subset (hb_subset_context_t *c) const - { return GSUBGPOS::subset<SubstLookup> (c); } - - bool sanitize (hb_sanitize_context_t *c) const - { return GSUBGPOS::sanitize<SubstLookup> (c); } - - HB_INTERNAL bool is_blacklisted (hb_blob_t *blob, - hb_face_t *face) const; - - typedef GSUBGPOS::accelerator_t<GSUB> accelerator_t; -}; - - -struct GSUB_accelerator_t : GSUB::accelerator_t {}; - - +// TODO(garretrieger): Move into the new layout directory. /* Out-of-class implementation for methods recursing */ #ifndef HB_NO_OT_LAYOUT /*static*/ inline bool ExtensionSubst::is_reverse () const { - unsigned int type = get_type (); - if (unlikely (type == SubTable::Extension)) - return CastR<ExtensionSubst> (get_subtable<SubTable>()).is_reverse (); - return SubstLookup::lookup_type_is_reverse (type); + return SubstLookup::lookup_type_is_reverse (get_type ()); } template <typename context_t> -/*static*/ inline typename context_t::return_t SubstLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index) +/*static*/ typename context_t::return_t SubstLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index) { const SubstLookup &l = c->face->table.GSUB.get_relaxed ()->table->get_lookup (lookup_index); return l.dispatch (c); } -/*static*/ inline bool SubstLookup::apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index) + +/*static*/ typename hb_closure_context_t::return_t SubstLookup::closure_glyphs_recurse_func (hb_closure_context_t *c, unsigned lookup_index, hb_set_t *covered_seq_indices, unsigned seq_index, unsigned end_index) { const SubstLookup &l = c->face->table.GSUB.get_relaxed ()->table->get_lookup (lookup_index); + if (l.may_have_non_1to1 ()) + hb_set_add_range (covered_seq_indices, seq_index, end_index); + return l.dispatch (c); +} + +template <> +inline hb_closure_lookups_context_t::return_t +SubstLookup::dispatch_recurse_func<hb_closure_lookups_context_t> (hb_closure_lookups_context_t *c, unsigned this_index) +{ + const SubstLookup &l = c->face->table.GSUB.get_relaxed ()->table->get_lookup (this_index); + return l.closure_lookups (c, this_index); +} + +template <> +inline bool SubstLookup::dispatch_recurse_func<hb_ot_apply_context_t> (hb_ot_apply_context_t *c, unsigned int lookup_index) +{ + auto *gsub = c->face->table.GSUB.get_relaxed (); + const SubstLookup &l = gsub->table->get_lookup (lookup_index); unsigned int saved_lookup_props = c->lookup_props; unsigned int saved_lookup_index = c->lookup_index; c->set_lookup_index (lookup_index); c->set_lookup_props (l.get_props ()); - bool ret = l.dispatch (c); + + bool ret = false; + auto *accel = gsub->get_accel (lookup_index); + ret = accel && accel->apply (c, l.get_subtable_count (), false); + c->set_lookup_index (saved_lookup_index); c->set_lookup_props (saved_lookup_props); return ret; } #endif - +} /* namespace GSUB_impl */ +} /* namespace Layout */ } /* namespace OT */ |