Roll HarfBuzz to 1.1.1

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 56 matching lines @@
   }
 
   hb_face_t *face;
   hb_set_t *glyphs;
   recurse_func_t recurse_func;
   unsigned int nesting_level_left;
   unsigned int debug_depth;
 
   hb_closure_context_t (hb_face_t *face_,
                         hb_set_t *glyphs_,
-                        unsigned int nesting_level_left_ = MAX_NESTING_LEVEL) :
+                        unsigned int nesting_level_left_ = HB_MAX_NESTING_LEVEL) :
                           face (face_),
                           glyphs (glyphs_),
                           recurse_func (NULL),
                           nesting_level_left (nesting_level_left_),
                           debug_depth (0) {}
 
   void set_recurse_func (recurse_func_t func) { recurse_func = func; }
 };
 
 
@@ skipping 101 matching lines @@
   recurse_func_t recurse_func;
   hb_set_t recursed_lookups;
   unsigned int nesting_level_left;
   unsigned int debug_depth;
 
   hb_collect_glyphs_context_t (hb_face_t *face_,
                                hb_set_t  *glyphs_before, /* OUT. May be NULL */
                                hb_set_t  *glyphs_input,  /* OUT. May be NULL */
                                hb_set_t  *glyphs_after,  /* OUT. May be NULL */
                                hb_set_t  *glyphs_output, /* OUT. May be NULL */
-                               unsigned int nesting_level_left_ = MAX_NESTING_LEVEL) :
+                               unsigned int nesting_level_left_ = HB_MAX_NESTING_LEVEL) :
                               face (face_),
                               before (glyphs_before ? glyphs_before : hb_set_get_empty ()),
                               input  (glyphs_input  ? glyphs_input  : hb_set_get_empty ()),
                               after  (glyphs_after  ? glyphs_after  : hb_set_get_empty ()),
                               output (glyphs_output ? glyphs_output : hb_set_get_empty ()),
                               recurse_func (NULL),
                               recursed_lookups (),
                               nesting_level_left (nesting_level_left_),
                               debug_depth (0)
   {
@@ skipping 138 matching lines @@
       /* Ignore ZWNJ if we are matching GSUB context, or matching GPOS. */
       matcher.set_ignore_zwnj (context_match || c->table_index == 1);
       /* Ignore ZWJ if we are matching GSUB context, or matching GPOS, or if asked to. */
       matcher.set_ignore_zwj (context_match || c->table_index == 1 || c->auto_zwj);
       matcher.set_mask (context_match ? -1 : c->lookup_mask);
     }
     inline void set_lookup_props (unsigned int lookup_props)
     {
       matcher.set_lookup_props (lookup_props);
     }
-    inline void set_match_func (matcher_t::match_func_t match_func,
-                                const void *match_data,
+    inline void set_match_func (matcher_t::match_func_t match_func_,
+                                const void *match_data_,
                                 const USHORT glyph_data[])
     {
-      matcher.set_match_func (match_func, match_data);
+      matcher.set_match_func (match_func_, match_data_);
       match_glyph_data = glyph_data;
     }
 
     inline void reset (unsigned int start_index_,
                        unsigned int num_items_)
     {
       idx = start_index_;
       num_items = num_items_;
       end = c->buffer->len;
       matcher.set_syllable (start_index_ == c->buffer->idx ? c->buffer->cur().syllable () : 0);
@@ skipping 103 matching lines @@
 
   hb_apply_context_t (unsigned int table_index_,
                       hb_font_t *font_,
                       hb_buffer_t *buffer_) :
                         table_index (table_index_),
                         font (font_), face (font->face), buffer (buffer_),
                         direction (buffer_->props.direction),
                         lookup_mask (1),
                         auto_zwj (true),
                         recurse_func (NULL),
-                        nesting_level_left (MAX_NESTING_LEVEL),
+                        nesting_level_left (HB_MAX_NESTING_LEVEL),
                         lookup_props (0),
                         gdef (*hb_ot_layout_from_face (face)->gdef),
                         has_glyph_classes (gdef.has_glyph_classes ()),
                         iter_input (),
                         iter_context (),
                         lookup_index ((unsigned int) -1),
                         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_; }
@@ skipping 200 matching lines @@
       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,
-                                unsigned int match_positions[MAX_CONTEXT_LENGTH],
+                                unsigned int match_positions[HB_MAX_CONTEXT_LENGTH],
                                 bool *p_is_mark_ligature = NULL,
                                 unsigned int *p_total_component_count = NULL)
 {
   TRACE_APPLY (NULL);
 
-  if (unlikely (count > MAX_CONTEXT_LENGTH)) return_trace (false);
+  if (unlikely (count > HB_MAX_CONTEXT_LENGTH)) return_trace (false);
 
   hb_buffer_t *buffer = c->buffer;
 
   hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
   skippy_iter.reset (buffer->idx, count - 1);
   skippy_iter.set_match_func (match_func, match_data, input);
 
   /*
    * This is perhaps the trickiest part of OpenType...  Remarks:
    *
@@ skipping 53 matching lines @@
   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 (true);
 }
 static inline bool ligate_input (hb_apply_context_t *c,
                                  unsigned int count, /* Including the first glyph */
-                                 unsigned int match_positions[MAX_CONTEXT_LENGTH], /* Including the first glyph */
+                                 unsigned int match_positions[HB_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)
 {
   TRACE_APPLY (NULL);
 
   hb_buffer_t *buffer = c->buffer;
 
   buffer->merge_clusters (buffer->idx, buffer->idx + match_length);
@@ skipping 31 matching lines @@
   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)
   {
     _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++)
   {
-    while (buffer->idx < match_positions[i])
+    while (buffer->idx < match_positions[i] && !buffer->in_error)
     {
       if (!is_mark_ligature) {
         unsigned int new_lig_comp = components_so_far - last_num_components +
                                     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);
       }
       buffer->next_glyph ();
     }
 
     last_lig_id = _hb_glyph_info_get_lig_id (&buffer->cur());
@@ skipping 80 matching lines @@
 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[i].lookupListIndex);
 }
 
 static inline bool apply_lookup (hb_apply_context_t *c,
                                  unsigned int count, /* Including the first glyph */
-                                 unsigned int match_positions[MAX_CONTEXT_LENGTH], /* Including the first glyph */
+                                 unsigned int match_positions[HB_MAX_CONTEXT_LENGTH], /* Including the first glyph */
                                  unsigned int lookupCount,
                                  const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
                                  unsigned int match_length)
 {
   TRACE_APPLY (NULL);
 
   hb_buffer_t *buffer = c->buffer;
   unsigned int end;
 
   /* All positions are distance from beginning of *output* buffer.
    * Adjust. */
   {
     unsigned int bl = buffer->backtrack_len ();
     end = bl + match_length;
 
     int delta = bl - buffer->idx;
     /* Convert positions to new indexing. */
     for (unsigned int j = 0; j < count; j++)
       match_positions[j] += delta;
   }
 
   for (unsigned int i = 0; i < lookupCount; i++)
   {
     unsigned int idx = lookupRecord[i].sequenceIndex;
     if (idx >= count)
       continue;
 
+    /* Don't recurse to ourself at same position.
+     * Note that this test is too naive, it doesn't catch longer loops. */
+    if (idx == 0 && lookupRecord[i].lookupListIndex == c->lookup_index)
+      continue;
+
     buffer->move_to (match_positions[idx]);
 
     unsigned int orig_len = buffer->backtrack_len () + buffer->lookahead_len ();
     if (!c->recurse (lookupRecord[i].lookupListIndex))
       continue;
 
     unsigned int new_len = buffer->backtrack_len () + buffer->lookahead_len ();
     int delta = new_len - orig_len;
 
     if (!delta)
         continue;
 
     /* Recursed lookup changed buffer len.  Adjust. */
 
     /* end can't go back past the current match position.
      * Note: this is only true because we do NOT allow MultipleSubst
      * with zero sequence len. */
-    end = MAX ((int) match_positions[idx] + 1, int (end) + delta);
+    end = MAX (MIN((int) match_positions[idx] + 1, (int) new_len), int (end) + delta);
 
     unsigned int next = idx + 1; /* next now is the position after the recursed lookup. */
 
     if (delta > 0)
     {
-      if (unlikely (delta + count > MAX_CONTEXT_LENGTH))
+      if (unlikely (delta + count > HB_MAX_CONTEXT_LENGTH))
         break;
     }
     else
     {
       /* NOTE: delta is negative. */
       delta = MAX (delta, (int) next - (int) count);
       next -= delta;
     }
 
     /* Shift! */
@@ skipping 78 matching lines @@
                             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];
+  unsigned int match_positions[HB_MAX_CONTEXT_LENGTH];
   return match_input (c,
                       inputCount, input,
                       lookup_context.funcs.match, lookup_context.match_data,
                       &match_length, match_positions)
       && apply_lookup (c,
                        inputCount, match_positions,
                        lookupCount, lookupRecord,
                        match_length);
 }
 
@@ skipping 506 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[],
                                                ChainContextApplyLookupContext &lookup_context)
 {
   unsigned int match_length = 0;
-  unsigned int match_positions[MAX_CONTEXT_LENGTH];
+  unsigned int match_positions[HB_MAX_CONTEXT_LENGTH];
   return match_input (c,
                       inputCount, input,
                       lookup_context.funcs.match, lookup_context.match_data[1],
                       &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],
@@ skipping 642 matching lines @@
                 lookupList;     /* LookupList table */
   public:
   DEFINE_SIZE_STATIC (10);
 };
 
 
 } /* namespace OT */
 
 
 #endif /* HB_OT_LAYOUT_GSUBGPOS_PRIVATE_HH */