1 /*

     2  * Copyright © 2013  Google, Inc.

     3  *

     4  *  This is part of HarfBuzz, a text shaping library.

     5  *

     6  * Permission is hereby granted, without written agreement and without

     7  * license or royalty fees, to use, copy, modify, and distribute this

     8  * software and its documentation for any purpose, provided that the

     9  * above copyright notice and the following two paragraphs appear in

    10  * all copies of this software.

    11  *

    12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

    13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

    14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

    15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

    16  * DAMAGE.

    17  *

    18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

    19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

    20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

    21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

    22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

    23  *

    24  * Google Author(s): Behdad Esfahbod

    25  */

    26 

    27 #include "hb-ot-shape-complex-private.hh"

    28 

    29 

    30 /* Hangul shaper */

    31 

    32 

    33 /* Same order as the feature array below */

    34 enum {

    35   NONE,

    36 

    37   LJMO,

    38   VJMO,

    39   TJMO,

    40 

    41   FIRST_HANGUL_FEATURE = LJMO,

    42   HANGUL_FEATURE_COUNT = TJMO + 1

    43 };

    44 

    45 static const hb_tag_t hangul_features[HANGUL_FEATURE_COUNT] =

    46 {

    47   HB_TAG_NONE,

    48   HB_TAG('l','j','m','o'),

    49   HB_TAG('v','j','m','o'),

    50   HB_TAG('t','j','m','o')

    51 };

    52 

    53 static void

    54 collect_features_hangul (hb_ot_shape_planner_t *plan)

    55 {

    56   hb_ot_map_builder_t *map = &plan->map;

    57 

    58   for (unsigned int i = FIRST_HANGUL_FEATURE; i < HANGUL_FEATURE_COUNT; i++)

    59     map->add_feature (hangul_features[i], 1, F_NONE);

    60 }

    61 

    62 static void

    63 override_features_hangul (hb_ot_shape_planner_t *plan)

    64 {

    65   /* Uniscribe does not apply 'calt' for Hangul, and certain fonts

    66    * (Noto Sans CJK, Source Sans Han, etc) apply all of jamo lookups

    67    * in calt, which is not desirable. */

    68   plan->map.add_feature (HB_TAG('c','a','l','t'), 0, F_GLOBAL);

    69 }

    70 

    71 struct hangul_shape_plan_t

    72 {

    73   ASSERT_POD ();

    74 

    75   hb_mask_t mask_array[HANGUL_FEATURE_COUNT];

    76 };

    77 

    78 static void *

    79 data_create_hangul (const hb_ot_shape_plan_t *plan)

    80 {

    81   hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) calloc (1, sizeof (hangul_shape_plan_t));

    82   if (unlikely (!hangul_plan))

    83     return NULL;

    84 

    85   for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++)

    86     hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]);

    87 

    88   return hangul_plan;

    89 }

    90 

    91 static void

    92 data_destroy_hangul (void *data)

    93 {

    94   free (data);

    95 }

    96 

    97 /* Constants for algorithmic hangul syllable [de]composition. */

    98 #define LBase 0x1100u

    99 #define VBase 0x1161u

   100 #define TBase 0x11A7u

   101 #define LCount 19u

   102 #define VCount 21u

   103 #define TCount 28u

   104 #define SBase 0xAC00u

   105 #define NCount (VCount * TCount)

   106 #define SCount (LCount * NCount)

   107 

   108 #define isCombiningL(u) (hb_in_range ((u), LBase, LBase+LCount-1))

   109 #define isCombiningV(u) (hb_in_range ((u), VBase, VBase+VCount-1))

   110 #define isCombiningT(u) (hb_in_range ((u), TBase+1, TBase+TCount-1))

   111 #define isCombinedS(u) (hb_in_range ((u), SBase, SBase+SCount-1))

   112 

   113 #define isL(u) (hb_in_ranges ((u), 0x1100u, 0x115Fu, 0xA960u, 0xA97Cu))

   114 #define isV(u) (hb_in_ranges ((u), 0x1160u, 0x11A7u, 0xD7B0u, 0xD7C6u))

   115 #define isT(u) (hb_in_ranges ((u), 0x11A8u, 0x11FFu, 0xD7CBu, 0xD7FBu))

   116 

   117 #define isHangulTone(u) (hb_in_range ((u), 0x302Eu, 0x302Fu))

   118 

   119 /* buffer var allocations */

   120 #define hangul_shaping_feature() complex_var_u8_0() /* hangul jamo shaping feature */

   121 

   122 static bool

   123 is_zero_width_char (hb_font_t *font,

   124                     hb_codepoint_t unicode)

   125 {

   126   hb_codepoint_t glyph;

   127   return hb_font_get_glyph (font, unicode, 0, &glyph) && hb_font_get_glyph_h_advance (font, glyph) == 0;

   128 }

   129 

   130 static void

   131 preprocess_text_hangul (const hb_ot_shape_plan_t *plan,

   132                         hb_buffer_t              *buffer,

   133                         hb_font_t                *font)

   134 {

   135   HB_BUFFER_ALLOCATE_VAR (buffer, hangul_shaping_feature);

   136 

   137   /* Hangul syllables come in two shapes: LV, and LVT.  Of those:

   138    *

   139    *   - LV can be precomposed, or decomposed.  Lets call those

   140    *     <LV> and <L,V>,

   141    *   - LVT can be fully precomposed, partically precomposed, or

   142    *     fully decomposed.  Ie. <LVT>, <LV,T>, or <L,V,T>.

   143    *

   144    * The composition / decomposition is mechanical.  However, not

   145    * all <L,V> sequences compose, and not all <LV,T> sequences

   146    * compose.

   147    *

   148    * Here are the specifics:

   149    *

   150    *   - <L>: U+1100..115F, U+A960..A97F

   151    *   - <V>: U+1160..11A7, U+D7B0..D7C7

   152    *   - <T>: U+11A8..11FF, U+D7CB..D7FB

   153    *

   154    *   - Only the <L,V> sequences for the 11xx ranges combine.

   155    *   - Only <LV,T> sequences for T in U+11A8..11C3 combine.

   156    *

   157    * Here is what we want to accomplish in this shaper:

   158    *

   159    *   - If the whole syllable can be precomposed, do that,

   160    *   - Otherwise, fully decompose and apply ljmo/vjmo/tjmo features.

   161    *   - If a valid syllable is followed by a Hangul tone mark, reorder the tone

   162    *     mark to precede the whole syllable - unless it is a zero-width glyph, in

   163    *     which case we leave it untouched, assuming it's designed to overstrike.

   164    *

   165    * That is, of the different possible syllables:

   166    *

   167    *   <L>

   168    *   <L,V>

   169    *   <L,V,T>

   170    *   <LV>

   171    *   <LVT>

   172    *   <LV, T>

   173    *

   174    * - <L> needs no work.

   175    *

   176    * - <LV> and <LVT> can stay the way they are if the font supports them, otherwise we

   177    *   should fully decompose them if font supports.

   178    *

   179    * - <L,V> and <L,V,T> we should compose if the whole thing can be composed.

   180    *

   181    * - <LV,T> we should compose if the whole thing can be composed, otherwise we should

   182    *   decompose.

   183    */

   184 

   185   buffer->clear_output ();

   186   unsigned int start = 0, end = 0; /* Extent of most recently seen syllable;

   187                                     * valid only if start < end

   188                                     */

   189   unsigned int count = buffer->len;

   190 

   191   for (buffer->idx = 0; buffer->idx < count;)

   192   {

   193     hb_codepoint_t u = buffer->cur().codepoint;

   194 

   195     if (isHangulTone (u))

   196     {

   197       /*

   198        * We could cache the width of the tone marks and the existence of dotted-circle,

   199        * but the use of the Hangul tone mark characters seems to be rare enough that

   200        * I didn't bother for now.

   201        */

   202       if (start < end && end == buffer->out_len)

   203       {

   204         /* Tone mark follows a valid syllable; move it in front, unless it's zero width. */

   205         buffer->next_glyph ();

   206         if (!is_zero_width_char (font, u))

   207         {

   208           buffer->merge_out_clusters (start, end + 1);

   209           hb_glyph_info_t *info = buffer->out_info;

   210           hb_glyph_info_t tone = info[end];

   211           memmove (&info[start + 1], &info[start], (end - start) * sizeof (hb_glyph_info_t));

   212           info[start] = tone;

   213         }

   214       }

   215       else

   216       {

   217         /* No valid syllable as base for tone mark; try to insert dotted circle. */

   218         if (font->has_glyph (0x25CCu))

   219         {

   220           hb_codepoint_t chars[2];

   221           if (!is_zero_width_char (font, u)) {

   222             chars[0] = u;

   223             chars[1] = 0x25CCu;

   224           } else {

   225             chars[0] = 0x25CCu;

   226             chars[1] = u;

   227           }

   228           buffer->replace_glyphs (1, 2, chars);

   229         }

   230         else

   231         {

   232           /* No dotted circle available in the font; just leave tone mark untouched. */

   233           buffer->next_glyph ();

   234         }

   235       }

   236       start = end = buffer->out_len;

   237       continue;

   238     }

   239 

   240     start = buffer->out_len; /* Remember current position as a potential syllable start;

   241                               * will only be used if we set end to a later position.

   242                               */

   243 

   244     if (isL (u) && buffer->idx + 1 < count)

   245     {

   246       hb_codepoint_t l = u;

   247       hb_codepoint_t v = buffer->cur(+1).codepoint;

   248       if (isV (v))

   249       {

   250         /* Have <L,V> or <L,V,T>. */

   251         hb_codepoint_t t = 0;

   252         unsigned int tindex = 0;

   253         if (buffer->idx + 2 < count)

   254         {

   255           t = buffer->cur(+2).codepoint;

   256           if (isT (t))

   257             tindex = t - TBase; /* Only used if isCombiningT (t); otherwise invalid. */

   258           else

   259             t = 0; /* The next character was not a trailing jamo. */

   260         }

   261 

   262         /* We've got a syllable <L,V,T?>; see if it can potentially be composed. */

   263         if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t)))

   264         {

   265           /* Try to compose; if this succeeds, end is set to start+1. */

   266           hb_codepoint_t s = SBase + (l - LBase) * NCount + (v - VBase) * TCount + tindex;

   267           if (font->has_glyph (s))

   268           {

   269             buffer->replace_glyphs (t ? 3 : 2, 1, &s);

   270             if (unlikely (buffer->in_error))

   271               return;

   272             end = start + 1;

   273             continue;

   274           }

   275         }

   276 

   277         /* We didn't compose, either because it's an Old Hangul syllable without a

   278          * precomposed character in Unicode, or because the font didn't support the

   279          * necessary precomposed glyph.

   280          * Set jamo features on the individual glyphs, and advance past them.

   281          */

   282         buffer->cur().hangul_shaping_feature() = LJMO;

   283         buffer->next_glyph ();

   284         buffer->cur().hangul_shaping_feature() = VJMO;

   285         buffer->next_glyph ();

   286         if (t)

   287         {

   288           buffer->cur().hangul_shaping_feature() = TJMO;

   289           buffer->next_glyph ();

   290           end = start + 3;

   291         }

   292         else

   293           end = start + 2;

   294         if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)

   295           buffer->merge_out_clusters (start, end);

   296         continue;

   297       }

   298     }

   299 

   300     else if (isCombinedS (u))

   301     {

   302       /* Have <LV>, <LVT>, or <LV,T> */

   303       hb_codepoint_t s = u;

   304       bool has_glyph = font->has_glyph (s);

   305       unsigned int lindex = (s - SBase) / NCount;

   306       unsigned int nindex = (s - SBase) % NCount;

   307       unsigned int vindex = nindex / TCount;

   308       unsigned int tindex = nindex % TCount;

   309 

   310       if (!tindex &&

   311           buffer->idx + 1 < count &&

   312           isCombiningT (buffer->cur(+1).codepoint))

   313       {

   314         /* <LV,T>, try to combine. */

   315         unsigned int new_tindex = buffer->cur(+1).codepoint - TBase;

   316         hb_codepoint_t new_s = s + new_tindex;

   317         if (font->has_glyph (new_s))

   318         {

   319           buffer->replace_glyphs (2, 1, &new_s);

   320           if (unlikely (buffer->in_error))

   321             return;

   322           end = start + 1;

   323           continue;

   324         }

   325       }

   326 

   327       /* Otherwise, decompose if font doesn't support <LV> or <LVT>,

   328        * or if having non-combining <LV,T>.  Note that we already handled

   329        * combining <LV,T> above. */

   330       if (!has_glyph ||

   331           (!tindex &&

   332            buffer->idx + 1 < count &&

   333            isT (buffer->cur(+1).codepoint)))

   334       {

   335         hb_codepoint_t decomposed[3] = {LBase + lindex,

   336                                         VBase + vindex,

   337                                         TBase + tindex};

   338         if (font->has_glyph (decomposed[0]) &&

   339             font->has_glyph (decomposed[1]) &&

   340             (!tindex || font->has_glyph (decomposed[2])))

   341         {

   342           unsigned int s_len = tindex ? 3 : 2;

   343           buffer->replace_glyphs (1, s_len, decomposed);

   344           if (unlikely (buffer->in_error))

   345             return;

   346 

   347           /* We decomposed S: apply jamo features to the individual glyphs

   348            * that are now in buffer->out_info.

   349            */

   350           hb_glyph_info_t *info = buffer->out_info;

   351 

   352           /* If we decomposed an LV because of a non-combining T following,

   353            * we want to include this T in the syllable.

   354            */

   355           if (has_glyph && !tindex)

   356           {

   357             buffer->next_glyph ();

   358             s_len++;

   359           }

   360           end = start + s_len;

   361 

   362           unsigned int i = start;

   363           info[i++].hangul_shaping_feature() = LJMO;

   364           info[i++].hangul_shaping_feature() = VJMO;

   365           if (i < end)

   366             info[i++].hangul_shaping_feature() = TJMO;

   367           if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)

   368             buffer->merge_out_clusters (start, end);

   369           continue;

   370         }

   371       }

   372 

   373       if (has_glyph)

   374       {

   375         /* We didn't decompose the S, so just advance past it. */

   376         end = start + 1;

   377         buffer->next_glyph ();

   378         continue;

   379       }

   380     }

   381 

   382     /* Didn't find a recognizable syllable, so we leave end <= start;

   383      * this will prevent tone-mark reordering happening.

   384      */

   385     buffer->next_glyph ();

   386   }

   387   buffer->swap_buffers ();

   388 }

   389 

   390 static void

   391 setup_masks_hangul (const hb_ot_shape_plan_t *plan,

   392                     hb_buffer_t              *buffer,

   393                     hb_font_t                *font HB_UNUSED)

   394 {

   395   const hangul_shape_plan_t *hangul_plan = (const hangul_shape_plan_t *) plan->data;

   396 

   397   if (likely (hangul_plan))

   398   {

   399     unsigned int count = buffer->len;

   400     hb_glyph_info_t *info = buffer->info;

   401     for (unsigned int i = 0; i < count; i++, info++)

   402       info->mask |= hangul_plan->mask_array[info->hangul_shaping_feature()];

   403   }

   404 

   405   HB_BUFFER_DEALLOCATE_VAR (buffer, hangul_shaping_feature);

   406 }

   407 

   408 

   409 const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hangul =

   410 {

   411   "hangul",

   412   collect_features_hangul,

   413   override_features_hangul,

   414   data_create_hangul, /* data_create */

   415   data_destroy_hangul, /* data_destroy */

   416   preprocess_text_hangul,

   417   HB_OT_SHAPE_NORMALIZATION_MODE_NONE,

   418   NULL, /* decompose */

   419   NULL, /* compose */

   420   setup_masks_hangul, /* setup_masks */

   421   HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,

   422   false, /* fallback_position */

   423 };