Update harfbuzz-ng to 0.9.17

third_party/harfbuzz-ng/src/hb-ot-shape-normalize.cc

 /*
  * Copyright © 2011,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
  * all copies of this software.
@@ skipping 152 matching lines @@
       output_char (c->buffer, b, b_glyph);
       return 2;
     }
     return 1;
   }
 
   return 0;
 }
 
 /* Returns 0 if didn't decompose, number of resulting characters otherwise. */
-static inline bool
+static inline unsigned int
 decompose_compatibility (const hb_ot_shape_normalize_context_t *c, hb_codepoint_t u)
 {
   unsigned int len, i;
   hb_codepoint_t decomposed[HB_UNICODE_MAX_DECOMPOSITION_LEN];
   hb_codepoint_t glyphs[HB_UNICODE_MAX_DECOMPOSITION_LEN];
 
   len = c->buffer->unicode->decompose_compatibility (u, decomposed);
   if (!len)
     return 0;
 
   for (i = 0; i < len; i++)
     if (!c->font->get_glyph (decomposed[i], 0, &glyphs[i]))
       return 0;
 
   for (i = 0; i < len; i++)
     output_char (c->buffer, decomposed[i], glyphs[i]);
 
   return len;
 }
 
-/* Returns true if recomposition may be benefitial. */
 static inline void
 decompose_current_character (const hb_ot_shape_normalize_context_t *c, bool shortest)
 {
   hb_buffer_t * const buffer = c->buffer;
   hb_codepoint_t glyph;
 
   /* Kind of a cute waterfall here... */
   if (shortest && c->font->get_glyph (buffer->cur().codepoint, 0, &glyph))
     next_char (buffer, glyph);
   else if (decompose (c, shortest, buffer->cur().codepoint))
@@ skipping 19 matching lines @@
       set_glyph (buffer->cur(), c->font);
       buffer->next_glyph ();
     }
   }
   if (likely (buffer->idx < end)) {
     set_glyph (buffer->cur(), c->font);
     buffer->next_glyph ();
   }
 }
 
-/* Returns true if recomposition may be benefitial. */
 static inline void
 decompose_multi_char_cluster (const hb_ot_shape_normalize_context_t *c, unsigned int end)
 {
   hb_buffer_t * const buffer = c->buffer;
   /* TODO Currently if there's a variation-selector we give-up, it's just too hard. */
   for (unsigned int i = buffer->idx; i < end; i++)
     if (unlikely (buffer->unicode->is_variation_selector (buffer->info[i].codepoint))) {
       handle_variation_selector_cluster (c, end);
       return;
     }
@@ skipping 101 matching lines @@
   /* As noted in the comment earlier, we don't try to combine
    * ccc=0 chars with their previous Starter. */
 
   buffer->clear_output ();
   count = buffer->len;
   unsigned int starter = 0;
   buffer->next_glyph ();
   while (buffer->idx < count)
   {
     hb_codepoint_t composed, glyph;
-    if (/* If mode is NOT COMPOSED_FULL (ie. it's COMPOSED_DIACRITICS), we don't try to
-         * compose a non-mark character with it's preceding starter.  This is just an
-         * optimization to avoid trying to compose every two neighboring glyphs in most
-         * scripts. */
-        (mode == HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_FULL ||
-         HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&buffer->cur()))) &&
+    if (/* We don't try to compose a non-mark character with it's preceding starter.
+         * This is both an optimization to avoid trying to compose every two neighboring
+         * glyphs in most scripts AND a desired feature for Hangul.  Apparently Hangul
+         * fonts are not designed to mix-and-match pre-composed syllables and Jamo. */
+        HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&buffer->cur())) &&
         /* If there's anything between the starter and this char, they should have CCC
          * smaller than this character's. */
         (starter == buffer->out_len - 1 ||
          _hb_glyph_info_get_modified_combining_class (&buffer->prev()) < _hb_glyph_info_get_modified_combining_class (&buffer->cur())) &&
         /* And compose. */
         c.compose (&c,
                    buffer->out_info[starter].codepoint,
                    buffer->cur().codepoint,
                    &composed) &&
         /* And the font has glyph for the composite. */
@@ skipping 14 matching lines @@
 
     /* Blocked, or doesn't compose. */
     buffer->next_glyph ();
 
     if (_hb_glyph_info_get_modified_combining_class (&buffer->prev()) == 0)
       starter = buffer->out_len - 1;
   }
   buffer->swap_buffers ();
 
 }