Update harfbuzz-ng to 0.9.27

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

+/*
+ * Copyright © 2013  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.
+ *
+ * Google Author(s): Behdad Esfahbod
+ */
+
+#include "hb-ot-shape-complex-private.hh"
+
+
+/* Hangul shaper */
+
+
+/* Same order as the feature array below */
+enum {
+  NONE,
+
+  LJMO,
+  VJMO,
+  TJMO,
+
+  FIRST_HANGUL_FEATURE = LJMO,
+  HANGUL_FEATURE_COUNT = TJMO + 1
+};
+
+static const hb_tag_t hangul_features[HANGUL_FEATURE_COUNT] =
+{
+  HB_TAG_NONE,
+  HB_TAG('l','j','m','o'),
+  HB_TAG('v','j','m','o'),
+  HB_TAG('t','j','m','o')
+};
+
+static void
+collect_features_hangul (hb_ot_shape_planner_t *plan)
+{
+  hb_ot_map_builder_t *map = &plan->map;
+
+  for (unsigned int i = FIRST_HANGUL_FEATURE; i < HANGUL_FEATURE_COUNT; i++)
+    map->add_feature (hangul_features[i], 1, F_NONE);
+}
+
+struct hangul_shape_plan_t
+{
+  ASSERT_POD ();
+
+  hb_mask_t mask_array[HANGUL_FEATURE_COUNT];
+};
+
+static void *
+data_create_hangul (const hb_ot_shape_plan_t *plan)
+{
+  hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) calloc (1, sizeof (hangul_shape_plan_t));
+  if (unlikely (!hangul_plan))
+    return NULL;
+
+  for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++)
+    hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]);
+
+  return hangul_plan;
+}
+
+static void
+data_destroy_hangul (void *data)
+{
+  free (data);
+}
+
+/* Constants for algorithmic hangul syllable [de]composition. */
+#define LBase 0x1100
+#define VBase 0x1161
+#define TBase 0x11A7
+#define LCount 19
+#define VCount 21
+#define TCount 28
+#define SBase 0xAC00
+#define NCount (VCount * TCount)
+#define SCount (LCount * NCount)
+
+#define isCombiningL(u) (hb_in_range<hb_codepoint_t> ((u), LBase, LBase+LCount-1))
+#define isCombiningV(u) (hb_in_range<hb_codepoint_t> ((u), VBase, VBase+VCount-1))
+#define isCombiningT(u) (hb_in_range<hb_codepoint_t> ((u), TBase+1, TBase+TCount-1))
+#define isCombinedS(u) (hb_in_range<hb_codepoint_t> ((u), SBase, SBase+SCount-1))
+
+#define isL(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1100, 0x115F, 0xA960, 0xA97C))
+#define isV(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1160, 0x11A7, 0xD7B0, 0xD7C6))
+#define isT(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x11A8, 0x11FF, 0xD7CB, 0xD7FB))
+
+#define isHangulTone(u) (hb_in_range<hb_codepoint_t> ((u), 0x302e, 0x302f))
+
+/* buffer var allocations */
+#define hangul_shaping_feature() complex_var_u8_0() /* hangul jamo shaping feature */
+
+static bool
+is_zero_width_char (hb_font_t *font,
+                    hb_codepoint_t unicode)
+{
+  hb_codepoint_t glyph;
+  return hb_font_get_glyph (font, unicode, 0, &glyph) && hb_font_get_glyph_h_advance (font, glyph) == 0;
+}
+
+static void
+preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
+                        hb_buffer_t              *buffer,
+                        hb_font_t                *font)
+{
+  HB_BUFFER_ALLOCATE_VAR (buffer, hangul_shaping_feature);
+
+  /* Hangul syllables come in two shapes: LV, and LVT.  Of those:
+   *
+   *   - LV can be precomposed, or decomposed.  Lets call those
+   *     <LV> and <L,V>,
+   *   - LVT can be fully precomposed, partically precomposed, or
+   *     fully decomposed.  Ie. <LVT>, <LV,T>, or <L,V,T>.
+   *
+   * The composition / decomposition is mechanical.  However, not
+   * all <L,V> sequences compose, and not all <LV,T> sequences
+   * compose.
+   *
+   * Here are the specifics:
+   *
+   *   - <L>: U+1100..115F, U+A960..A97F
+   *   - <V>: U+1160..11A7, U+D7B0..D7C7
+   *   - <T>: U+11A8..11FF, U+D7CB..D7FB
+   *
+   *   - Only the <L,V> sequences for the 11xx ranges combine.
+   *   - Only <LV,T> sequences for T in U+11A8..11C3 combine.
+   *
+   * Here is what we want to accomplish in this shaper:
+   *
+   *   - If the whole syllable can be precomposed, do that,
+   *   - Otherwise, fully decompose and apply ljmo/vjmo/tjmo features.
+   *   - If a valid syllable is followed by a Hangul tone mark, reorder the tone
+   *     mark to precede the whole syllable - unless it is a zero-width glyph, in
+   *     which case we leave it untouched, assuming it's designed to overstrike.
+   *
+   * That is, of the different possible syllables:
+   *
+   *   <L>
+   *   <L,V>
+   *   <L,V,T>
+   *   <LV>
+   *   <LVT>
+   *   <LV, T>
+   *
+   * - <L> needs no work.
+   *
+   * - <LV> and <LVT> can stay the way they are if the font supports them, otherwise we
+   *   should fully decompose them if font supports.
+   *
+   * - <L,V> and <L,V,T> we should compose if the whole thing can be composed.
+   *
+   * - <LV,T> we should compose if the whole thing can be composed, otherwise we should
+   *   decompose.
+   */
+
+  buffer->clear_output ();
+  unsigned int start = 0, end = 0; /* Extent of most recently seen syllable;
+                                    * valid only if start < end
+                                    */
+  unsigned int count = buffer->len;
+
+  for (buffer->idx = 0; buffer->idx < count;)
+  {
+    hb_codepoint_t u = buffer->cur().codepoint;
+
+    if (isHangulTone (u))
+    {
+      /*
+       * We could cache the width of the tone marks and the existence of dotted-circle,
+       * but the use of the Hangul tone mark characters seems to be rare enough that
+       * I didn't bother for now.
+       */
+      if (start < end && end == buffer->out_len)
+      {
+        /* Tone mark follows a valid syllable; move it in front, unless it's zero width. */
+        buffer->next_glyph ();
+        if (!is_zero_width_char (font, u))
+        {
+          hb_glyph_info_t *info = buffer->out_info;
+          hb_glyph_info_t tone = info[end];
+          memmove (&info[start + 1], &info[start], (end - start) * sizeof (hb_glyph_info_t));
+          info[start] = tone;
+        }
+        /* Merge clusters across the (possibly reordered) syllable+tone.
+         * We want to merge even in the zero-width tone mark case here,
+         * so that clustering behavior isn't dependent on how the tone mark
+         * is handled by the font.
+         */
+        buffer->merge_out_clusters (start, end + 1);
+      }
+      else
+      {
+        /* No valid syllable as base for tone mark; try to insert dotted circle. */
+        if (font->has_glyph (0x25cc))
+        {
+          hb_codepoint_t chars[2];
+          if (!is_zero_width_char (font, u)) {
+            chars[0] = u;
+            chars[1] = 0x25cc;
+          } else {
+            chars[0] = 0x25cc;
+            chars[1] = u;
+          }
+          buffer->replace_glyphs (1, 2, chars);
+        }
+        else
+        {
+          /* No dotted circle available in the font; just leave tone mark untouched. */
+          buffer->next_glyph ();
+        }
+      }
+      start = end = buffer->out_len;
+      continue;
+    }
+
+    start = buffer->out_len; /* Remember current position as a potential syllable start;
+                              * will only be used if we set end to a later position.
+                              */
+
+    if (isL (u) && buffer->idx + 1 < count)
+    {
+      hb_codepoint_t l = u;
+      hb_codepoint_t v = buffer->cur(+1).codepoint;
+      if (isV (v))
+      {
+        /* Have <L,V> or <L,V,T>. */
+        hb_codepoint_t t = 0;
+        unsigned int tindex = 0;
+        if (buffer->idx + 2 < count)
+        {
+          t = buffer->cur(+2).codepoint;
+          if (isT (t))
+            tindex = t - TBase; /* Only used if isCombiningT (t); otherwise invalid. */
+          else
+            t = 0; /* The next character was not a trailing jamo. */
+        }
+
+        /* We've got a syllable <L,V,T?>; see if it can potentially be composed. */
+        if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t)))
+        {
+          /* Try to compose; if this succeeds, end is set to start+1. */
+          hb_codepoint_t s = SBase + (l - LBase) * NCount + (v - VBase) * TCount + tindex;
+          if (font->has_glyph (s))
+          {
+            buffer->replace_glyphs (t ? 3 : 2, 1, &s);
+            if (unlikely (buffer->in_error))
+              return;
+            end = start + 1;
+            continue;
+          }
+        }
+
+        /* We didn't compose, either because it's an Old Hangul syllable without a
+         * precomposed character in Unicode, or because the font didn't support the
+         * necessary precomposed glyph.
+         * Set jamo features on the individual glyphs, and advance past them.
+         */
+        buffer->cur().hangul_shaping_feature() = LJMO;
+        buffer->next_glyph ();
+        buffer->cur().hangul_shaping_feature() = VJMO;
+        buffer->next_glyph ();
+        if (t)
+        {
+          buffer->cur().hangul_shaping_feature() = TJMO;
+          buffer->next_glyph ();
+          end = start + 3;
+        }
+        else
+          end = start + 2;
+        buffer->merge_out_clusters (start, end);
+        continue;
+      }
+    }
+
+    else if (isCombinedS (u))
+    {
+      /* Have <LV>, <LVT>, or <LV,T> */
+      hb_codepoint_t s = u;
+      bool has_glyph = font->has_glyph (s);
+      unsigned int lindex = (s - SBase) / NCount;
+      unsigned int nindex = (s - SBase) % NCount;
+      unsigned int vindex = nindex / TCount;
+      unsigned int tindex = nindex % TCount;
+
+      if (!tindex &&
+          buffer->idx + 1 < count &&
+          isCombiningT (buffer->cur(+1).codepoint))
+      {
+        /* <LV,T>, try to combine. */
+        unsigned int new_tindex = buffer->cur(+1).codepoint - TBase;
+        hb_codepoint_t new_s = s + new_tindex;
+        if (font->has_glyph (new_s))
+        {
+          buffer->replace_glyphs (2, 1, &new_s);
+          if (unlikely (buffer->in_error))
+            return;
+          end = start + 1;
+          continue;
+        }
+      }
+
+      /* Otherwise, decompose if font doesn't support <LV> or <LVT>,
+       * or if having non-combining <LV,T>.  Note that we already handled
+       * combining <LV,T> above. */
+      if (!has_glyph ||
+          (!tindex &&
+           buffer->idx + 1 < count &&
+           isT (buffer->cur(+1).codepoint)))
+      {
+        hb_codepoint_t decomposed[3] = {LBase + lindex,
+                                        VBase + vindex,
+                                        TBase + tindex};
+        if (font->has_glyph (decomposed[0]) &&
+            font->has_glyph (decomposed[1]) &&
+            (!tindex || font->has_glyph (decomposed[2])))
+        {
+          unsigned int s_len = tindex ? 3 : 2;
+          buffer->replace_glyphs (1, s_len, decomposed);
+          if (unlikely (buffer->in_error))
+            return;
+
+          /* We decomposed S: apply jamo features to the individual glyphs
+           * that are now in buffer->out_info.
+           */
+          hb_glyph_info_t *info = buffer->out_info;
+
+          /* If we decomposed an LV because of a non-combining T following,
+           * we want to include this T in the syllable.
+           */
+          if (has_glyph && !tindex)
+          {
+            buffer->next_glyph ();
+            s_len++;
+          }
+          end = start + s_len;
+
+          unsigned int i = start;
+          info[i++].hangul_shaping_feature() = LJMO;
+          info[i++].hangul_shaping_feature() = VJMO;
+          if (i < end)
+            info[i++].hangul_shaping_feature() = TJMO;
+          buffer->merge_out_clusters (start, end);
+          continue;
+        }
+      }
+
+      if (has_glyph)
+      {
+        /* We didn't decompose the S, so just advance past it. */
+        end = start + 1;
+        buffer->next_glyph ();
+        continue;
+      }
+    }
+
+    /* Didn't find a recognizable syllable, so we leave end <= start;
+     * this will prevent tone-mark reordering happening.
+     */
+    buffer->next_glyph ();
+  }
+  buffer->swap_buffers ();
+}
+
+static void
+setup_masks_hangul (const hb_ot_shape_plan_t *plan,
+                    hb_buffer_t              *buffer,
+                    hb_font_t                *font HB_UNUSED)
+{
+  const hangul_shape_plan_t *hangul_plan = (const hangul_shape_plan_t *) plan->data;
+
+  if (likely (hangul_plan))
+  {
+    unsigned int count = buffer->len;
+    hb_glyph_info_t *info = buffer->info;
+    for (unsigned int i = 0; i < count; i++, info++)
+      info->mask |= hangul_plan->mask_array[info->hangul_shaping_feature()];
+  }
+
+  HB_BUFFER_DEALLOCATE_VAR (buffer, hangul_shaping_feature);
+}
+
+
+const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hangul =
+{
+  "hangul",
+  collect_features_hangul,
+  NULL, /* override_features */
+  data_create_hangul, /* data_create */
+  data_destroy_hangul, /* data_destroy */
+  preprocess_text_hangul,
+  HB_OT_SHAPE_NORMALIZATION_MODE_NONE,
+  NULL, /* decompose */
+  NULL, /* compose */
+  setup_masks_hangul, /* setup_masks */
+  HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
+  false, /* fallback_position */
+};