• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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   _JMO,
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
collect_features_hangul(hb_ot_shape_planner_t * plan)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
override_features_hangul(hb_ot_shape_planner_t * plan)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 *
data_create_hangul(const hb_ot_shape_plan_t * plan)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
data_destroy_hangul(void * data)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
is_zero_width_char(hb_font_t * font,hb_codepoint_t unicode)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
preprocess_text_hangul(const hb_ot_shape_plan_t * plan,hb_buffer_t * buffer,hb_font_t * font)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 && !buffer->in_error;)
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
setup_masks_hangul(const hb_ot_shape_plan_t * plan,hb_buffer_t * buffer,hb_font_t * font HB_UNUSED)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,
415   data_destroy_hangul,
416   preprocess_text_hangul,
417   NULL, /* postprocess_glyphs */
418   HB_OT_SHAPE_NORMALIZATION_MODE_NONE,
419   NULL, /* decompose */
420   NULL, /* compose */
421   setup_masks_hangul,
422   NULL, /* disable_otl */
423   HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
424   false, /* fallback_position */
425 };
426