Update harfbuzz-ng to 0.9.24

third_party/harfbuzz-ng/src/hb-ot-layout-gsubgpos-private.hh

 /*
  * Copyright © 2007,2008,2009,2010  Red Hat, Inc.
  * Copyright © 2010,2012  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
@@ skipping 25 matching lines @@
 
 namespace OT {
 
 
 
 #define TRACE_DISPATCH(this) \
         hb_auto_trace_t<context_t::max_debug_depth, typename context_t::return_t> trace \
         (&c->debug_depth, c->get_name (), this, HB_FUNC, \
          "");
 
-
 #ifndef HB_DEBUG_CLOSURE
 #define HB_DEBUG_CLOSURE (HB_DEBUG+0)
 #endif
 
 #define TRACE_CLOSURE(this) \
         hb_auto_trace_t<HB_DEBUG_CLOSURE, hb_void_t> trace \
         (&c->debug_depth, c->get_name (), this, HB_FUNC, \
          "");
 
 struct hb_closure_context_t
@@ skipping 94 matching lines @@
   inline return_t dispatch (const T &obj) { obj.collect_glyphs (this); return HB_VOID; }
   static return_t default_return_value (void) { return HB_VOID; }
   bool stop_sublookup_iteration (return_t r HB_UNUSED) const { return false; }
   return_t recurse (unsigned int lookup_index)
   {
     if (unlikely (nesting_level_left == 0 || !recurse_func))
       return default_return_value ();
 
     /* Note that GPOS sets recurse_func to NULL already, so it doesn't get
      * past the previous check.  For GSUB, we only want to collect the output
-     * glyphs in the recursion.  If output is not requested, we can go home now. */
+     * glyphs in the recursion.  If output is not requested, we can go home now.
+     *
+     * Note further, that the above is not exactly correct.  A recursed lookup
+     * is allowed to match input that is not matched in the context, but that's
+     * not how most fonts are built.  It's possible to relax that and recurse
+     * with all sets here if it proves to be an issue.
+     */
 
     if (output == hb_set_get_empty ())
       return HB_VOID;
 
     hb_set_t *old_before = before;
     hb_set_t *old_input  = input;
     hb_set_t *old_after  = after;
     before = input = after = hb_set_get_empty ();
 
     nesting_level_left--;
@@ skipping 93 matching lines @@
   recurse_func_t recurse_func;
   unsigned int nesting_level_left;
   unsigned int lookup_props;
   const GDEF &gdef;
   bool has_glyph_classes;
   unsigned int debug_depth;
 
 
   hb_apply_context_t (unsigned int table_index_,
                       hb_font_t *font_,
-                      hb_buffer_t *buffer_,
-                      hb_mask_t lookup_mask_,
-                      bool auto_zwj_) :
+                      hb_buffer_t *buffer_) :
                         table_index (table_index_),
                         font (font_), face (font->face), buffer (buffer_),
                         direction (buffer_->props.direction),
-                        lookup_mask (lookup_mask_),
-                        auto_zwj (auto_zwj_),
+                        lookup_mask (1),
+                        auto_zwj (true),
                         recurse_func (NULL),
                         nesting_level_left (MAX_NESTING_LEVEL),
                         lookup_props (0),
                         gdef (*hb_ot_layout_from_face (face)->gdef),
                         has_glyph_classes (gdef.has_glyph_classes ()),
                         debug_depth (0) {}
 
+  inline void set_lookup_mask (hb_mask_t mask) { lookup_mask = mask; }
+  inline void set_auto_zwj (bool auto_zwj_) { auto_zwj = auto_zwj_; }
   inline void set_recurse_func (recurse_func_t func) { recurse_func = func; }
   inline void set_lookup_props (unsigned int lookup_props_) { lookup_props = lookup_props_; }
   inline void set_lookup (const Lookup &l) { lookup_props = l.get_props (); }
 
   struct matcher_t
   {
     inline matcher_t (void) :
              lookup_props (0),
              ignore_zwnj (false),
              ignore_zwj (false),
@@ skipping 39 matching lines @@
       SKIP_YES,
       SKIP_MAYBE
     };
 
     inline may_skip_t
     may_skip (const hb_apply_context_t *c,
               const hb_glyph_info_t    &info) const
     {
       unsigned int property;
 
-      property = info.glyph_props();
+      property = _hb_glyph_info_get_glyph_props (&info);
 
       if (!c->match_properties (info.codepoint, property, lookup_props))
         return SKIP_YES;
 
       if (unlikely (_hb_glyph_info_is_default_ignorable (&info) &&
                     (ignore_zwnj || !_hb_glyph_info_is_zwnj (&info)) &&
                     (ignore_zwj || !_hb_glyph_info_is_zwj (&info)) &&
-                    !is_a_ligature (info)))
+                    !_hb_glyph_info_ligated (&info)))
         return SKIP_MAYBE;
 
       return SKIP_NO;
     }
 
     protected:
     unsigned int lookup_props;
     bool ignore_zwnj;
     bool ignore_zwj;
     hb_mask_t mask;
@@ skipping 180 matching lines @@
 
     return true;
   }
 
   inline bool
   check_glyph_property (hb_glyph_info_t *info,
                         unsigned int  lookup_props) const
   {
     unsigned int property;
 
-    property = info->glyph_props();
+    property = _hb_glyph_info_get_glyph_props (info);
 
     return match_properties (info->codepoint, property, lookup_props);
   }
 
-  inline void set_class (hb_codepoint_t glyph_index, unsigned int class_guess) const
+  inline void _set_glyph_props (hb_codepoint_t glyph_index,
+                          unsigned int class_guess = 0,
+                          bool ligature = false) const
   {
+    unsigned int add_in = _hb_glyph_info_get_glyph_props (&buffer->cur()) &
+                          HB_OT_LAYOUT_GLYPH_PROPS_PRESERVE;
+    add_in |= HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED;
+    if (ligature)
+      add_in |= HB_OT_LAYOUT_GLYPH_PROPS_LIGATED;
     if (likely (has_glyph_classes))
-      buffer->cur().glyph_props() = gdef.get_glyph_props (glyph_index);
+      _hb_glyph_info_set_glyph_props (&buffer->cur(), add_in | gdef.get_glyph_props (glyph_index));
     else if (class_guess)
-      buffer->cur().glyph_props() = class_guess;
+      _hb_glyph_info_set_glyph_props (&buffer->cur(), add_in | class_guess);
   }
 
-  inline void output_glyph (hb_codepoint_t glyph_index,
-                            unsigned int class_guess = 0) const
+  inline void replace_glyph (hb_codepoint_t glyph_index) const
   {
-    set_class (glyph_index, class_guess);
-    buffer->output_glyph (glyph_index);
-  }
-  inline void replace_glyph (hb_codepoint_t glyph_index,
-                             unsigned int class_guess = 0) const
-  {
-    set_class (glyph_index, class_guess);
+    _set_glyph_props (glyph_index);
     buffer->replace_glyph (glyph_index);
   }
-  inline void replace_glyph_inplace (hb_codepoint_t glyph_index,
-                                     unsigned int class_guess = 0) const
+  inline void replace_glyph_inplace (hb_codepoint_t glyph_index) const
   {
-    set_class (glyph_index, class_guess);
+    _set_glyph_props (glyph_index);
     buffer->cur().codepoint = glyph_index;
   }
+  inline void replace_glyph_with_ligature (hb_codepoint_t glyph_index,
+                                           unsigned int class_guess) const
+  {
+    _set_glyph_props (glyph_index, class_guess, true);
+    buffer->replace_glyph (glyph_index);
+  }
+  inline void output_glyph (hb_codepoint_t glyph_index,
+                            unsigned int class_guess) const
+  {
+    _set_glyph_props (glyph_index, class_guess);
+    buffer->output_glyph (glyph_index);
+  }
 };
 
 
 
 typedef bool (*intersects_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
 typedef void (*collect_glyphs_func_t) (hb_set_t *glyphs, const USHORT &value, const void *data);
 typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
 
 struct ContextClosureFuncs
 {
@@ skipping 91 matching lines @@
     if (likely (!match_func (c->glyphs[i], input[i - 1], match_data)))
       return false;
 
   return true;
 }
 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 *end_offset = NULL,
+                                unsigned int *end_offset,
+                                unsigned int match_positions[MAX_CONTEXT_LENGTH],
                                 bool *p_is_mark_ligature = NULL,
                                 unsigned int *p_total_component_count = NULL)
 {
   TRACE_APPLY (NULL);
 
-  hb_apply_context_t::skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, count - 1);
+  if (unlikely (count > MAX_CONTEXT_LENGTH)) TRACE_RETURN (false);
+
+  hb_buffer_t *buffer = c->buffer;
+
+  hb_apply_context_t::skipping_forward_iterator_t skippy_iter (c, buffer->idx, count - 1);
   skippy_iter.set_match_func (match_func, match_data, input);
   if (skippy_iter.has_no_chance ()) return TRACE_RETURN (false);
 
   /*
    * This is perhaps the trickiest part of OpenType...  Remarks:
    *
    * - If all components of the ligature were marks, we call this a mark ligature.
    *
    * - If there is no GDEF, and the ligature is NOT a mark ligature, we categorize
    *   it as a ligature glyph.
    *
    * - Ligatures cannot be formed across glyphs attached to different components
    *   of previous ligatures.  Eg. the sequence is LAM,SHADDA,LAM,FATHA,HEH, and
    *   LAM,LAM,HEH form a ligature, leaving SHADDA,FATHA next to eachother.
    *   However, it would be wrong to ligate that SHADDA,FATHA sequence.o
    *   There is an exception to this: If a ligature tries ligating with marks that
    *   belong to it itself, go ahead, assuming that the font designer knows what
    *   they are doing (otherwise it can break Indic stuff when a matra wants to
    *   ligate with a conjunct...)
    */
 
-  bool is_mark_ligature = !!(c->buffer->cur().glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_MARK);
+  bool is_mark_ligature = _hb_glyph_info_is_mark (&buffer->cur());
 
   unsigned int total_component_count = 0;
-  total_component_count += get_lig_num_comps (c->buffer->cur());
+  total_component_count += _hb_glyph_info_get_lig_num_comps (&buffer->cur());
 
-  unsigned int first_lig_id = get_lig_id (c->buffer->cur());
-  unsigned int first_lig_comp = get_lig_comp (c->buffer->cur());
+  unsigned int first_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
+  unsigned int first_lig_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
 
+  match_positions[0] = buffer->idx;
   for (unsigned int i = 1; i < count; i++)
   {
     if (!skippy_iter.next ()) return TRACE_RETURN (false);
 
-    unsigned int this_lig_id = get_lig_id (c->buffer->info[skippy_iter.idx]);
-    unsigned int this_lig_comp = get_lig_comp (c->buffer->info[skippy_iter.idx]);
+    match_positions[i] = skippy_iter.idx;
+
+    unsigned int this_lig_id = _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx]);
+    unsigned int this_lig_comp = _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]);
 
     if (first_lig_id && first_lig_comp) {
       /* If first component was attached to a previous ligature component,
        * all subsequent components should be attached to the same ligature
        * component, otherwise we shouldn't ligate them. */
       if (first_lig_id != this_lig_id || first_lig_comp != this_lig_comp)
         return TRACE_RETURN (false);
     } else {
       /* If first component was NOT attached to a previous ligature component,
        * all subsequent components should also NOT be attached to any ligature
        * component, unless they are attached to the first component itself! */
       if (this_lig_id && this_lig_comp && (this_lig_id != first_lig_id))
         return TRACE_RETURN (false);
     }
 
-    is_mark_ligature = is_mark_ligature && (c->buffer->info[skippy_iter.idx].glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_MARK);
-    total_component_count += get_lig_num_comps (c->buffer->info[skippy_iter.idx]);
+    is_mark_ligature = is_mark_ligature && _hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx]);
+    total_component_count += _hb_glyph_info_get_lig_num_comps (&buffer->info[skippy_iter.idx]);
   }
 
-  if (end_offset)
-    *end_offset = skippy_iter.idx - c->buffer->idx + 1;
+  *end_offset = skippy_iter.idx - buffer->idx + 1;
 
   if (p_is_mark_ligature)
     *p_is_mark_ligature = is_mark_ligature;
 
   if (p_total_component_count)
     *p_total_component_count = total_component_count;
 
   return TRACE_RETURN (true);
 }
 static inline void ligate_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 count, /* Including the first glyph */
+                                 unsigned int match_positions[MAX_CONTEXT_LENGTH], /* Including the first glyph */
+                                 unsigned int match_length,
                                  hb_codepoint_t lig_glyph,
                                  bool is_mark_ligature,
                                  unsigned int total_component_count)
 {
-  hb_apply_context_t::skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, count - 1);
-  skippy_iter.set_match_func (match_func, match_data, input);
-  if (skippy_iter.has_no_chance ()) return;
+  TRACE_APPLY (NULL);
+
+  hb_buffer_t *buffer = c->buffer;
+
+  buffer->merge_clusters (buffer->idx, buffer->idx + match_length);
 
   /*
    * - If it *is* a mark ligature, we don't allocate a new ligature id, and leave
    *   the ligature to keep its old ligature id.  This will allow it to attach to
    *   a base ligature in GPOS.  Eg. if the sequence is: LAM,LAM,SHADDA,FATHA,HEH,
    *   and LAM,LAM,HEH for a ligature, they will leave SHADDA and FATHA wit a
    *   ligature id and component value of 2.  Then if SHADDA,FATHA form a ligature
    *   later, we don't want them to lose their ligature id/component, otherwise
    *   GPOS will fail to correctly position the mark ligature on top of the
    *   LAM,LAM,HEH ligature.  See:
@@ skipping 10 matching lines @@
    *   'calt' ligature of LAM,HEH, leaving the SHADDA and FATHA with a ligature
    *   id and component == 1.  Now, during 'liga', the LAM and the LAM-HEH ligature
    *   form a LAM-LAM-HEH ligature.  We need to reassign the SHADDA and FATHA to
    *   the new ligature with a component value of 2.
    *
    *   This in fact happened to a font...  See:
    *   https://bugzilla.gnome.org/show_bug.cgi?id=437633
    */
 
   unsigned int klass = is_mark_ligature ? 0 : HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE;
-  unsigned int lig_id = is_mark_ligature ? 0 : allocate_lig_id (c->buffer);
-  unsigned int last_lig_id = get_lig_id (c->buffer->cur());
-  unsigned int last_num_components = get_lig_num_comps (c->buffer->cur());
+  unsigned int lig_id = is_mark_ligature ? 0 : _hb_allocate_lig_id (buffer);
+  unsigned int last_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
+  unsigned int last_num_components = _hb_glyph_info_get_lig_num_comps (&buffer->cur());
   unsigned int components_so_far = last_num_components;
 
   if (!is_mark_ligature)
-    set_lig_props_for_ligature (c->buffer->cur(), lig_id, total_component_count);
-  c->replace_glyph (lig_glyph, klass);
+  {
+    _hb_glyph_info_set_lig_props_for_ligature (&buffer->cur(), lig_id, total_component_count);
+    if (_hb_glyph_info_get_general_category (&buffer->cur()) == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)
+    {
+      _hb_glyph_info_set_general_category (&buffer->cur(), HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER);
+      _hb_glyph_info_set_modified_combining_class (&buffer->cur(), 0);
+    }
+  }
+  c->replace_glyph_with_ligature (lig_glyph, klass);
 
   for (unsigned int i = 1; i < count; i++)
   {
-    if (!skippy_iter.next ()) return;
-
-    while (c->buffer->idx < skippy_iter.idx)
+    while (buffer->idx < match_positions[i])
     {
       if (!is_mark_ligature) {
         unsigned int new_lig_comp = components_so_far - last_num_components +
-                                    MIN (MAX (get_lig_comp (c->buffer->cur()), 1u), last_num_components);
-        set_lig_props_for_mark (c->buffer->cur(), lig_id, new_lig_comp);
+                                    MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->cur()), 1u), last_num_components);
+        _hb_glyph_info_set_lig_props_for_mark (&buffer->cur(), lig_id, new_lig_comp);
       }
-      c->buffer->next_glyph ();
+      buffer->next_glyph ();
     }
 
-    last_lig_id = get_lig_id (c->buffer->cur());
-    last_num_components = get_lig_num_comps (c->buffer->cur());
+    last_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
+    last_num_components = _hb_glyph_info_get_lig_num_comps (&buffer->cur());
     components_so_far += last_num_components;
 
     /* Skip the base glyph */
-    c->buffer->idx++;
+    buffer->idx++;
   }
 
   if (!is_mark_ligature && last_lig_id) {
     /* Re-adjust components for any marks following. */
-    for (unsigned int i = c->buffer->idx; i < c->buffer->len; i++) {
-      if (last_lig_id == get_lig_id (c->buffer->info[i])) {
+    for (unsigned int i = buffer->idx; i < buffer->len; i++) {
+      if (last_lig_id == _hb_glyph_info_get_lig_id (&buffer->info[i])) {
         unsigned int new_lig_comp = components_so_far - last_num_components +
-                                    MIN (MAX (get_lig_comp (c->buffer->info[i]), 1u), last_num_components);
-        set_lig_props_for_mark (c->buffer->info[i], lig_id, new_lig_comp);
+                                    MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->info[i]), 1u), last_num_components);
+        _hb_glyph_info_set_lig_props_for_mark (&buffer->info[i], lig_id, new_lig_comp);
       } else
         break;
     }
   }
 }
 
 static inline bool match_backtrack (hb_apply_context_t *c,
                                     unsigned int count,
                                     const USHORT backtrack[],
                                     match_func_t match_func,
@@ skipping 49 matching lines @@
   DEFINE_SIZE_STATIC (4);
 };
 
 
 template <typename context_t>
 static inline void recurse_lookups (context_t *c,
                                     unsigned int lookupCount,
                                     const LookupRecord lookupRecord[] /* Array of LookupRecords--in design order */)
 {
   for (unsigned int i = 0; i < lookupCount; i++)
-    c->recurse (lookupRecord->lookupListIndex);
+    c->recurse (lookupRecord[i].lookupListIndex);
 }
 
 static inline bool apply_lookup (hb_apply_context_t *c,
                                  unsigned int count, /* Including the first glyph */
-                                 const USHORT input[], /* Array of input values--start with second glyph */
-                                 match_func_t match_func,
-                                 const void *match_data,
+                                 unsigned int match_positions[MAX_CONTEXT_LENGTH], /* Including the first glyph */
                                  unsigned int lookupCount,
-                                 const LookupRecord lookupRecord[] /* Array of LookupRecords--in design order */)
+                                 const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
+                                 unsigned int match_length)
 {
   TRACE_APPLY (NULL);
 
-  unsigned int end = c->buffer->len;
-  if (unlikely (count == 0 || c->buffer->idx + count > end))
-    return TRACE_RETURN (false);
+  hb_buffer_t *buffer = c->buffer;
+  unsigned int end;
 
-  /* TODO We don't support lookupRecord arrays that are not increasing:
-   *      Should be easy for in_place ones at least. */
+  /* All positions are distance from beginning of *output* buffer.
+   * Adjust. */
+  {
+    unsigned int bl = buffer->backtrack_len ();
+    end = bl + match_length;
 
-  /* 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.
-   */
+    int delta = bl - buffer->idx;
+    /* Convert positions to new indexing. */
+    for (unsigned int j = 0; j < count; j++)
+      match_positions[j] += delta;
+  }
 
-  hb_apply_context_t::skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, count - 1);
-  skippy_iter.set_match_func (match_func, match_data, input);
-  uint8_t syllable = c->buffer->cur().syllable();
+  for (unsigned int i = 0; i < lookupCount; i++)
+  {
+    unsigned int idx = lookupRecord[i].sequenceIndex;
+    if (idx >= count)
+      continue;
 
-  unsigned int i = 0;
-  if (lookupCount && 0 == lookupRecord->sequenceIndex)
-  {
-    unsigned int old_pos = c->buffer->idx;
+    buffer->move_to (match_positions[idx]);
 
-    /* Apply a lookup */
-    bool done = c->recurse (lookupRecord->lookupListIndex);
+    unsigned int orig_len = buffer->backtrack_len () + buffer->lookahead_len ();
+    if (!c->recurse (lookupRecord[i].lookupListIndex))
+      continue;
 
-    lookupRecord++;
-    lookupCount--;
-    /* Err, this is wrong if the lookup jumped over some glyphs */
-    i += c->buffer->idx - old_pos;
+    unsigned int new_len = buffer->backtrack_len () + buffer->lookahead_len ();
+    int delta = new_len - orig_len;
 
-    if (!done)
-      goto not_applied;
-    else
+    if (!delta)
+        continue;
+
+    /* Recursed lookup changed buffer len.  Adjust. */
+
+    /* end can't go back past the current match position. */
+    end = MAX ((int) match_positions[idx] + 1, int (end) + delta);
+
+    unsigned int next = idx + 1; /* next now is the position after the recursed lookup. */
+
+    if (delta > 0)
     {
-      /* Reinitialize iterator. */
-      hb_apply_context_t::skipping_forward_iterator_t tmp (c, c->buffer->idx - 1, count - i);
-      tmp.set_syllable (syllable);
-      skippy_iter = tmp;
-    }
-  }
-  else
-  {
-  not_applied:
-    /* No lookup applied for this index */
-    c->buffer->next_glyph ();
-    i++;
-  }
-  while (i < count)
-  {
-    if (!skippy_iter.next ()) return TRACE_RETURN (true);
-    while (c->buffer->idx < skippy_iter.idx)
-      c->buffer->next_glyph ();
-
-    if (lookupCount && i == lookupRecord->sequenceIndex)
-    {
-      unsigned int old_pos = c->buffer->idx;
-
-      /* Apply a lookup */
-      bool done = c->recurse (lookupRecord->lookupListIndex);
-
-      lookupRecord++;
-      lookupCount--;
-      /* Err, this is wrong if the lookup jumped over some glyphs */
-      i += c->buffer->idx - old_pos;
-
-      if (!done)
-        goto not_applied2;
-      else
-      {
-        /* Reinitialize iterator. */
-        hb_apply_context_t::skipping_forward_iterator_t tmp (c, c->buffer->idx - 1, count - i);
-        tmp.set_syllable (syllable);
-        skippy_iter = tmp;
-      }
+      if (unlikely (delta + count > MAX_CONTEXT_LENGTH))
+        break;
     }
     else
     {
-    not_applied2:
-      /* No lookup applied for this index */
-      c->buffer->next_glyph ();
-      i++;
+      /* NOTE: delta is negative. */
+      delta = MAX (delta, (int) next - (int) count);
+      next -= delta;
     }
+
+    /* Shift! */
+    memmove (match_positions + next + delta, match_positions + next,
+             (count - next) * sizeof (match_positions[0]));
+    next += delta;
+    count += delta;
+
+    /* Fill in new entries. */
+    for (unsigned int j = idx + 1; j < next; j++)
+      match_positions[j] = match_positions[j - 1] + 1;
+
+    /* And fixup the rest. */
+    for (; next < count; next++)
+      match_positions[next] += delta;
   }
 
+  buffer->move_to (end);
+
   return TRACE_RETURN (true);
 }
 
 
 
 /* Contextual lookups */
 
 struct ContextClosureLookupContext
 {
   ContextClosureFuncs funcs;
@@ skipping 51 matching lines @@
                             inputCount, input,
                             lookup_context.funcs.match, lookup_context.match_data);
 }
 static inline bool context_apply_lookup (hb_apply_context_t *c,
                                          unsigned int inputCount, /* Including the first glyph (not matched) */
                                          const USHORT input[], /* Array of input values--start with second glyph */
                                          unsigned int lookupCount,
                                          const LookupRecord lookupRecord[],
                                          ContextApplyLookupContext &lookup_context)
 {
+  unsigned int match_length = 0;
+  unsigned int match_positions[MAX_CONTEXT_LENGTH];
   return match_input (c,
                       inputCount, input,
-                      lookup_context.funcs.match, lookup_context.match_data)
+                      lookup_context.funcs.match, lookup_context.match_data,
+                      &match_length, match_positions)
       && apply_lookup (c,
-                       inputCount, input,
-                       lookup_context.funcs.match, lookup_context.match_data,
-                       lookupCount, lookupRecord);
+                       inputCount, match_positions,
+                       lookupCount, lookupRecord,
+                       match_length);
 }
 
 struct Rule
 {
   inline void closure (hb_closure_context_t *c, ContextClosureLookupContext &lookup_context) const
   {
     TRACE_CLOSURE (this);
     const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
     context_closure_lookup (c,
                             inputCount, input,
@@ skipping 442 matching lines @@
                                                  unsigned int lookupCount,
                                                  const LookupRecord lookupRecord[],
                                                  ChainContextClosureLookupContext &lookup_context)
 {
   if (intersects_array (c,
                         backtrackCount, backtrack,
                         lookup_context.funcs.intersects, lookup_context.intersects_data[0])
    && intersects_array (c,
                         inputCount ? inputCount - 1 : 0, input,
                         lookup_context.funcs.intersects, lookup_context.intersects_data[1])
-  && intersects_array (c,
+   && intersects_array (c,
                        lookaheadCount, lookahead,
                        lookup_context.funcs.intersects, lookup_context.intersects_data[2]))
     recurse_lookups (c,
                      lookupCount, lookupRecord);
 }
 
 static inline void chain_context_collect_glyphs_lookup (hb_collect_glyphs_context_t *c,
                                                         unsigned int backtrackCount,
                                                         const USHORT backtrack[],
                                                         unsigned int inputCount, /* Including the first glyph (not matched) */
@@ skipping 38 matching lines @@
                                                unsigned int backtrackCount,
                                                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[],
                                                ChainContextApplyLookupContext &lookup_context)
 {
-  unsigned int lookahead_offset = 0;
+  unsigned int match_length = 0;
+  unsigned int match_positions[MAX_CONTEXT_LENGTH];
   return match_input (c,
                       inputCount, input,
                       lookup_context.funcs.match, lookup_context.match_data[1],
-                      &lookahead_offset)
+                      &match_length, match_positions)
       && match_backtrack (c,
                           backtrackCount, backtrack,
                           lookup_context.funcs.match, lookup_context.match_data[0])
       && match_lookahead (c,
                           lookaheadCount, lookahead,
                           lookup_context.funcs.match, lookup_context.match_data[2],
-                          lookahead_offset)
+                          match_length)
       && apply_lookup (c,
-                       inputCount, input,
-                       lookup_context.funcs.match, lookup_context.match_data[1],
-                       lookupCount, lookupRecord);
+                       inputCount, match_positions,
+                       lookupCount, lookupRecord,
+                       match_length);
 }
 
 struct ChainRule
 {
   inline void closure (hb_closure_context_t *c, ChainContextClosureLookupContext &lookup_context) const
   {
     TRACE_CLOSURE (this);
     const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
     const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
     const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
@@ skipping 628 matching lines @@
                 lookupList;     /* LookupList table */
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
 
 } /* namespace OT */
 
 
 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */