Update harfbuzz-ng to 1a5a91dc0d8bf4b72a2f22dc6300b06ad7000b79.

third_party/harfbuzz-ng/src/hb-ot-layout-gsubgpos-private.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_GSUBGPOS_PRIVATE_HH
 #define HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH
 
 #include "hb-buffer-private.hh"
-#include "hb-ot-layout-gdef-private.hh"
-
-HB_BEGIN_DECLS
+#include "hb-ot-layout-gdef-table.hh"
 
 
 /* buffer var allocations */
-#define lig_id() var2.u16[0] /* unique ligature id */
-#define lig_comp() var2.u16[1] /* component number in the ligature (0 = base) */
+#define lig_id() var2.u8[2] /* unique ligature id */
+#define lig_comp() var2.u8[3] /* component number in the ligature (0 = base) */
+
+static inline uint8_t allocate_lig_id (hb_buffer_t *buffer) {
+  uint8_t lig_id = buffer->next_serial ();
+  if (unlikely (!lig_id)) lig_id = buffer->next_serial (); /* in case of overflow */
+  return lig_id;
+}
+
 
 
 #ifndef HB_DEBUG_APPLY
 #define HB_DEBUG_APPLY (HB_DEBUG+0)
 #endif
 
 #define TRACE_APPLY() \
-        hb_trace_t<HB_DEBUG_APPLY> trace (&c->debug_depth, "APPLY", HB_FUNC, this); \
+        hb_auto_trace_t<HB_DEBUG_APPLY> trace (&c->debug_depth, "APPLY", this, NULL, HB_FUNC);
 
 
-HB_BEGIN_DECLS
 
 struct hb_apply_context_t
 {
   unsigned int debug_depth;
-  hb_ot_layout_context_t *layout;
+  hb_font_t *font;
+  hb_face_t *face;
   hb_buffer_t *buffer;
+  hb_direction_t direction;
   hb_mask_t lookup_mask;
   unsigned int context_length;
   unsigned int nesting_level_left;
   unsigned int lookup_props;
   unsigned int property; /* propety of first glyph */
 
+  struct mark_skipping_forward_iterator_t
+  {
+    inline mark_skipping_forward_iterator_t (hb_apply_context_t *c_,
+                                             unsigned int start_index_,
+                                             unsigned int num_items_)
+    {
+      c = c_;
+      idx = start_index_;
+      num_items = num_items_;
+      end = MIN (c->buffer->len, c->buffer->idx + c->context_length);
+    }
+    inline bool has_no_chance (void) const
+    {
+      return unlikely (num_items && idx + num_items >= end);
+    }
+    inline bool next (unsigned int *property_out,
+                      unsigned int lookup_props)
+    {
+      assert (num_items > 0);
+      do
+      {
+        if (has_no_chance ())
+          return false;
+        idx++;
+      } while (_hb_ot_layout_skip_mark (c->face, &c->buffer->info[idx], lookup_props, property_out));
+      num_items--;
+      return true;
+    }
+    inline bool next (unsigned int *property_out = NULL)
+    {
+      return next (property_out, c->lookup_props);
+    }
+
+    unsigned int idx;
+    private:
+    hb_apply_context_t *c;
+    unsigned int num_items;
+    unsigned int end;
+  };
+
+  struct mark_skipping_backward_iterator_t
+  {
+    inline mark_skipping_backward_iterator_t (hb_apply_context_t *c_,
+                                              unsigned int start_index_,
+                                              unsigned int num_items_)
+    {
+      c = c_;
+      idx = start_index_;
+      num_items = num_items_;
+    }
+    inline bool has_no_chance (void) const
+    {
+      return unlikely (idx < num_items);
+    }
+    inline bool prev (unsigned int *property_out,
+                      unsigned int lookup_props)
+    {
+      assert (num_items > 0);
+      do
+      {
+        if (has_no_chance ())
+          return false;
+        idx--;
+      } while (_hb_ot_layout_skip_mark (c->face, &c->buffer->out_info[idx], lookup_props, property_out));
+      num_items--;
+      return true;
+    }
+    inline bool prev (unsigned int *property_out = NULL)
+    {
+      return prev (property_out, c->lookup_props);
+    }
+
+    unsigned int idx;
+    private:
+    hb_apply_context_t *c;
+    unsigned int num_items;
+  };
+
+  inline bool should_mark_skip_current_glyph (void) const
+  {
+    return _hb_ot_layout_skip_mark (face, &buffer->info[buffer->idx], lookup_props, NULL);
+  }
+
+
 
   inline void replace_glyph (hb_codepoint_t glyph_index) const
   {
     clear_property ();
     buffer->replace_glyph (glyph_index);
   }
   inline void replace_glyphs_be16 (unsigned int num_in,
                                    unsigned int num_out,
                                    const uint16_t *glyph_data_be) const
   {
     clear_property ();
     buffer->replace_glyphs_be16 (num_in, num_out, glyph_data_be);
   }
 
   inline void guess_glyph_class (unsigned int klass)
   {
     /* XXX if ! has gdef */
-    buffer->info[buffer->i].props_cache() = klass;
+    buffer->info[buffer->idx].props_cache() = klass;
   }
 
   private:
   inline void clear_property (void) const
   {
     /* XXX if has gdef */
-    buffer->info[buffer->i].props_cache() = 0;
+    buffer->info[buffer->idx].props_cache() = 0;
   }
 };
 
 
 
 typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
 typedef bool (*apply_lookup_func_t) (hb_apply_context_t *c, unsigned int lookup_index);
 
 struct ContextFuncs
 {
@@ skipping 20 matching lines @@
 }
 
 
 static inline bool match_input (hb_apply_context_t *c,
                                 unsigned int count, /* Including the first glyph (not matched) */
                                 const USHORT input[], /* Array of input values--start with second glyph */
                                 match_func_t match_func,
                                 const void *match_data,
                                 unsigned int *context_length_out)
 {
-  unsigned int i, j;
-  unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-  if (unlikely (c->buffer->i + count > end))
+  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;
 
-  for (i = 1, j = c->buffer->i + 1; i < count; i++, j++)
+  for (unsigned int i = 1; i < count; i++)
   {
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
-    {
-      if (unlikely (j + count - i == end))
-        return false;
-      j++;
-    }
+    if (!skippy_iter.next ())
+      return false;
 
-    if (likely (!match_func (c->buffer->info[j].codepoint, input[i - 1], match_data)))
+    if (likely (!match_func (c->buffer->info[skippy_iter.idx].codepoint, input[i - 1], match_data)))
       return false;
   }
 
-  *context_length_out = j - c->buffer->i;
+  *context_length_out = skippy_iter.idx - c->buffer->idx + 1;
 
   return true;
 }
 
 static inline bool match_backtrack (hb_apply_context_t *c,
                                     unsigned int count,
                                     const USHORT backtrack[],
                                     match_func_t match_func,
                                     const void *match_data)
 {
-  if (unlikely (c->buffer->out_len < count))
+  hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->backtrack_len (), count);
+  if (skippy_iter.has_no_chance ())
     return false;
 
-  for (unsigned int i = 0, j = c->buffer->out_len - 1; i < count; i++, j--)
+  for (unsigned int i = 0; i < count; i++)
   {
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->out_info[j], c->lookup_props, NULL))
-    {
-      if (unlikely (j + 1 == count - i))
-        return false;
-      j--;
-    }
+    if (!skippy_iter.prev ())
+      return false;
 
-    if (likely (!match_func (c->buffer->out_info[j].codepoint, backtrack[i], match_data)))
+    if (likely (!match_func (c->buffer->out_info[skippy_iter.idx].codepoint, backtrack[i], match_data)))
       return false;
   }
 
   return true;
 }
 
 static inline bool match_lookahead (hb_apply_context_t *c,
                                     unsigned int count,
                                     const USHORT lookahead[],
                                     match_func_t match_func,
                                     const void *match_data,
                                     unsigned int offset)
 {
-  unsigned int i, j;
-  unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-  if (unlikely (c->buffer->i + offset + count > end))
+  hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx + offset - 1, count);
+  if (skippy_iter.has_no_chance ())
     return false;
 
-  for (i = 0, j = c->buffer->i + offset; i < count; i++, j++)
+  for (unsigned int i = 0; i < count; i++)
   {
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
-    {
-      if (unlikely (j + count - i == end))
-        return false;
-      j++;
-    }
+    if (!skippy_iter.next ())
+      return false;
 
-    if (likely (!match_func (c->buffer->info[j].codepoint, lookahead[i], match_data)))
+    if (likely (!match_func (c->buffer->info[skippy_iter.idx].codepoint, lookahead[i], match_data)))
       return false;
   }
 
   return true;
 }
 
-HB_END_DECLS
 
 
 struct LookupRecord
 {
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     return c->check_struct (this);
   }
 
   USHORT        sequenceIndex;          /* Index into current glyph
                                          * sequence--first glyph = 0 */
   USHORT        lookupListIndex;        /* Lookup to apply to that
                                          * position--zero--based */
   public:
   DEFINE_SIZE_STATIC (4);
 };
 
 
-HB_BEGIN_DECLS
 
 static inline bool apply_lookup (hb_apply_context_t *c,
                                  unsigned int count, /* Including the first glyph */
                                  unsigned int lookupCount,
                                  const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
                                  apply_lookup_func_t apply_func)
 {
-  unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
-  if (unlikely (count == 0 || c->buffer->i + count > end))
+  unsigned int end = MIN (c->buffer->len, c->buffer->idx + c->context_length);
+  if (unlikely (count == 0 || c->buffer->idx + count > end))
     return false;
 
   /* TODO We don't support lookupRecord arrays that are not increasing:
    *      Should be easy for in_place ones at least. */
 
   /* Note: If sublookup is reverse, it will underflow after the first loop
    * and we jump out of it.  Not entirely disastrous.  So we don't check
    * for reverse lookup here.
    */
   for (unsigned int i = 0; i < count; /* NOP */)
   {
-    while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_props, NULL))
+    if (unlikely (c->buffer->idx == end))
+      return true;
+    while (c->should_mark_skip_current_glyph ())
     {
-      if (unlikely (c->buffer->i == end))
-        return true;
       /* No lookup applied for this index */
       c->buffer->next_glyph ();
+      if (unlikely (c->buffer->idx == end))
+        return true;
     }
 
     if (lookupCount && i == lookupRecord->sequenceIndex)
     {
-      unsigned int old_pos = c->buffer->i;
+      unsigned int old_pos = c->buffer->idx;
 
       /* Apply a lookup */
       bool done = apply_func (c, lookupRecord->lookupListIndex);
 
       lookupRecord++;
       lookupCount--;
       /* Err, this is wrong if the lookup jumped over some glyphs */
-      i += c->buffer->i - old_pos;
-      if (unlikely (c->buffer->i == end))
+      i += c->buffer->idx - old_pos;
+      if (unlikely (c->buffer->idx == end))
         return true;
 
       if (!done)
         goto not_applied;
     }
     else
     {
     not_applied:
       /* No lookup applied for this index */
       c->buffer->next_glyph ();
       i++;
     }
   }
 
   return true;
 }
 
-HB_END_DECLS
 
 
 /* Contextual lookups */
 
 struct ContextLookupContext
 {
   ContextFuncs funcs;
   const void *match_data;
 };
 
@@ skipping 83 matching lines @@
 
 
 struct ContextFormat1
 {
   friend struct Context;
 
   private:
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) 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;
 
     const RuleSet &rule_set = this+ruleSet[index];
     struct ContextLookupContext lookup_context = {
       {match_glyph, apply_func},
       NULL
     };
     return rule_set.apply (c, lookup_context);
   }
@@ skipping 18 matching lines @@
 
 
 struct ContextFormat2
 {
   friend struct Context;
 
   private:
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) 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;
 
     const ClassDef &class_def = this+classDef;
-    index = class_def (c->buffer->info[c->buffer->i].codepoint);
+    index = class_def (c->buffer->info[c->buffer->idx].codepoint);
     const RuleSet &rule_set = this+ruleSet[index];
     struct ContextLookupContext lookup_context = {
       {match_class, apply_func},
       &class_def
     };
     return rule_set.apply (c, lookup_context);
   }
 
   inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
@@ skipping 19 matching lines @@
 
 
 struct ContextFormat3
 {
   friend struct Context;
 
   private:
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
-    unsigned int index = (this+coverage[0]) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+coverage[0]) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
     const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * glyphCount);
     struct ContextLookupContext lookup_context = {
       {match_coverage, apply_func},
       this
     };
     return context_lookup (c,
                            glyphCount, (const USHORT *) (coverage + 1),
@@ skipping 74 matching lines @@
                                          const USHORT backtrack[],
                                          unsigned int inputCount, /* Including the first glyph (not matched) */
                                          const USHORT input[], /* Array of input values--start with second glyph */
                                          unsigned int lookaheadCount,
                                          const USHORT lookahead[],
                                          unsigned int lookupCount,
                                          const LookupRecord lookupRecord[],
                                          ChainContextLookupContext &lookup_context)
 {
   /* First guess */
-  if (unlikely (c->buffer->out_len < backtrackCount ||
-                c->buffer->i + inputCount + lookaheadCount > c->buffer->len ||
+  if (unlikely (c->buffer->backtrack_len () < backtrackCount ||
+                c->buffer->idx + inputCount + lookaheadCount > c->buffer->len ||
                 inputCount + lookaheadCount > c->context_length))
     return false;
 
   hb_apply_context_t new_context = *c;
   return match_backtrack (c,
                           backtrackCount, backtrack,
                           lookup_context.funcs.match, lookup_context.match_data[0])
       && match_input (c,
                       inputCount, input,
                       lookup_context.funcs.match, lookup_context.match_data[1],
@@ skipping 86 matching lines @@
 };
 
 struct ChainContextFormat1
 {
   friend struct ChainContext;
 
   private:
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) 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;
 
     const ChainRuleSet &rule_set = this+ruleSet[index];
     struct ChainContextLookupContext lookup_context = {
       {match_glyph, apply_func},
       {NULL, NULL, NULL}
     };
     return rule_set.apply (c, lookup_context);
   }
@@ skipping 17 matching lines @@
 };
 
 struct ChainContextFormat2
 {
   friend struct ChainContext;
 
   private:
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) 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;
 
     const ClassDef &backtrack_class_def = this+backtrackClassDef;
     const ClassDef &input_class_def = this+inputClassDef;
     const ClassDef &lookahead_class_def = this+lookaheadClassDef;
 
-    index = input_class_def (c->buffer->info[c->buffer->i].codepoint);
+    index = input_class_def (c->buffer->info[c->buffer->idx].codepoint);
     const ChainRuleSet &rule_set = this+ruleSet[index];
     struct ChainContextLookupContext lookup_context = {
       {match_class, apply_func},
       {&backtrack_class_def,
        &input_class_def,
        &lookahead_class_def}
     };
     return rule_set.apply (c, lookup_context);
   }
 
@@ skipping 34 matching lines @@
 {
   friend struct ChainContext;
 
   private:
 
   inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
 
-    unsigned int index = (this+input[0]) (c->buffer->info[c->buffer->i].codepoint);
+    unsigned int index = (this+input[0]) (c->buffer->info[c->buffer->idx].codepoint);
     if (likely (index == NOT_COVERED))
       return false;
 
     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
     const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
     struct ChainContextLookupContext lookup_context = {
       {match_coverage, apply_func},
       {this, this, this}
     };
     return chain_context_lookup (c,
@@ skipping 184 matching lines @@
                 scriptList;     /* ScriptList table */
   OffsetTo<FeatureList>
                 featureList;    /* FeatureList table */
   OffsetTo<LookupList>
                 lookupList;     /* LookupList table */
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
 
-HB_END_DECLS
 
 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */