diff options
author | Akira Kakuto <kakuto@fuk.kindai.ac.jp> | 2018-12-22 00:39:38 +0000 |
---|---|---|
committer | Akira Kakuto <kakuto@fuk.kindai.ac.jp> | 2018-12-22 00:39:38 +0000 |
commit | aefa260469999e53f3b8ea263fda94cdddef8ce3 (patch) | |
tree | e1182a668216a25f19d5f18ffcfec27cc7925b96 /Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh | |
parent | 27205aecce351fee6bb1ad9a7c43d4b542e28a1a (diff) |
harfbuzz-2.3.0
git-svn-id: svn://tug.org/texlive/trunk@49473 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh')
-rw-r--r-- | Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh | 529 |
1 files changed, 246 insertions, 283 deletions
diff --git a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh index 27bd440dabf..180e7f2decd 100644 --- a/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh +++ b/Build/source/libs/harfbuzz/harfbuzz-src/src/hb-ot-layout-gsub-table.hh @@ -36,16 +36,15 @@ namespace OT { static inline void SingleSubst_serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<GlyphID> &substitutes, - unsigned int num_glyphs); + hb_array_t<const GlyphID> glyphs, + hb_array_t<const GlyphID> substitutes); struct SingleSubstFormat1 { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); for (Coverage::Iter iter (this+coverage); iter.more (); iter.next ()) @@ -58,7 +57,7 @@ struct SingleSubstFormat1 } } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); if (unlikely (!(this+coverage).add_coverage (c->input))) return; @@ -71,16 +70,15 @@ struct SingleSubstFormat1 } } - inline const Coverage &get_coverage (void) const - { return this+coverage; } + const Coverage &get_coverage () const { return this+coverage; } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_codepoint_t glyph_id = c->buffer->cur().codepoint; @@ -95,43 +93,37 @@ struct SingleSubstFormat1 return_trace (true); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - unsigned int num_glyphs, - int delta) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + int delta) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false); + if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs))) return_trace (false); deltaGlyphID.set (delta); /* TODO(serialize) overflow? */ return_trace (true); } - inline bool subset (hb_subset_context_t *c) const + 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; hb_vector_t<GlyphID> from; hb_vector_t<GlyphID> to; hb_codepoint_t delta = deltaGlyphID; for (Coverage::Iter iter (this+coverage); iter.more (); iter.next ()) { - if (!c->plan->glyphset->has (iter.get_glyph ())) - continue; - from.push ()->set (iter.get_glyph ()); - to.push ()->set ((iter.get_glyph () + delta) & 0xFFFF); + if (!glyphset.has (iter.get_glyph ())) continue; + from.push ()->set (glyph_map[iter.get_glyph ()]); + to.push ()->set (glyph_map[(iter.get_glyph () + delta) & 0xFFFF]); } - c->serializer->err (from.in_error () || to.in_error ()); - - Supplier<GlyphID> from_supplier (&from); - Supplier<GlyphID> to_supplier (&to); - SingleSubst_serialize (c->serializer, - from_supplier, - to_supplier, - from.len); + c->serializer->propagate_error (from, to); + SingleSubst_serialize (c->serializer, from, to); return_trace (from.len); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (coverage.sanitize (c, this) && deltaGlyphID.sanitize (c)); @@ -150,10 +142,10 @@ struct SingleSubstFormat1 struct SingleSubstFormat2 { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = substitute.len; @@ -166,7 +158,7 @@ struct SingleSubstFormat2 } } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); if (unlikely (!(this+coverage).add_coverage (c->input))) return; @@ -179,16 +171,15 @@ struct SingleSubstFormat2 } } - inline const Coverage &get_coverage (void) const - { return this+coverage; } + const Coverage &get_coverage () const { return this+coverage; } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint); @@ -201,42 +192,36 @@ struct SingleSubstFormat2 return_trace (true); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<GlyphID> &substitutes, - unsigned int num_glyphs) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const GlyphID> substitutes) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!substitute.serialize (c, substitutes, num_glyphs))) return_trace (false); - if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) 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); } - inline bool subset (hb_subset_context_t *c) const + 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; hb_vector_t<GlyphID> from; hb_vector_t<GlyphID> to; for (Coverage::Iter iter (this+coverage); iter.more (); iter.next ()) { - if (!c->plan->glyphset->has (iter.get_glyph ())) - continue; - from.push ()->set (iter.get_glyph ()); - to.push ()->set (substitute[iter.get_coverage ()]); + if (!glyphset.has (iter.get_glyph ())) continue; + from.push ()->set (glyph_map[iter.get_glyph ()]); + to.push ()->set (glyph_map[substitute[iter.get_coverage ()]]); } - c->serializer->err (from.in_error () || to.in_error ()); - - Supplier<GlyphID> from_supplier (&from); - Supplier<GlyphID> to_supplier (&to); - SingleSubst_serialize (c->serializer, - from_supplier, - to_supplier, - from.len); + c->serializer->propagate_error (from, to); + SingleSubst_serialize (c->serializer, from, to); return_trace (from.len); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (coverage.sanitize (c, this) && substitute.sanitize (c)); @@ -256,35 +241,35 @@ struct SingleSubstFormat2 struct SingleSubst { - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<GlyphID> &substitutes, - unsigned int num_glyphs) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const GlyphID> substitutes) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); unsigned int format = 2; int delta = 0; - if (num_glyphs) { + if (glyphs.len) + { format = 1; /* TODO(serialize) check for wrap-around */ delta = substitutes[0] - glyphs[0]; - for (unsigned int i = 1; i < num_glyphs; i++) - if (delta != substitutes[i] - glyphs[i]) { + for (unsigned int i = 1; i < glyphs.len; i++) + if (delta != (int) (substitutes[i] - glyphs[i])) { format = 2; break; } } u.format.set (format); switch (u.format) { - case 1: return_trace (u.format1.serialize (c, glyphs, num_glyphs, delta)); - case 2: return_trace (u.format2.serialize (c, glyphs, substitutes, num_glyphs)); + case 1: return_trace (u.format1.serialize (c, glyphs, delta)); + case 2: return_trace (u.format2.serialize (c, glyphs, substitutes)); default:return_trace (false); } } template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c) const + typename context_t::return_t dispatch (context_t *c) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); @@ -305,19 +290,13 @@ struct SingleSubst static inline void SingleSubst_serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<GlyphID> &substitutes, - unsigned int num_glyphs) -{ - c->start_embed<SingleSubst> ()->serialize (c, - glyphs, - substitutes, - num_glyphs); -} + hb_array_t<const GlyphID> glyphs, + hb_array_t<const GlyphID> substitutes) +{ c->start_embed<SingleSubst> ()->serialize (c, glyphs, substitutes); } struct Sequence { - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = substitute.len; @@ -325,13 +304,13 @@ struct Sequence c->out->add (substitute[i]); } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); c->output->add_array (substitute.arrayZ, substitute.len); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); unsigned int count = substitute.len; @@ -363,17 +342,14 @@ struct Sequence return_trace (true); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - unsigned int num_glyphs) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs) { TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!substitute.serialize (c, glyphs, num_glyphs))) return_trace (false); - return_trace (true); + return_trace (substitute.serialize (c, glyphs)); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (substitute.sanitize (c)); @@ -388,10 +364,10 @@ struct Sequence struct MultipleSubstFormat1 { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = sequence.len; @@ -404,7 +380,7 @@ struct MultipleSubstFormat1 } } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); if (unlikely (!(this+coverage).add_coverage (c->input))) return; @@ -413,16 +389,15 @@ struct MultipleSubstFormat1 (this+sequence[i]).collect_glyphs (c); } - inline const Coverage &get_coverage (void) const - { return this+coverage; } + const Coverage &get_coverage () const { return this+coverage; } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); @@ -432,32 +407,33 @@ struct MultipleSubstFormat1 return_trace ((this+sequence[index]).apply (c)); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<unsigned int> &substitute_len_list, - unsigned int num_glyphs, - Supplier<GlyphID> &substitute_glyphs_list) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const unsigned int> substitute_len_list, + hb_array_t<const GlyphID> substitute_glyphs_list) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!sequence.serialize (c, num_glyphs))) return_trace (false); - for (unsigned int i = 0; i < num_glyphs; i++) - if (unlikely (!sequence[i].serialize (c, this).serialize (c, - substitute_glyphs_list, - substitute_len_list[i]))) return_trace (false); - substitute_len_list += num_glyphs; - if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false); - return_trace (true); + if (unlikely (!sequence.serialize (c, glyphs.len))) return_trace (false); + for (unsigned int i = 0; i < glyphs.len; 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)); } - inline bool subset (hb_subset_context_t *c) const + bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); // TODO(subset) return_trace (false); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (coverage.sanitize (c, this) && sequence.sanitize (c, this)); @@ -477,24 +453,23 @@ struct MultipleSubstFormat1 struct MultipleSubst { - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<unsigned int> &substitute_len_list, - unsigned int num_glyphs, - Supplier<GlyphID> &substitute_glyphs_list) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const unsigned int> substitute_len_list, + hb_array_t<const GlyphID> substitute_glyphs_list) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); unsigned int format = 1; u.format.set (format); switch (u.format) { - case 1: return_trace (u.format1.serialize (c, glyphs, substitute_len_list, num_glyphs, substitute_glyphs_list)); + case 1: return_trace (u.format1.serialize (c, glyphs, substitute_len_list, substitute_glyphs_list)); default:return_trace (false); } } template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c) const + typename context_t::return_t dispatch (context_t *c) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); @@ -513,7 +488,7 @@ struct MultipleSubst struct AlternateSet { - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = alternates.len; @@ -521,13 +496,13 @@ struct AlternateSet c->out->add (alternates[i]); } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); c->output->add_array (alternates.arrayZ, alternates.len); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); unsigned int count = alternates.len; @@ -552,17 +527,14 @@ struct AlternateSet return_trace (true); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - unsigned int num_glyphs) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs) { TRACE_SERIALIZE (this); - if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!alternates.serialize (c, glyphs, num_glyphs))) return_trace (false); - return_trace (true); + return_trace (alternates.serialize (c, glyphs)); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (alternates.sanitize (c)); @@ -578,10 +550,10 @@ struct AlternateSet struct AlternateSubstFormat1 { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = alternateSet.len; @@ -594,7 +566,7 @@ struct AlternateSubstFormat1 } } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); if (unlikely (!(this+coverage).add_coverage (c->input))) return; @@ -607,16 +579,15 @@ struct AlternateSubstFormat1 } } - inline const Coverage &get_coverage (void) const - { return this+coverage; } + const Coverage &get_coverage () const { return this+coverage; } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); @@ -626,32 +597,33 @@ struct AlternateSubstFormat1 return_trace ((this+alternateSet[index]).apply (c)); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<unsigned int> &alternate_len_list, - unsigned int num_glyphs, - Supplier<GlyphID> &alternate_glyphs_list) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const unsigned int> alternate_len_list, + hb_array_t<const GlyphID> alternate_glyphs_list) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - if (unlikely (!alternateSet.serialize (c, num_glyphs))) return_trace (false); - for (unsigned int i = 0; i < num_glyphs; i++) - if (unlikely (!alternateSet[i].serialize (c, this).serialize (c, - alternate_glyphs_list, - alternate_len_list[i]))) return_trace (false); - alternate_len_list += num_glyphs; - if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false); - return_trace (true); + if (unlikely (!alternateSet.serialize (c, glyphs.len))) return_trace (false); + for (unsigned int i = 0; i < glyphs.len; 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)); } - inline bool subset (hb_subset_context_t *c) const + bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); // TODO(subset) return_trace (false); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (coverage.sanitize (c, this) && alternateSet.sanitize (c, this)); @@ -671,24 +643,23 @@ struct AlternateSubstFormat1 struct AlternateSubst { - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &glyphs, - Supplier<unsigned int> &alternate_len_list, - unsigned int num_glyphs, - Supplier<GlyphID> &alternate_glyphs_list) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const unsigned int> alternate_len_list, + hb_array_t<const GlyphID> alternate_glyphs_list) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); unsigned int format = 1; u.format.set (format); switch (u.format) { - case 1: return_trace (u.format1.serialize (c, glyphs, alternate_len_list, num_glyphs, alternate_glyphs_list)); + case 1: return_trace (u.format1.serialize (c, glyphs, alternate_len_list, alternate_glyphs_list)); default:return_trace (false); } } template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c) const + typename context_t::return_t dispatch (context_t *c) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); @@ -708,7 +679,7 @@ struct AlternateSubst struct Ligature { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { unsigned int count = component.lenP1; for (unsigned int i = 1; i < count; i++) @@ -717,7 +688,7 @@ struct Ligature return true; } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = component.lenP1; @@ -727,14 +698,14 @@ struct Ligature c->out->add (ligGlyph); } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); c->input->add_array (component.arrayZ, component.lenP1 ? component.lenP1 - 1 : 0); c->output->add (ligGlyph); } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); if (c->len != component.lenP1) @@ -747,7 +718,7 @@ struct Ligature return_trace (true); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); unsigned int count = component.lenP1; @@ -786,20 +757,19 @@ struct Ligature return_trace (true); } - inline bool serialize (hb_serialize_context_t *c, - GlyphID ligature, - Supplier<GlyphID> &components, /* Starting from second */ - unsigned int num_components /* Including first component */) + bool serialize (hb_serialize_context_t *c, + GlyphID ligature, + hb_array_t<const GlyphID> components /* Starting from second */) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); ligGlyph = ligature; - if (unlikely (!component.serialize (c, components, num_components))) return_trace (false); + if (unlikely (!component.serialize (c, components))) return_trace (false); return_trace (true); } public: - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (ligGlyph.sanitize (c) && component.sanitize (c)); @@ -817,7 +787,7 @@ struct Ligature struct LigatureSet { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { unsigned int num_ligs = ligature.len; for (unsigned int i = 0; i < num_ligs; i++) @@ -826,7 +796,7 @@ struct LigatureSet return false; } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int num_ligs = ligature.len; @@ -834,7 +804,7 @@ struct LigatureSet (this+ligature[i]).closure (c); } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); unsigned int num_ligs = ligature.len; @@ -842,7 +812,7 @@ struct LigatureSet (this+ligature[i]).collect_glyphs (c); } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); unsigned int num_ligs = ligature.len; @@ -855,7 +825,7 @@ struct LigatureSet return_trace (false); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); unsigned int num_ligs = ligature.len; @@ -868,26 +838,28 @@ struct LigatureSet return_trace (false); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &ligatures, - Supplier<unsigned int> &component_count_list, - unsigned int num_ligatures, - Supplier<GlyphID> &component_list /* Starting from second for each ligature */) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> ligatures, + hb_array_t<const unsigned int> component_count_list, + hb_array_t<const GlyphID> 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, num_ligatures))) return_trace (false); - for (unsigned int i = 0; i < num_ligatures; i++) - if (unlikely (!ligature[i].serialize (c, this).serialize (c, - ligatures[i], - component_list, - component_count_list[i]))) return_trace (false); - ligatures += num_ligatures; - component_count_list += num_ligatures; + if (unlikely (!ligature.serialize (c, ligatures.len))) return_trace (false); + for (unsigned int i = 0; i < ligatures.len; i++) + { + unsigned int component_count = 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); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (ligature.sanitize (c, this)); @@ -903,7 +875,7 @@ struct LigatureSet struct LigatureSubstFormat1 { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { unsigned int count = ligatureSet.len; for (Coverage::Iter iter (this+coverage); iter.more (); iter.next ()) @@ -917,7 +889,7 @@ struct LigatureSubstFormat1 return false; } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); unsigned int count = ligatureSet.len; @@ -930,7 +902,7 @@ struct LigatureSubstFormat1 } } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); if (unlikely (!(this+coverage).add_coverage (c->input))) return; @@ -943,10 +915,9 @@ struct LigatureSubstFormat1 } } - inline const Coverage &get_coverage (void) const - { return this+coverage; } + const Coverage &get_coverage () const { return this+coverage; } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); unsigned int index = (this+coverage).get_coverage (c->glyphs[0]); @@ -956,7 +927,7 @@ struct LigatureSubstFormat1 return_trace (lig_set.would_apply (c)); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); @@ -967,36 +938,40 @@ struct LigatureSubstFormat1 return_trace (lig_set.apply (c)); } - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &first_glyphs, - Supplier<unsigned int> &ligature_per_first_glyph_count_list, - unsigned int num_first_glyphs, - Supplier<GlyphID> &ligatures_list, - Supplier<unsigned int> &component_count_list, - Supplier<GlyphID> &component_list /* Starting from second for each ligature */) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> first_glyphs, + hb_array_t<const unsigned int> ligature_per_first_glyph_count_list, + hb_array_t<const GlyphID> ligatures_list, + hb_array_t<const unsigned int> component_count_list, + hb_array_t<const GlyphID> 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, num_first_glyphs))) return_trace (false); - for (unsigned int i = 0; i < num_first_glyphs; i++) - if (unlikely (!ligatureSet[i].serialize (c, this).serialize (c, - ligatures_list, - component_count_list, - ligature_per_first_glyph_count_list[i], - component_list))) return_trace (false); - ligature_per_first_glyph_count_list += num_first_glyphs; - if (unlikely (!coverage.serialize (c, this).serialize (c, first_glyphs, num_first_glyphs))) return_trace (false); - return_trace (true); + if (unlikely (!ligatureSet.serialize (c, first_glyphs.len))) return_trace (false); + for (unsigned int i = 0; i < first_glyphs.len; 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; + for (unsigned int i = 0; i < ligature_count; i++) + component_list += MAX<int> (component_count_list[i] - 1, 0); + } + return_trace (coverage.serialize (c, this).serialize (c, first_glyphs)); } - inline bool subset (hb_subset_context_t *c) const + bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); // TODO(subset) return_trace (false); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (coverage.sanitize (c, this) && ligatureSet.sanitize (c, this)); @@ -1016,13 +991,12 @@ struct LigatureSubstFormat1 struct LigatureSubst { - inline bool serialize (hb_serialize_context_t *c, - Supplier<GlyphID> &first_glyphs, - Supplier<unsigned int> &ligature_per_first_glyph_count_list, - unsigned int num_first_glyphs, - Supplier<GlyphID> &ligatures_list, - Supplier<unsigned int> &component_count_list, - Supplier<GlyphID> &component_list /* Starting from second for each ligature */) + bool serialize (hb_serialize_context_t *c, + hb_array_t<const GlyphID> first_glyphs, + hb_array_t<const unsigned int> ligature_per_first_glyph_count_list, + hb_array_t<const GlyphID> ligatures_list, + hb_array_t<const unsigned int> component_count_list, + hb_array_t<const GlyphID> component_list /* Starting from second for each ligature */) { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); @@ -1032,7 +1006,6 @@ struct LigatureSubst case 1: return_trace (u.format1.serialize (c, first_glyphs, ligature_per_first_glyph_count_list, - num_first_glyphs, ligatures_list, component_count_list, component_list)); @@ -1041,7 +1014,7 @@ struct LigatureSubst } template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c) const + typename context_t::return_t dispatch (context_t *c) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); @@ -1067,13 +1040,13 @@ struct ExtensionSubst : Extension<ExtensionSubst> { typedef struct SubstLookupSubTable SubTable; - inline bool is_reverse (void) const; + bool is_reverse () const; }; struct ReverseChainSingleSubstFormat1 { - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { if (!(this+coverage).intersects (glyphs)) return false; @@ -1095,7 +1068,7 @@ struct ReverseChainSingleSubstFormat1 return true; } - inline void closure (hb_closure_context_t *c) const + void closure (hb_closure_context_t *c) const { TRACE_CLOSURE (this); const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack); @@ -1123,7 +1096,7 @@ struct ReverseChainSingleSubstFormat1 } } - inline void collect_glyphs (hb_collect_glyphs_context_t *c) const + void collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); if (unlikely (!(this+coverage).add_coverage (c->input))) return; @@ -1144,16 +1117,15 @@ struct ReverseChainSingleSubstFormat1 c->output->add_array (substitute.arrayZ, substitute.len); } - inline const Coverage &get_coverage (void) const - { return this+coverage; } + const Coverage &get_coverage () const { return this+coverage; } - inline bool would_apply (hb_would_apply_context_t *c) const + bool would_apply (hb_would_apply_context_t *c) const { TRACE_WOULD_APPLY (this); return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); if (unlikely (c->nesting_level_left != HB_MAX_NESTING_LEVEL)) @@ -1186,14 +1158,14 @@ struct ReverseChainSingleSubstFormat1 return_trace (false); } - inline bool subset (hb_subset_context_t *c) const + bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); // TODO(subset) return_trace (false); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (!(coverage.sanitize (c, this) && backtrack.sanitize (c, this))) @@ -1228,7 +1200,7 @@ struct ReverseChainSingleSubstFormat1 struct ReverseChainSingleSubst { template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c) const + typename context_t::return_t dispatch (context_t *c) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); @@ -1268,10 +1240,9 @@ struct SubstLookupSubTable }; template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type) const + typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type) const { TRACE_DISPATCH (this, lookup_type); - if (unlikely (!c->may_dispatch (this, &u.sub_format))) return_trace (c->no_dispatch_return_value ()); switch (lookup_type) { case Single: return_trace (u.single.dispatch (c)); case Multiple: return_trace (u.multiple.dispatch (c)); @@ -1287,7 +1258,6 @@ struct SubstLookupSubTable protected: union { - HBUINT16 sub_format; SingleSubst single; MultipleSubst multiple; AlternateSubst alternate; @@ -1298,7 +1268,7 @@ struct SubstLookupSubTable ReverseChainSingleSubst reverseChainContextSingle; } u; public: - DEFINE_SIZE_UNION (2, sub_format); + DEFINE_SIZE_MIN (0); }; @@ -1306,13 +1276,13 @@ struct SubstLookup : Lookup { typedef SubstLookupSubTable SubTable; - inline const SubTable& get_subtable (unsigned int i) const + const SubTable& get_subtable (unsigned int i) const { return Lookup::get_subtable<SubTable> (i); } - inline static bool lookup_type_is_reverse (unsigned int lookup_type) + static bool lookup_type_is_reverse (unsigned int lookup_type) { return lookup_type == SubTable::ReverseChainSingle; } - inline bool is_reverse (void) const + bool is_reverse () const { unsigned int type = get_type (); if (unlikely (type == SubTable::Extension)) @@ -1320,19 +1290,19 @@ struct SubstLookup : Lookup return lookup_type_is_reverse (type); } - inline bool apply (hb_ot_apply_context_t *c) const + bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); return_trace (dispatch (c)); } - inline bool intersects (const hb_set_t *glyphs) const + bool intersects (const hb_set_t *glyphs) const { hb_intersects_context_t c (glyphs); return dispatch (&c); } - inline hb_closure_context_t::return_t closure (hb_closure_context_t *c, unsigned int this_index) const + hb_closure_context_t::return_t closure (hb_closure_context_t *c, unsigned int this_index) const { TRACE_CLOSURE (this); if (!c->should_visit_lookup (this_index)) @@ -1347,7 +1317,7 @@ struct SubstLookup : Lookup return_trace (ret); } - inline hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const + hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const { TRACE_COLLECT_GLYPHS (this); c->set_recurse_func (dispatch_recurse_func<hb_collect_glyphs_context_t>); @@ -1355,14 +1325,14 @@ struct SubstLookup : Lookup } template <typename set_t> - inline void add_coverage (set_t *glyphs) const + void add_coverage (set_t *glyphs) const { hb_add_coverage_context_t<set_t> c (glyphs); dispatch (&c); } - inline bool would_apply (hb_would_apply_context_t *c, - const hb_ot_layout_lookup_accelerator_t *accel) const + bool would_apply (hb_would_apply_context_t *c, + const hb_ot_layout_lookup_accelerator_t *accel) const { TRACE_WOULD_APPLY (this); if (unlikely (!c->len)) return_trace (false); @@ -1372,77 +1342,70 @@ struct SubstLookup : Lookup static bool apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index); - inline SubTable& serialize_subtable (hb_serialize_context_t *c, + SubTable& serialize_subtable (hb_serialize_context_t *c, unsigned int i) { return get_subtables<SubTable> ()[i].serialize (c, this); } - inline bool serialize_single (hb_serialize_context_t *c, - uint32_t lookup_props, - Supplier<GlyphID> &glyphs, - Supplier<GlyphID> &substitutes, - unsigned int num_glyphs) + bool serialize_single (hb_serialize_context_t *c, + uint32_t lookup_props, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const GlyphID> 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, glyphs, substitutes, num_glyphs)); + return_trace (serialize_subtable (c, 0).u.single.serialize (c, glyphs, substitutes)); } - inline bool serialize_multiple (hb_serialize_context_t *c, - uint32_t lookup_props, - Supplier<GlyphID> &glyphs, - Supplier<unsigned int> &substitute_len_list, - unsigned int num_glyphs, - Supplier<GlyphID> &substitute_glyphs_list) + bool serialize_multiple (hb_serialize_context_t *c, + uint32_t lookup_props, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const unsigned int> substitute_len_list, + hb_array_t<const GlyphID> 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, - num_glyphs, substitute_glyphs_list)); } - inline bool serialize_alternate (hb_serialize_context_t *c, - uint32_t lookup_props, - Supplier<GlyphID> &glyphs, - Supplier<unsigned int> &alternate_len_list, - unsigned int num_glyphs, - Supplier<GlyphID> &alternate_glyphs_list) + bool serialize_alternate (hb_serialize_context_t *c, + uint32_t lookup_props, + hb_array_t<const GlyphID> glyphs, + hb_array_t<const unsigned int> alternate_len_list, + hb_array_t<const GlyphID> 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, - num_glyphs, alternate_glyphs_list)); } - inline bool serialize_ligature (hb_serialize_context_t *c, - uint32_t lookup_props, - Supplier<GlyphID> &first_glyphs, - Supplier<unsigned int> &ligature_per_first_glyph_count_list, - unsigned int num_first_glyphs, - Supplier<GlyphID> &ligatures_list, - Supplier<unsigned int> &component_count_list, - Supplier<GlyphID> &component_list /* Starting from second for each ligature */) + bool serialize_ligature (hb_serialize_context_t *c, + uint32_t lookup_props, + hb_array_t<const GlyphID> first_glyphs, + hb_array_t<const unsigned int> ligature_per_first_glyph_count_list, + hb_array_t<const GlyphID> ligatures_list, + hb_array_t<const unsigned int> component_count_list, + hb_array_t<const GlyphID> 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, - num_first_glyphs, ligatures_list, component_count_list, component_list)); } template <typename context_t> - static inline typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index); + static typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index); - static inline hb_closure_context_t::return_t dispatch_closure_recurse_func (hb_closure_context_t *c, unsigned int lookup_index) + 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_VOID; @@ -1458,13 +1421,13 @@ struct SubstLookup : Lookup } template <typename context_t> - inline typename context_t::return_t dispatch (context_t *c) const + typename context_t::return_t dispatch (context_t *c) const { return Lookup::dispatch<SubTable> (c); } - inline bool subset (hb_subset_context_t *c) const + bool subset (hb_subset_context_t *c) const { return Lookup::subset<SubTable> (c); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { return Lookup::sanitize<SubTable> (c); } }; @@ -1475,15 +1438,15 @@ struct SubstLookup : Lookup struct GSUB : GSUBGPOS { - static const hb_tag_t tableTag = HB_OT_TAG_GSUB; + enum { tableTag = HB_OT_TAG_GSUB }; - inline const SubstLookup& get_lookup (unsigned int i) const + const SubstLookup& get_lookup (unsigned int i) const { return CastR<SubstLookup> (GSUBGPOS::get_lookup (i)); } - inline bool subset (hb_subset_context_t *c) const + bool subset (hb_subset_context_t *c) const { return GSUBGPOS::subset<SubstLookup> (c); } - inline bool sanitize (hb_sanitize_context_t *c) const + bool sanitize (hb_sanitize_context_t *c) const { return GSUBGPOS::sanitize<SubstLookup> (c); } HB_INTERNAL bool is_blacklisted (hb_blob_t *blob, @@ -1498,7 +1461,7 @@ struct GSUB_accelerator_t : GSUB::accelerator_t {}; /* Out-of-class implementation for methods recursing */ -/*static*/ inline bool ExtensionSubst::is_reverse (void) const +/*static*/ inline bool ExtensionSubst::is_reverse () const { unsigned int type = get_type (); if (unlikely (type == SubTable::Extension)) |