Update harfbuzz-ng to 0.9.24

third_party/harfbuzz-ng/src/hb-ot-layout.cc

 /*
  * Copyright © 1998-2004  David Turner and Werner Lemberg
  * Copyright © 2006  Behdad Esfahbod
  * Copyright © 2007,2008,2009  Red Hat, Inc.
- * Copyright © 2012  Google, Inc.
+ * Copyright © 2012,2013  Google, Inc.
  *
  *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
  * software and its documentation for any purpose, provided that the
  * above copyright notice and the following two paragraphs appear in
  * all copies of this software.
  *
  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
@@ skipping 10 matching lines @@
  *
  * Red Hat Author(s): Behdad Esfahbod
  * Google Author(s): Behdad Esfahbod
  */
 
 #include "hb-ot-layout-private.hh"
 
 #include "hb-ot-layout-gdef-table.hh"
 #include "hb-ot-layout-gsub-table.hh"
 #include "hb-ot-layout-gpos-table.hh"
+#include "hb-ot-layout-jstf-table.hh"
+
+#include "hb-ot-map-private.hh"
 
 #include <stdlib.h>
 #include <string.h>
 
 
 HB_SHAPER_DATA_ENSURE_DECLARE(ot, face)
 
 hb_ot_layout_t *
 _hb_ot_layout_create (hb_face_t *face)
 {
   hb_ot_layout_t *layout = (hb_ot_layout_t *) calloc (1, sizeof (hb_ot_layout_t));
   if (unlikely (!layout))
     return NULL;
 
   layout->gdef_blob = OT::Sanitizer<OT::GDEF>::sanitize (face->reference_table (HB_OT_TAG_GDEF));
   layout->gdef = OT::Sanitizer<OT::GDEF>::lock_instance (layout->gdef_blob);
 
   layout->gsub_blob = OT::Sanitizer<OT::GSUB>::sanitize (face->reference_table (HB_OT_TAG_GSUB));
   layout->gsub = OT::Sanitizer<OT::GSUB>::lock_instance (layout->gsub_blob);
 
   layout->gpos_blob = OT::Sanitizer<OT::GPOS>::sanitize (face->reference_table (HB_OT_TAG_GPOS));
   layout->gpos = OT::Sanitizer<OT::GPOS>::lock_instance (layout->gpos_blob);
 
   layout->gsub_lookup_count = layout->gsub->get_lookup_count ();
   layout->gpos_lookup_count = layout->gpos->get_lookup_count ();
 
-  layout->gsub_digests = (hb_set_digest_t *) calloc (layout->gsub->get_lookup_count (), sizeof (hb_set_digest_t));
-  layout->gpos_digests = (hb_set_digest_t *) calloc (layout->gpos->get_lookup_count (), sizeof (hb_set_digest_t));
+  layout->gsub_accels = (hb_ot_layout_lookup_accelerator_t *) calloc (layout->gsub->get_lookup_count (), sizeof (hb_ot_layout_lookup_accelerator_t));
+  layout->gpos_accels = (hb_ot_layout_lookup_accelerator_t *) calloc (layout->gpos->get_lookup_count (), sizeof (hb_ot_layout_lookup_accelerator_t));
 
-  if (unlikely ((layout->gsub_lookup_count && !layout->gsub_digests) ||
-                (layout->gpos_lookup_count && !layout->gpos_digests)))
+  if (unlikely ((layout->gsub_lookup_count && !layout->gsub_accels) ||
+                (layout->gpos_lookup_count && !layout->gpos_accels)))
   {
     _hb_ot_layout_destroy (layout);
     return NULL;
   }
 
   for (unsigned int i = 0; i < layout->gsub_lookup_count; i++)
-  {
-    layout->gsub_digests[i].init ();
-    layout->gsub->get_lookup (i).add_coverage (&layout->gsub_digests[i]);
-  }
+    layout->gsub_accels[i].init (layout->gsub->get_lookup (i));
   for (unsigned int i = 0; i < layout->gpos_lookup_count; i++)
-  {
-    layout->gpos_digests[i].init ();
-    layout->gpos->get_lookup (i).add_coverage (&layout->gpos_digests[i]);
-  }
+    layout->gpos_accels[i].init (layout->gpos->get_lookup (i));
 
   return layout;
 }
 
 void
 _hb_ot_layout_destroy (hb_ot_layout_t *layout)
 {
+  for (unsigned int i = 0; i < layout->gsub_lookup_count; i++)
+    layout->gsub_accels[i].fini (layout->gsub->get_lookup (i));
+  for (unsigned int i = 0; i < layout->gpos_lookup_count; i++)
+    layout->gpos_accels[i].fini (layout->gpos->get_lookup (i));
+
+  free (layout->gsub_accels);
+  free (layout->gpos_accels);
+
   hb_blob_destroy (layout->gdef_blob);
   hb_blob_destroy (layout->gsub_blob);
   hb_blob_destroy (layout->gpos_blob);
 
-  free (layout->gsub_digests);
-  free (layout->gpos_digests);
-
   free (layout);
 }
 
 static inline const OT::GDEF&
 _get_gdef (hb_face_t *face)
 {
   if (unlikely (!hb_ot_shaper_face_data_ensure (face))) return OT::Null(OT::GDEF);
   return *hb_ot_layout_from_face (face)->gdef;
 }
 static inline const OT::GSUB&
@@ skipping 299 matching lines @@
                                   unsigned int  start_offset,
                                   unsigned int *lookup_count /* IN/OUT */,
                                   unsigned int *lookup_indexes /* OUT */)
 {
   const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
   const OT::Feature &f = g.get_feature (feature_index);
 
   return f.get_lookup_indexes (start_offset, lookup_count, lookup_indexes);
 }
 
+unsigned int
+hb_ot_layout_table_get_lookup_count (hb_face_t    *face,
+                                     hb_tag_t      table_tag)
+{
+  switch (table_tag)
+  {
+    case HB_OT_TAG_GSUB:
+    {
+      return hb_ot_layout_from_face (face)->gsub_lookup_count;
+    }
+    case HB_OT_TAG_GPOS:
+    {
+      return hb_ot_layout_from_face (face)->gpos_lookup_count;
+    }
+  }
+  return 0;
+}
+
 static void
 _hb_ot_layout_collect_lookups_lookups (hb_face_t      *face,
                                        hb_tag_t        table_tag,
                                        unsigned int    feature_index,
                                        hb_set_t       *lookup_indexes /* OUT */)
 {
   unsigned int lookup_indices[32];
   unsigned int offset, len;
 
   offset = 0;
@@ skipping 13 matching lines @@
 }
 
 static void
 _hb_ot_layout_collect_lookups_features (hb_face_t      *face,
                                         hb_tag_t        table_tag,
                                         unsigned int    script_index,
                                         unsigned int    language_index,
                                         const hb_tag_t *features,
                                         hb_set_t       *lookup_indexes /* OUT */)
 {
-  unsigned int required_feature_index;
-  if (hb_ot_layout_language_get_required_feature_index (face,
-                                                        table_tag,
-                                                        script_index,
-                                                        language_index,
-                                                        &required_feature_index))
-    _hb_ot_layout_collect_lookups_lookups (face,
-                                           table_tag,
-                                           required_feature_index,
-                                           lookup_indexes);
-
   if (!features)
   {
+    unsigned int required_feature_index;
+    if (hb_ot_layout_language_get_required_feature_index (face,
+                                                          table_tag,
+                                                          script_index,
+                                                          language_index,
+                                                          &required_feature_index))
+      _hb_ot_layout_collect_lookups_lookups (face,
+                                             table_tag,
+                                             required_feature_index,
+                                             lookup_indexes);
+
     /* All features */
     unsigned int feature_indices[32];
     unsigned int offset, len;
 
     offset = 0;
     do {
       len = ARRAY_LENGTH (feature_indices);
       hb_ot_layout_language_get_feature_indexes (face,
                                                  table_tag,
                                                  script_index,
@@ skipping 135 matching lines @@
                                      glyphs_before,
                                      glyphs_input,
                                      glyphs_after,
                                      glyphs_output);
 
   switch (table_tag)
   {
     case HB_OT_TAG_GSUB:
     {
       const OT::SubstLookup& l = hb_ot_layout_from_face (face)->gsub->get_lookup (lookup_index);
-      l.collect_glyphs_lookup (&c);
+      l.collect_glyphs (&c);
       return;
     }
     case HB_OT_TAG_GPOS:
     {
       const OT::PosLookup& l = hb_ot_layout_from_face (face)->gpos->get_lookup (lookup_index);
-      l.collect_glyphs_lookup (&c);
+      l.collect_glyphs (&c);
       return;
     }
   }
 }
 
 
 /*
  * OT::GSUB
  */
 
@@ skipping 19 matching lines @@
                                            unsigned int          lookup_index,
                                            const hb_codepoint_t *glyphs,
                                            unsigned int          glyphs_length,
                                            hb_bool_t             zero_context)
 {
   if (unlikely (lookup_index >= hb_ot_layout_from_face (face)->gsub_lookup_count)) return false;
   OT::hb_would_apply_context_t c (face, glyphs, glyphs_length, zero_context);
 
   const OT::SubstLookup& l = hb_ot_layout_from_face (face)->gsub->get_lookup (lookup_index);
 
-  return l.would_apply (&c, &hb_ot_layout_from_face (face)->gsub_digests[lookup_index]);
+  return l.would_apply (&c, &hb_ot_layout_from_face (face)->gsub_accels[lookup_index].digest);
 }
 
 void
 hb_ot_layout_substitute_start (hb_font_t *font, hb_buffer_t *buffer)
 {
   OT::GSUB::substitute_start (font, buffer);
 }
 
-hb_bool_t
-hb_ot_layout_substitute_lookup (hb_font_t    *font,
-                                hb_buffer_t  *buffer,
-                                unsigned int  lookup_index,
-                                hb_mask_t     mask,
-                                hb_bool_t     auto_zwj)
-{
-  if (unlikely (lookup_index >= hb_ot_layout_from_face (font->face)->gsub_lookup_count)) return false;
-
-  OT::hb_apply_context_t c (0, font, buffer, mask, auto_zwj);
-
-  const OT::SubstLookup& l = hb_ot_layout_from_face (font->face)->gsub->get_lookup (lookup_index);
-
-  return l.apply_string (&c, &hb_ot_layout_from_face (font->face)->gsub_digests[lookup_index]);
-}
-
 void
 hb_ot_layout_substitute_finish (hb_font_t *font, hb_buffer_t *buffer)
 {
   OT::GSUB::substitute_finish (font, buffer);
 }
 
 void
 hb_ot_layout_lookup_substitute_closure (hb_face_t    *face,
                                         unsigned int  lookup_index,
                                         hb_set_t     *glyphs)
@@ skipping 14 matching lines @@
 {
   return &_get_gpos (face) != &OT::Null(OT::GPOS);
 }
 
 void
 hb_ot_layout_position_start (hb_font_t *font, hb_buffer_t *buffer)
 {
   OT::GPOS::position_start (font, buffer);
 }
 
-hb_bool_t
-hb_ot_layout_position_lookup (hb_font_t    *font,
-                              hb_buffer_t  *buffer,
-                              unsigned int  lookup_index,
-                              hb_mask_t     mask,
-                              hb_bool_t     auto_zwj)
-{
-  if (unlikely (lookup_index >= hb_ot_layout_from_face (font->face)->gpos_lookup_count)) return false;
-
-  OT::hb_apply_context_t c (1, font, buffer, mask, auto_zwj);
-
-  const OT::PosLookup& l = hb_ot_layout_from_face (font->face)->gpos->get_lookup (lookup_index);
-
-  return l.apply_string (&c, &hb_ot_layout_from_face (font->face)->gpos_digests[lookup_index]);
-}
-
 void
 hb_ot_layout_position_finish (hb_font_t *font, hb_buffer_t *buffer)
 {
   OT::GPOS::position_finish (font, buffer);
 }
 
 hb_bool_t
 hb_ot_layout_get_size_params (hb_face_t    *face,
                               unsigned int *design_size,       /* OUT.  May be NULL */
                               unsigned int *subfamily_id,      /* OUT.  May be NULL */
@@ skipping 30 matching lines @@
 #define PARAM(a, A) if (a) *a = 0
   PARAM (design_size, designSize);
   PARAM (subfamily_id, subfamilyID);
   PARAM (subfamily_name_id, subfamilyNameID);
   PARAM (range_start, rangeStart);
   PARAM (range_end, rangeEnd);
 #undef PARAM
 
   return false;
 }
+
+
+/*
+ * Parts of different types are implemented here such that they have direct
+ * access to GSUB/GPOS lookups.
+ */
+
+
+struct GSUBProxy
+{
+  static const unsigned int table_index = 0;
+  static const bool inplace = false;
+  typedef OT::SubstLookup Lookup;
+
+  GSUBProxy (hb_face_t *face) :
+    table (*hb_ot_layout_from_face (face)->gsub),
+    accels (hb_ot_layout_from_face (face)->gsub_accels) {}
+
+  const OT::GSUB &table;
+  const hb_ot_layout_lookup_accelerator_t *accels;
+};
+
+struct GPOSProxy
+{
+  static const unsigned int table_index = 1;
+  static const bool inplace = true;
+  typedef OT::PosLookup Lookup;
+
+  GPOSProxy (hb_face_t *face) :
+    table (*hb_ot_layout_from_face (face)->gpos),
+    accels (hb_ot_layout_from_face (face)->gpos_accels) {}
+
+  const OT::GPOS &table;
+  const hb_ot_layout_lookup_accelerator_t *accels;
+};
+
+
+template <typename Lookup>
+static inline bool apply_once (OT::hb_apply_context_t *c,
+                               const Lookup &lookup)
+{
+  if (!c->check_glyph_property (&c->buffer->cur(), c->lookup_props))
+    return false;
+  return lookup.dispatch (c);
+}
+
+template <typename Proxy>
+static inline bool
+apply_string (OT::hb_apply_context_t *c,
+              const typename Proxy::Lookup &lookup,
+              const hb_ot_layout_lookup_accelerator_t &accel)
+{
+  bool ret = false;
+  hb_buffer_t *buffer = c->buffer;
+
+  if (unlikely (!buffer->len || !c->lookup_mask))
+    return false;
+
+  c->set_lookup (lookup);
+
+  if (likely (!lookup.is_reverse ()))
+  {
+    /* in/out forward substitution/positioning */
+    if (Proxy::table_index == 0)
+      buffer->clear_output ();
+    buffer->idx = 0;
+
+    while (buffer->idx < buffer->len)
+    {
+      if (accel.digest.may_have (buffer->cur().codepoint) &&
+          (buffer->cur().mask & c->lookup_mask) &&
+          apply_once (c, lookup))
+        ret = true;
+      else
+        buffer->next_glyph ();
+    }
+    if (ret)
+    {
+      if (!Proxy::inplace)
+        buffer->swap_buffers ();
+      else
+        assert (!buffer->has_separate_output ());
+    }
+  }
+  else
+  {
+    /* in-place backward substitution/positioning */
+    if (Proxy::table_index == 0)
+      buffer->remove_output ();
+    buffer->idx = buffer->len - 1;
+    do
+    {
+      if (accel.digest.may_have (buffer->cur().codepoint) &&
+          (buffer->cur().mask & c->lookup_mask) &&
+          apply_once (c, lookup))
+        ret = true;
+      /* The reverse lookup doesn't "advance" cursor (for good reason). */
+      buffer->idx--;
+
+    }
+    while ((int) buffer->idx >= 0);
+  }
+
+  return ret;
+}
+
+template <typename Proxy>
+inline void hb_ot_map_t::apply (const Proxy &proxy,
+                                const hb_ot_shape_plan_t *plan,
+                                hb_font_t *font,
+                                hb_buffer_t *buffer) const
+{
+  const unsigned int table_index = proxy.table_index;
+  unsigned int i = 0;
+  OT::hb_apply_context_t c (table_index, font, buffer);
+  c.set_recurse_func (Proxy::Lookup::apply_recurse_func);
+
+  for (unsigned int stage_index = 0; stage_index < stages[table_index].len; stage_index++) {
+    const stage_map_t *stage = &stages[table_index][stage_index];
+    for (; i < stage->last_lookup; i++)
+    {
+      unsigned int lookup_index = lookups[table_index][i].index;
+      c.set_lookup_mask (lookups[table_index][i].mask);
+      c.set_auto_zwj (lookups[table_index][i].auto_zwj);
+      apply_string<Proxy> (&c,
+                           proxy.table.get_lookup (lookup_index),
+                           proxy.accels[lookup_index]);
+    }
+
+    if (stage->pause_func)
+    {
+      buffer->clear_output ();
+      stage->pause_func (plan, font, buffer);
+    }
+  }
+}
+
+void hb_ot_map_t::substitute (const hb_ot_shape_plan_t *plan, hb_font_t *font, hb_buffer_t *buffer) const
+{
+  GSUBProxy proxy (font->face);
+  apply (proxy, plan, font, buffer);
+}
+
+void hb_ot_map_t::position (const hb_ot_shape_plan_t *plan, hb_font_t *font, hb_buffer_t *buffer) const
+{
+  GPOSProxy proxy (font->face);
+  apply (proxy, plan, font, buffer);
+}
+
+HB_INTERNAL void
+hb_ot_layout_substitute_lookup (OT::hb_apply_context_t *c,
+                                const OT::SubstLookup &lookup,
+                                const hb_ot_layout_lookup_accelerator_t &accel)
+{
+  apply_string<GSUBProxy> (c, lookup, accel);
+}