Update harfbuzz-ng to 0.9.24

third_party/harfbuzz-ng/src/hb-ot-layout-gsub-table.hh

 /*
  * Copyright © 2007,2008,2009,2010  Red Hat, Inc.
- * Copyright © 2010,2012  Google, Inc.
+ * Copyright © 2010,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 251 matching lines @@
     unsigned int count = substitute.len;
     for (unsigned int i = 0; i < count; i++)
       c->output->add (substitute[i]);
   }
 
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY (this);
     if (unlikely (!substitute.len)) return TRACE_RETURN (false);
 
-    unsigned int klass = c->buffer->cur().glyph_props() &
-                         HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE ? HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0;
+    unsigned int klass = _hb_glyph_info_is_ligature (&c->buffer->cur()) ?
+                         HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0;
     unsigned int count = substitute.len;
     if (count == 1) /* Special-case to make it in-place. */
     {
       c->replace_glyph (substitute.array[0]);
     }
     else
     {
       for (unsigned int i = 0; i < count; i++) {
-        set_lig_props_for_component (c->buffer->cur(), i);
+        _hb_glyph_info_set_lig_props_for_component (&c->buffer->cur(), i);
         c->output_glyph (substitute.array[i], klass);
       }
       c->buffer->skip_glyph ();
     }
 
     return TRACE_RETURN (true);
   }
 
   inline bool serialize (hb_serialize_context_t *c,
                          Supplier<GlyphID> &glyphs,
@@ skipping 323 matching lines @@
 
     return TRACE_RETURN (true);
   }
 
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY (this);
     unsigned int count = component.len;
     if (unlikely (count < 1)) return TRACE_RETURN (false);
 
-    unsigned int end_offset = 0;
     bool is_mark_ligature = false;
     unsigned int total_component_count = 0;
 
+    unsigned int match_length = 0;
+    unsigned int match_positions[MAX_CONTEXT_LENGTH];
+
     if (likely (!match_input (c, count,
                               &component[1],
                               match_glyph,
                               NULL,
-                              &end_offset,
+                              &match_length,
+                              match_positions,
                               &is_mark_ligature,
                               &total_component_count)))
       return TRACE_RETURN (false);
 
-    /* Deal, we are forming the ligature. */
-    c->buffer->merge_clusters (c->buffer->idx, c->buffer->idx + end_offset);
-
     ligate_input (c,
                   count,
-                  &component[1],
-                  match_glyph,
-                  NULL,
+                  match_positions,
+                  match_length,
                   ligGlyph,
                   is_mark_ligature,
                   total_component_count);
 
     return TRACE_RETURN (true);
   }
 
   inline bool serialize (hb_serialize_context_t *c,
                          GlyphID ligature,
                          Supplier<GlyphID> &components, /* Starting from second */
@@ skipping 322 matching lines @@
 
     if (match_backtrack (c,
                          backtrack.len, (USHORT *) backtrack.array,
                          match_coverage, this) &&
         match_lookahead (c,
                          lookahead.len, (USHORT *) lookahead.array,
                          match_coverage, this,
                          1))
     {
       c->replace_glyph_inplace (substitute[index]);
-      c->buffer->idx--; /* Reverse! */
+      /* 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_RETURN (true);
     }
 
     return TRACE_RETURN (false);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE (this);
     if (!(coverage.sanitize (c, this) && backtrack.sanitize (c, this)))
       return TRACE_RETURN (false);
@@ skipping 142 matching lines @@
     return lookup_type_is_reverse (type);
   }
 
   inline hb_closure_context_t::return_t closure (hb_closure_context_t *c) const
   {
     TRACE_CLOSURE (this);
     c->set_recurse_func (dispatch_recurse_func<hb_closure_context_t>);
     return TRACE_RETURN (dispatch (c));
   }
 
-  inline hb_collect_glyphs_context_t::return_t collect_glyphs_lookup (hb_collect_glyphs_context_t *c) const
+  inline 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>);
     return TRACE_RETURN (dispatch (c));
   }
 
   template <typename set_t>
   inline void add_coverage (set_t *glyphs) const
   {
     hb_get_coverage_context_t c;
@@ skipping 18 matching lines @@
 
   inline bool apply_once (hb_apply_context_t *c) const
   {
     TRACE_APPLY (this);
     if (!c->check_glyph_property (&c->buffer->cur(), c->lookup_props))
       return TRACE_RETURN (false);
     return TRACE_RETURN (dispatch (c));
   }
 
   static bool apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index);
-  inline bool apply_string (hb_apply_context_t *c, const hb_set_digest_t *digest) const
-  {
-    bool ret = false;
-
-    if (unlikely (!c->buffer->len || !c->lookup_mask))
-      return false;
-
-    c->set_recurse_func (apply_recurse_func);
-    c->set_lookup (*this);
-
-    if (likely (!is_reverse ()))
-    {
-      /* in/out forward substitution */
-      c->buffer->clear_output ();
-      c->buffer->idx = 0;
-
-      while (c->buffer->idx < c->buffer->len)
-      {
-        if (digest->may_have (c->buffer->cur().codepoint) &&
-            (c->buffer->cur().mask & c->lookup_mask) &&
-            apply_once (c))
-          ret = true;
-        else
-          c->buffer->next_glyph ();
-      }
-      if (ret)
-        c->buffer->swap_buffers ();
-    }
-    else
-    {
-      /* in-place backward substitution */
-      c->buffer->remove_output ();
-      c->buffer->idx = c->buffer->len - 1;
-      do
-      {
-        if (digest->may_have (c->buffer->cur().codepoint) &&
-            (c->buffer->cur().mask & c->lookup_mask) &&
-            apply_once (c))
-          ret = true;
-        else
-          c->buffer->idx--;
-
-      }
-      while ((int) c->buffer->idx >= 0);
-    }
-
-    return ret;
-  }
 
   inline SubstLookupSubTable& serialize_subtable (hb_serialize_context_t *c,
                                                   unsigned int i)
   { return CastR<OffsetArrayOf<SubstLookupSubTable> > (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)
@@ skipping 84 matching lines @@
 };
 
 typedef OffsetListOf<SubstLookup> SubstLookupList;
 
 /*
  * GSUB -- The Glyph Substitution Table
  */
 
 struct GSUB : GSUBGPOS
 {
-  static const hb_tag_t Tag     = HB_OT_TAG_GSUB;
+  static const hb_tag_t tableTag        = HB_OT_TAG_GSUB;
 
   inline const SubstLookup& get_lookup (unsigned int i) const
   { return CastR<SubstLookup> (GSUBGPOS::get_lookup (i)); }
 
   static inline void substitute_start (hb_font_t *font, hb_buffer_t *buffer);
   static inline void substitute_finish (hb_font_t *font, hb_buffer_t *buffer);
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE (this);
     if (unlikely (!GSUBGPOS::sanitize (c))) return TRACE_RETURN (false);
     OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
     return TRACE_RETURN (list.sanitize (c, this));
   }
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
 
 void
 GSUB::substitute_start (hb_font_t *font, hb_buffer_t *buffer)
 {
-  HB_BUFFER_ALLOCATE_VAR (buffer, glyph_props);
-  HB_BUFFER_ALLOCATE_VAR (buffer, lig_props);
-  HB_BUFFER_ALLOCATE_VAR (buffer, syllable);
+  _hb_buffer_allocate_gsubgpos_vars (buffer);
 
   const GDEF &gdef = *hb_ot_layout_from_face (font->face)->gdef;
   unsigned int count = buffer->len;
-  for (unsigned int i = 0; i < count; i++) {
-    buffer->info[i].lig_props() = buffer->info[i].syllable() = 0;
-    buffer->info[i].glyph_props() = gdef.get_glyph_props (buffer->info[i].codepoint);
+  for (unsigned int i = 0; i < count; i++)
+  {
+    _hb_glyph_info_set_glyph_props (&buffer->info[i], gdef.get_glyph_props (buffer->info[i].codepoint));
+    _hb_glyph_info_clear_lig_props (&buffer->info[i]);
+    buffer->info[i].syllable() = 0;
   }
 }
 
 void
 GSUB::substitute_finish (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)
 {
 }
 
 
 /* Out-of-class implementation for methods recursing */
@@ skipping 23 matching lines @@
   bool ret = l.apply_once (c);
   c->lookup_props = saved_lookup_props;
   return ret;
 }
 
 
 } /* namespace OT */
 
 
 #endif /* HB_OT_LAYOUT_GSUB_TABLE_HH */