Update harfbuzz-ng to 1a5a91dc0d8bf4b72a2f22dc6300b06ad7000b79.

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

 /*
- * Copyright (C) 2007,2008,2009,2010  Red Hat, Inc.
- * Copyright (C) 2010  Google, Inc.
+ * Copyright © 2007,2008,2009,2010  Red Hat, Inc.
+ * Copyright © 2010  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
  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  *
  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  *
  * Red Hat Author(s): Behdad Esfahbod
  * Google Author(s): Behdad Esfahbod
  */
 
-#ifndef HB_OT_LAYOUT_GSUB_PRIVATE_HH
-#define HB_OT_LAYOUT_GSUB_PRIVATE_HH
+#ifndef HB_OT_LAYOUT_GSUB_TABLE_HH
+#define HB_OT_LAYOUT_GSUB_TABLE_HH
 
 #include "hb-ot-layout-gsubgpos-private.hh"
 
-HB_BEGIN_DECLS
 
 
 struct SingleSubstFormat1
 {
   friend struct SingleSubst;
 
   private:
 
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->idx].codepoint;
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
 
-    glyph_id += deltaGlyphID;
+    /* According to the Adobe Annotated OpenType Suite, result is always
+     * limited to 16bit. */
+    glyph_id = (glyph_id + deltaGlyphID) & 0xFFFF;
     c->replace_glyph (glyph_id);
 
     return true;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return coverage.sanitize (c, this)
         && deltaGlyphID.sanitize (c);
   }
@@ skipping 11 matching lines @@
 
 struct SingleSubstFormat2
 {
   friend struct SingleSubst;
 
   private:
 
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->idx].codepoint;
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
 
     if (unlikely (index >= substitute.len))
       return false;
 
     glyph_id = substitute[index];
     c->replace_glyph (glyph_id);
 
@@ skipping 87 matching lines @@
 struct MultipleSubstFormat1
 {
   friend struct MultipleSubst;
 
   private:
 
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
     return (this+sequence[index]).apply (c);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return coverage.sanitize (c, this)
         && sequence.sanitize (c, this);
@@ skipping 48 matching lines @@
 
 struct AlternateSubstFormat1
 {
   friend struct AlternateSubst;
 
   private:
 
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
-    hb_mask_t glyph_mask = c->buffer->info[c->buffer->i].mask;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->idx].codepoint;
+    hb_mask_t glyph_mask = c->buffer->info[c->buffer->idx].mask;
     hb_mask_t lookup_mask = c->lookup_mask;
 
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
 
     const AlternateSet &alt_set = this+alternateSet[index];
 
     if (unlikely (!alt_set.len))
       return false;
@@ skipping 63 matching lines @@
 
 
 struct Ligature
 {
   friend struct LigatureSet;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int i, j;
     unsigned int count = component.len;
-    unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-    if (unlikely (count < 2 || c->buffer->i + count > end))
+    if (unlikely (count < 2))
+      return false;
+
+    hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, count - 1);
+    if (skippy_iter.has_no_chance ())
       return false;
 
     bool first_was_mark = (c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK);
     bool found_non_mark = false;
 
-    for (i = 1, j = c->buffer->i + 1; i < count; i++, j++)
+    for (unsigned int i = 1; i < count; i++)
     {
       unsigned int property;
-      while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, &property))
-      {
-        if (unlikely (j + count - i == end))
-          return false;
-        j++;
-      }
+
+      if (!skippy_iter.next (&property))
+        return false;
 
       found_non_mark |= !(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK);
 
-      if (likely (c->buffer->info[j].codepoint != component[i]))
+      if (likely (c->buffer->info[skippy_iter.idx].codepoint != component[i]))
         return false;
     }
 
     if (first_was_mark && found_non_mark)
       c->guess_glyph_class (HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE);
 
     /* Allocate new ligature id */
     unsigned int lig_id = allocate_lig_id (c->buffer);
-    c->buffer->info[c->buffer->i].lig_comp() = 0;
-    c->buffer->info[c->buffer->i].lig_id() = lig_id;
+    c->buffer->info[c->buffer->idx].lig_comp() = 0;
+    c->buffer->info[c->buffer->idx].lig_id() = lig_id;
 
-    if (j == c->buffer->i + i) /* No input glyphs skipped */
+    if (skippy_iter.idx < c->buffer->idx + count) /* No input glyphs skipped */
     {
-      c->replace_glyphs_be16 (i, 1, (const uint16_t *) &ligGlyph);
+      c->replace_glyphs_be16 (count, 1, (const uint16_t *) &ligGlyph);
     }
     else
     {
       c->replace_glyph (ligGlyph);
 
       /* Now we must do a second loop to copy the skipped glyphs to
          `out' and assign component values to it.  We start with the
          glyph after the first component.  Glyphs between component
          i and i+1 belong to component i.  Together with the lig_id
          value it is later possible to check whether a specific
          component value really belongs to a given ligature. */
 
-      for (i = 1; i < count; i++)
+      for (unsigned int i = 1; i < count; i++)
       {
-        while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_props, NULL))
+        while (c->should_mark_skip_current_glyph ())
         {
-          c->buffer->info[c->buffer->i].lig_comp() = i;
-          c->buffer->info[c->buffer->i].lig_id() = lig_id;
-          c->replace_glyph (c->buffer->info[c->buffer->i].codepoint);
+          c->buffer->info[c->buffer->idx].lig_comp() = i;
+          c->buffer->info[c->buffer->idx].lig_id() = lig_id;
+          c->replace_glyph (c->buffer->info[c->buffer->idx].codepoint);
         }
 
         /* Skip the base glyph */
-        c->buffer->i++;
+        c->buffer->idx++;
       }
     }
 
     return true;
   }
 
-  inline uint16_t allocate_lig_id (hb_buffer_t *buffer) const {
-    uint16_t lig_id = buffer->next_serial ();
-    if (unlikely (!lig_id)) lig_id = buffer->next_serial (); /* in case of overflows */
-    return lig_id;
-  }
-
   public:
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return ligGlyph.sanitize (c)
         && component.sanitize (c);
   }
 
   private:
   GlyphID       ligGlyph;               /* GlyphID of ligature to substitute */
   HeadlessArrayOf<GlyphID>
@@ skipping 38 matching lines @@
 };
 
 struct LigatureSubstFormat1
 {
   friend struct LigatureSubst;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->i].codepoint;
+    hb_codepoint_t glyph_id = c->buffer->info[c->buffer->idx].codepoint;
 
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
 
     const LigatureSet &lig_set = this+ligatureSet[index];
     return lig_set.apply (c);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
@@ skipping 38 matching lines @@
   }
 
   private:
   union {
   USHORT                format;         /* Format identifier */
   LigatureSubstFormat1  format1;
   } u;
 };
 
 
-HB_BEGIN_DECLS
 static inline bool substitute_lookup (hb_apply_context_t *c, unsigned int lookup_index);
-HB_END_DECLS
 
 struct ContextSubst : Context
 {
   friend struct SubstLookupSubTable;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     return Context::apply (c, substitute_lookup);
@@ skipping 38 matching lines @@
 {
   friend struct ReverseChainSingleSubst;
 
   private:
   inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     if (unlikely (c->context_length != NO_CONTEXT))
       return false; /* No chaining to this type */
 
-    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
     const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
 
     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->buffer->info[c->buffer->i].codepoint = substitute[index];
-      c->buffer->i--; /* Reverse! */
+      c->buffer->info[c->buffer->idx].codepoint = substitute[index];
+      c->buffer->idx--; /* Reverse! */
       return true;
     }
 
     return false;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (!(coverage.sanitize (c, this)
        && backtrack.sanitize (c, this)))
@@ skipping 134 matching lines @@
 
   inline bool is_reverse (void) const
   {
     unsigned int type = get_type ();
     if (unlikely (type == SubstLookupSubTable::Extension))
       return CastR<ExtensionSubst> (get_subtable(0)).is_reverse ();
     return lookup_type_is_reverse (type);
   }
 
 
-  inline bool apply_once (hb_ot_layout_context_t *layout,
+  inline bool apply_once (hb_face_t *face,
                           hb_buffer_t *buffer,
                           hb_mask_t lookup_mask,
                           unsigned int context_length,
                           unsigned int nesting_level_left) const
   {
     unsigned int lookup_type = get_type ();
     hb_apply_context_t c[1] = {{0}};
 
-    c->layout = layout;
+    c->face = face;
     c->buffer = buffer;
+    c->direction = buffer->props.direction;
     c->lookup_mask = lookup_mask;
     c->context_length = context_length;
     c->nesting_level_left = nesting_level_left;
     c->lookup_props = get_props ();
 
-    if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_props, &c->property))
+    if (!_hb_ot_layout_check_glyph_property (c->face, &c->buffer->info[c->buffer->idx], c->lookup_props, &c->property))
       return false;
 
     if (unlikely (lookup_type == SubstLookupSubTable::Extension))
     {
       /* The spec says all subtables should have the same type.
        * This is specially important if one has a reverse type!
        *
        * This is rather slow to do this here for every glyph,
        * but it's easiest, and who uses extension lookups anyway?!*/
       unsigned int count = get_subtable_count ();
       unsigned int type = get_subtable(0).u.extension.get_type ();
       for (unsigned int i = 1; i < count; i++)
         if (get_subtable(i).u.extension.get_type () != type)
           return false;
     }
 
     unsigned int count = get_subtable_count ();
     for (unsigned int i = 0; i < count; i++)
       if (get_subtable (i).apply (c, lookup_type))
         return true;
 
     return false;
   }
 
-  inline bool apply_string (hb_ot_layout_context_t *layout,
+  inline bool apply_string (hb_face_t   *face,
                             hb_buffer_t *buffer,
                             hb_mask_t    mask) const
   {
     bool ret = false;
 
     if (unlikely (!buffer->len))
       return false;
 
     if (likely (!is_reverse ()))
     {
         /* in/out forward substitution */
         buffer->clear_output ();
-        buffer->i = 0;
-        while (buffer->i < buffer->len)
+        buffer->idx = 0;
+        while (buffer->idx < buffer->len)
         {
-          if ((buffer->info[buffer->i].mask & mask) &&
-              apply_once (layout, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
+          if ((buffer->info[buffer->idx].mask & mask) &&
+              apply_once (face, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
             ret = true;
           else
             buffer->next_glyph ();
 
         }
         if (ret)
-          buffer->swap ();
+          buffer->swap_buffers ();
     }
     else
     {
         /* in-place backward substitution */
-        buffer->i = buffer->len - 1;
+        buffer->idx = buffer->len - 1;
         do
         {
-          if ((buffer->info[buffer->i].mask & mask) &&
-              apply_once (layout, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
+          if ((buffer->info[buffer->idx].mask & mask) &&
+              apply_once (face, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
             ret = true;
           else
-            buffer->i--;
+            buffer->idx--;
 
         }
-        while ((int) buffer->i >= 0);
+        while ((int) buffer->idx >= 0);
     }
 
     return ret;
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (unlikely (!Lookup::sanitize (c))) return false;
     OffsetArrayOf<SubstLookupSubTable> &list = CastR<OffsetArrayOf<SubstLookupSubTable> > (subTable);
     return list.sanitize (c, this, get_type ());
   }
 };
 
 typedef OffsetListOf<SubstLookup> SubstLookupList;
 
 /*
- * GSUB
+ * GSUB -- The Glyph Substitution Table
  */
 
 struct GSUB : GSUBGPOS
 {
   static const hb_tag_t Tag     = HB_OT_TAG_GSUB;
 
   inline const SubstLookup& get_lookup (unsigned int i) const
   { return CastR<SubstLookup> (GSUBGPOS::get_lookup (i)); }
 
-  inline bool substitute_lookup (hb_ot_layout_context_t *layout,
+  inline bool substitute_lookup (hb_face_t    *face,
                                  hb_buffer_t  *buffer,
                                  unsigned int  lookup_index,
                                  hb_mask_t     mask) const
-  { return get_lookup (lookup_index).apply_string (layout, buffer, mask); }
+  { return get_lookup (lookup_index).apply_string (face, buffer, mask); }
+
+  static inline void substitute_start (hb_buffer_t *buffer);
+  static inline void substitute_finish (hb_buffer_t *buffer);
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     if (unlikely (!GSUBGPOS::sanitize (c))) return false;
     OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
     return list.sanitize (c, this);
   }
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
 
+void
+GSUB::substitute_start (hb_buffer_t *buffer)
+{
+  HB_BUFFER_ALLOCATE_VAR (buffer, props_cache);
+  HB_BUFFER_ALLOCATE_VAR (buffer, lig_id);
+  HB_BUFFER_ALLOCATE_VAR (buffer, lig_comp);
+
+  unsigned int count = buffer->len;
+  for (unsigned int i = 0; i < count; i++)
+    buffer->info[i].props_cache() = buffer->info[i].lig_id() = buffer->info[i].lig_comp() = 0;
+}
+
+void
+GSUB::substitute_finish (hb_buffer_t *buffer)
+{
+}
+
+
 /* Out-of-class implementation for methods recursing */
 
 inline bool ExtensionSubst::apply (hb_apply_context_t *c) const
 {
   TRACE_APPLY ();
   return get_subtable ().apply (c, get_type ());
 }
 
 inline bool ExtensionSubst::sanitize (hb_sanitize_context_t *c)
 {
   TRACE_SANITIZE ();
   if (unlikely (!Extension::sanitize (c))) return false;
   unsigned int offset = get_offset ();
   if (unlikely (!offset)) return true;
   return StructAtOffset<SubstLookupSubTable> (this, offset).sanitize (c, get_type ());
 }
 
 inline bool ExtensionSubst::is_reverse (void) const
 {
   unsigned int type = get_type ();
   if (unlikely (type == SubstLookupSubTable::Extension))
     return CastR<ExtensionSubst> (get_subtable()).is_reverse ();
   return SubstLookup::lookup_type_is_reverse (type);
 }
 
 static inline bool substitute_lookup (hb_apply_context_t *c, unsigned int lookup_index)
 {
-  const GSUB &gsub = *(c->layout->face->ot_layout->gsub);
+  const GSUB &gsub = *(c->face->ot_layout->gsub);
   const SubstLookup &l = gsub.get_lookup (lookup_index);
 
   if (unlikely (c->nesting_level_left == 0))
     return false;
 
   if (unlikely (c->context_length < 1))
     return false;
 
-  return l.apply_once (c->layout, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1);
+  return l.apply_once (c->face, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1);
 }
 
 
-HB_END_DECLS
 
-#endif /* HB_OT_LAYOUT_GSUB_PRIVATE_HH */
+#endif /* HB_OT_LAYOUT_GSUB_TABLE_HH */