Roll HarfBuzz to 1.1.3

third_party/harfbuzz-ng/src/hb-ot-shape-complex-use.cc

 /*
  * Copyright © 2015  Mozilla Foundation.
  * Copyright © 2015  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 267 matching lines @@
     unsigned int limit = info[start].use_category() == USE_R ? 1 : MIN (3u, end - start);
     for (unsigned int i = start; i < start + limit; i++)
       info[i].mask |= mask;
   }
 }
 
 static void
 setup_topographical_masks (const hb_ot_shape_plan_t *plan,
                            hb_buffer_t *buffer)
 {
+  const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data;
+  if (use_plan->arabic_plan)
+    return;
 
   ASSERT_STATIC (INIT < 4 && ISOL < 4 && MEDI < 4 && FINA < 4);
   hb_mask_t masks[4], all_masks = 0;
   for (unsigned int i = 0; i < 4; i++)
   {
     masks[i] = plan->map.get_1_mask (arabic_features[i]);
     if (masks[i] == plan->map.get_global_mask ())
       masks[i] = 0;
     all_masks |= masks[i];
   }
@@ skipping 55 matching lines @@
 }
 
 static void
 clear_substitution_flags (const hb_ot_shape_plan_t *plan,
                           hb_font_t *font HB_UNUSED,
                           hb_buffer_t *buffer)
 {
   hb_glyph_info_t *info = buffer->info;
   unsigned int count = buffer->len;
   for (unsigned int i = 0; i < count; i++)
-    _hb_glyph_info_clear_substituted_and_ligated_and_multiplied (&info[i]);
+    _hb_glyph_info_clear_substituted (&info[i]);
 }
 
 static void
 record_rphf (const hb_ot_shape_plan_t *plan,
              hb_font_t *font,
              hb_buffer_t *buffer)
 {
   const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data;
 
   hb_mask_t mask = use_plan->rphf_mask;
@@ skipping 24 matching lines @@
     /* Mark a substituted pref as VPre, as they behave the same way. */
     for (unsigned int i = start; i < end; i++)
       if (_hb_glyph_info_substituted (&info[i]))
       {
         info[i].use_category() = USE_VPre;
         break;
       }
   }
 }
 
+static inline bool
+is_halant (const hb_glyph_info_t &info)
+{
+  return info.use_category() == USE_H && !_hb_glyph_info_ligated (&info);
+}
+
 static void
 reorder_syllable (hb_buffer_t *buffer, unsigned int start, unsigned int end)
 {
   syllable_type_t syllable_type = (syllable_type_t) (buffer->info[start].syllable() & 0x0F);
   /* Only a few syllable types need reordering. */
   if (unlikely (!(FLAG_SAFE (syllable_type) &
                   (FLAG (virama_terminated_cluster) |
                    FLAG (consonant_cluster) |
                    FLAG (vowel_cluster) |
                    FLAG (broken_cluster) |
                    0))))
     return;
 
   hb_glyph_info_t *info = buffer->info;
 
-#define HALANT_FLAGS FLAG(USE_H)
 #define BASE_FLAGS (FLAG (USE_B) | FLAG (USE_GB) | FLAG (USE_IV))
 
   /* Move things forward. */
   if (info[start].use_category() == USE_R && end - start > 1)
   {
     /* Got a repha.  Reorder it to after first base, before first halant. */
     for (unsigned int i = start + 1; i < end; i++)
-      if (FLAG_UNSAFE (info[i].use_category()) & (HALANT_FLAGS | BASE_FLAGS))
+      if ((FLAG_UNSAFE (info[i].use_category()) & (BASE_FLAGS)) || is_halant (info[i]))
       {
         /* If we hit a halant, move before it; otherwise it's a base: move to it's
          * place, and shift things in between backward. */
 
-        if (info[i].use_category() == USE_H)
+        if (is_halant (info[i]))
           i--;
 
         buffer->merge_clusters (start, i + 1);
         hb_glyph_info_t t = info[start];
         memmove (&info[start], &info[start + 1], (i - start) * sizeof (info[0]));
         info[i] = t;
 
         break;
       }
   }
 
   /* Move things back. */
   unsigned int j = end;
   for (unsigned int i = start; i < end; i++)
   {
     uint32_t flag = FLAG_UNSAFE (info[i].use_category());
-    if (flag & (HALANT_FLAGS | BASE_FLAGS))
+    if ((flag & (BASE_FLAGS)) || is_halant (info[i]))
     {
-      /* If we hit a halant, move before it; otherwise it's a base: move to it's
+      /* If we hit a halant, move after it; otherwise it's a base: move to it's
        * place, and shift things in between backward. */
-      if (info[i].use_category() == USE_H)
+      if (is_halant (info[i]))
         j = i + 1;
       else
         j = i;
     }
     else if (((flag) & (FLAG (USE_VPre) | FLAG (USE_VMPre))) &&
              /* Only move the first component of a MultipleSubst. */
              0 == _hb_glyph_info_get_lig_comp (&info[i]) &&
              j < i)
     {
       buffer->merge_clusters (j, i + 1);
@@ skipping 83 matching lines @@
 static bool
 compose_use (const hb_ot_shape_normalize_context_t *c,
              hb_codepoint_t  a,
              hb_codepoint_t  b,
              hb_codepoint_t *ab)
 {
   /* Avoid recomposing split matras. */
   if (HB_UNICODE_GENERAL_CATEGORY_IS_MARK (c->unicode->general_category (a)))
     return false;
 
-  return c->unicode->compose (a, b, ab);
+  return (bool)c->unicode->compose (a, b, ab);
 }
 
 
 const hb_ot_complex_shaper_t _hb_ot_complex_shaper_use =
 {
   "use",
   collect_features_use,
   NULL, /* override_features */
   data_create_use,
   data_destroy_use,
   NULL, /* preprocess_text */
   NULL, /* postprocess_glyphs */
   HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
   NULL, /* decompose */
   compose_use,
   setup_masks_use,
   HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
   false, /* fallback_position */
 };