tor-browser

LigatureSubstFormat1.hh (6725B)

---

#ifndef OT_LAYOUT_GSUB_LIGATURESUBSTFORMAT1_HH
#define OT_LAYOUT_GSUB_LIGATURESUBSTFORMAT1_HH

#include "Common.hh"
#include "LigatureSet.hh"

namespace OT {
namespace Layout {
namespace GSUB_impl {

template <typename Types>
struct LigatureSubstFormat1_2
{
 protected:
 HBUINT16      format;                 /* Format identifier--format = 1 */
 typename Types::template OffsetTo<Coverage>
               coverage;               /* Offset to Coverage table--from
                                        * beginning of Substitution table */
 Array16Of<typename Types::template OffsetTo<LigatureSet<Types>>>
               ligatureSet;            /* Array LigatureSet tables
                                        * ordered by Coverage Index */
 public:
 DEFINE_SIZE_ARRAY (4 + Types::size, ligatureSet);

 bool sanitize (hb_sanitize_context_t *c) const
 {
   TRACE_SANITIZE (this);
   return_trace (coverage.sanitize (c, this) && ligatureSet.sanitize (c, this));
 }

 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 typename Types::template OffsetTo<LigatureSet<Types>> &_)
             { return (this+_).intersects (glyphs); })
   | hb_any
   ;
 }

 bool may_have_non_1to1 () const
 { return true; }

 void closure (hb_closure_context_t *c) const
 {
   + hb_zip (this+coverage, ligatureSet)
   | hb_filter (c->parent_active_glyphs (), hb_first)
   | hb_map (hb_second)
   | hb_map (hb_add (this))
   | hb_apply ([c] (const LigatureSet<Types> &_) { _.closure (c); })
   ;

 }

 void closure_lookups (hb_closure_lookups_context_t *c) const {}

 void collect_glyphs (hb_collect_glyphs_context_t *c) const
 {
   if (unlikely (!(this+coverage).collect_coverage (c->input))) return;

   + hb_zip (this+coverage, ligatureSet)
   | hb_map (hb_second)
   | hb_map (hb_add (this))
   | hb_apply ([c] (const LigatureSet<Types> &_) { _.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 auto &lig_set = this+ligatureSet[index];
   return lig_set.would_apply (c);
 }

 struct external_cache_t
 {
   hb_ot_layout_mapping_cache_t coverage;
   hb_set_digest_t seconds;
 };
 void *external_cache_create () const
 {
   external_cache_t *cache = (external_cache_t *) hb_malloc (sizeof (external_cache_t));
   if (likely (cache))
   {
     cache->coverage.clear ();

     cache->seconds.init ();
     + hb_iter (ligatureSet)
     | hb_map (hb_add (this))
     | hb_apply ([cache] (const LigatureSet<Types> &_) { _.collect_seconds (cache->seconds); })
     ;
   }
   return cache;
 }

 bool apply (hb_ot_apply_context_t *c, void *external_cache) const
 {
   TRACE_APPLY (this);
   hb_buffer_t *buffer = c->buffer;

#ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE
   external_cache_t *cache = (external_cache_t *) external_cache;
   const hb_set_digest_t *seconds = cache ? &cache->seconds : nullptr;
   unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint, cache ? &cache->coverage : nullptr);
#else
   const hb_set_digest_t *seconds = nullptr;
   unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
#endif
   if (index == NOT_COVERED) return_trace (false);

   const auto &lig_set = this+ligatureSet[index];
   return_trace (lig_set.apply (c, seconds));
 }

 bool serialize (hb_serialize_context_t *c,
                 hb_sorted_array_t<const HBGlyphID16> first_glyphs,
                 hb_array_t<const unsigned int> ligature_per_first_glyph_count_list,
                 hb_array_t<const HBGlyphID16> ligatures_list,
                 hb_array_t<const unsigned int> component_count_list,
                 hb_array_t<const HBGlyphID16> 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_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_serialize (c, first_glyphs));
 }

 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 *out = c->serializer->start_embed (*this);
   if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
   out->format = format;

   // Due to a bug in some older versions of windows 7 the Coverage table must be
   // packed after the LigatureSet and Ligature tables, so serialize Coverage first
   // which places it last in the packed order.
   hb_set_t new_coverage;
   + hb_zip (this+coverage, hb_iter (ligatureSet) | hb_map (hb_add (this)))
   | hb_filter (glyphset, hb_first)
   | hb_filter ([&] (const LigatureSet<Types>& _) {
     return _.intersects_lig_glyph (&glyphset);
   }, hb_second)
   | hb_map (hb_first)
   | hb_sink (new_coverage);

   if (!c->serializer->push<Coverage> ()
       ->serialize (c->serializer,
                    + new_coverage.iter () | hb_map_retains_sorting (glyph_map)))
   {
     c->serializer->pop_discard ();
     return_trace (false);
   }

   unsigned coverage_idx = c->serializer->pop_pack ();
    c->serializer->add_link (out->coverage, coverage_idx);

   + hb_zip (this+coverage, ligatureSet)
   | hb_filter (new_coverage, hb_first)
   | hb_map (hb_second)
   // to ensure that the repacker always orders the coverage table after the LigatureSet
   // and LigatureSubtable's they will be linked to the Coverage table via a virtual link
   // the coverage table object idx is passed down to facilitate this.
   | hb_apply (subset_offset_array (c, out->ligatureSet, this, coverage_idx))
   ;

   return_trace (bool (new_coverage));
 }
};

}
}
}

#endif  /* OT_LAYOUT_GSUB_LIGATURESUBSTFORMAT1_HH */