2 * Copyright © 2013 Google, Inc.
4 * This is part of HarfBuzz, a text shaping library.
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.
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
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.
24 * Google Author(s): Behdad Esfahbod
27 #include "hb-ot-shape-complex-private.hh"
33 /* Same order as the feature array below */
41 FIRST_HANGUL_FEATURE = LJMO,
42 HANGUL_FEATURE_COUNT = TJMO + 1
45 static const hb_tag_t hangul_features[HANGUL_FEATURE_COUNT] =
48 HB_TAG('l','j','m','o'),
49 HB_TAG('v','j','m','o'),
50 HB_TAG('t','j','m','o')
54 collect_features_hangul (hb_ot_shape_planner_t *plan)
56 hb_ot_map_builder_t *map = &plan->map;
58 for (unsigned int i = FIRST_HANGUL_FEATURE; i < HANGUL_FEATURE_COUNT; i++)
59 map->add_feature (hangul_features[i], 1, F_NONE);
62 struct hangul_shape_plan_t
66 hb_mask_t mask_array[HANGUL_FEATURE_COUNT];
70 data_create_hangul (const hb_ot_shape_plan_t *plan)
72 hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) calloc (1, sizeof (hangul_shape_plan_t));
73 if (unlikely (!hangul_plan))
76 for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++)
77 hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]);
83 data_destroy_hangul (void *data)
88 /* Constants for algorithmic hangul syllable [de]composition. */
96 #define NCount (VCount * TCount)
97 #define SCount (LCount * NCount)
99 #define isCombiningL(u) (hb_in_range<hb_codepoint_t> ((u), LBase, LBase+LCount-1))
100 #define isCombiningV(u) (hb_in_range<hb_codepoint_t> ((u), VBase, VBase+VCount-1))
101 #define isCombiningT(u) (hb_in_range<hb_codepoint_t> ((u), TBase+1, TBase+TCount-1))
102 #define isCombinedS(u) (hb_in_range<hb_codepoint_t> ((u), SBase, SBase+SCount-1))
104 #define isL(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1100, 0x115F, 0xA960, 0xA97C))
105 #define isV(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1160, 0x11A7, 0xD7B0, 0xD7C6))
106 #define isT(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x11A8, 0x11FF, 0xD7CB, 0xD7FB))
108 #define isHangulTone(u) (hb_in_range<hb_codepoint_t> ((u), 0x302e, 0x302f))
110 /* buffer var allocations */
111 #define hangul_shaping_feature() complex_var_u8_0() /* hangul jamo shaping feature */
114 is_zero_width_char (hb_font_t *font,
115 hb_codepoint_t unicode)
117 hb_codepoint_t glyph;
118 return hb_font_get_glyph (font, unicode, 0, &glyph) && hb_font_get_glyph_h_advance (font, glyph) == 0;
122 preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
126 HB_BUFFER_ALLOCATE_VAR (buffer, hangul_shaping_feature);
128 /* Hangul syllables come in two shapes: LV, and LVT. Of those:
130 * - LV can be precomposed, or decomposed. Lets call those
132 * - LVT can be fully precomposed, partically precomposed, or
133 * fully decomposed. Ie. <LVT>, <LV,T>, or <L,V,T>.
135 * The composition / decomposition is mechanical. However, not
136 * all <L,V> sequences compose, and not all <LV,T> sequences
139 * Here are the specifics:
141 * - <L>: U+1100..115F, U+A960..A97F
142 * - <V>: U+1160..11A7, U+D7B0..D7C7
143 * - <T>: U+11A8..11FF, U+D7CB..D7FB
145 * - Only the <L,V> sequences for the 11xx ranges combine.
146 * - Only <LV,T> sequences for T in U+11A8..11C3 combine.
148 * Here is what we want to accomplish in this shaper:
150 * - If the whole syllable can be precomposed, do that,
151 * - Otherwise, fully decompose and apply ljmo/vjmo/tjmo features.
152 * - If a valid syllable is followed by a Hangul tone mark, reorder the tone
153 * mark to precede the whole syllable - unless it is a zero-width glyph, in
154 * which case we leave it untouched, assuming it's designed to overstrike.
156 * That is, of the different possible syllables:
165 * - <L> needs no work.
167 * - <LV> and <LVT> can stay the way they are if the font supports them, otherwise we
168 * should fully decompose them if font supports.
170 * - <L,V> and <L,V,T> we should compose if the whole thing can be composed.
172 * - <LV,T> we should compose if the whole thing can be composed, otherwise we should
176 buffer->clear_output ();
177 unsigned int start = 0, end = 0; /* Extent of most recently seen syllable;
178 * valid only if start < end
180 unsigned int count = buffer->len;
182 for (buffer->idx = 0; buffer->idx < count;)
184 hb_codepoint_t u = buffer->cur().codepoint;
186 if (isHangulTone (u))
189 * We could cache the width of the tone marks and the existence of dotted-circle,
190 * but the use of the Hangul tone mark characters seems to be rare enough that
191 * I didn't bother for now.
193 if (start < end && end == buffer->out_len)
195 /* Tone mark follows a valid syllable; move it in front, unless it's zero width. */
196 buffer->next_glyph ();
197 if (!is_zero_width_char (font, u))
199 hb_glyph_info_t *info = buffer->out_info;
200 hb_glyph_info_t tone = info[end];
201 memmove (&info[start + 1], &info[start], (end - start) * sizeof (hb_glyph_info_t));
204 /* Merge clusters across the (possibly reordered) syllable+tone.
205 * We want to merge even in the zero-width tone mark case here,
206 * so that clustering behavior isn't dependent on how the tone mark
207 * is handled by the font.
209 buffer->merge_out_clusters (start, end + 1);
213 /* No valid syllable as base for tone mark; try to insert dotted circle. */
214 if (font->has_glyph (0x25cc))
216 hb_codepoint_t chars[2];
217 if (!is_zero_width_char (font, u)) {
224 buffer->replace_glyphs (1, 2, chars);
228 /* No dotted circle available in the font; just leave tone mark untouched. */
229 buffer->next_glyph ();
232 start = end = buffer->out_len;
236 start = buffer->out_len; /* Remember current position as a potential syllable start;
237 * will only be used if we set end to a later position.
240 if (isL (u) && buffer->idx + 1 < count)
242 hb_codepoint_t l = u;
243 hb_codepoint_t v = buffer->cur(+1).codepoint;
246 /* Have <L,V> or <L,V,T>. */
247 hb_codepoint_t t = 0;
248 unsigned int tindex = 0;
249 if (buffer->idx + 2 < count)
251 t = buffer->cur(+2).codepoint;
253 tindex = t - TBase; /* Only used if isCombiningT (t); otherwise invalid. */
255 t = 0; /* The next character was not a trailing jamo. */
258 /* We've got a syllable <L,V,T?>; see if it can potentially be composed. */
259 if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t)))
261 /* Try to compose; if this succeeds, end is set to start+1. */
262 hb_codepoint_t s = SBase + (l - LBase) * NCount + (v - VBase) * TCount + tindex;
263 if (font->has_glyph (s))
265 buffer->replace_glyphs (t ? 3 : 2, 1, &s);
266 if (unlikely (buffer->in_error))
273 /* We didn't compose, either because it's an Old Hangul syllable without a
274 * precomposed character in Unicode, or because the font didn't support the
275 * necessary precomposed glyph.
276 * Set jamo features on the individual glyphs, and advance past them.
278 buffer->cur().hangul_shaping_feature() = LJMO;
279 buffer->next_glyph ();
280 buffer->cur().hangul_shaping_feature() = VJMO;
281 buffer->next_glyph ();
284 buffer->cur().hangul_shaping_feature() = TJMO;
285 buffer->next_glyph ();
290 buffer->merge_out_clusters (start, end);
295 else if (isCombinedS (u))
297 /* Have <LV>, <LVT>, or <LV,T> */
298 hb_codepoint_t s = u;
299 bool has_glyph = font->has_glyph (s);
300 unsigned int lindex = (s - SBase) / NCount;
301 unsigned int nindex = (s - SBase) % NCount;
302 unsigned int vindex = nindex / TCount;
303 unsigned int tindex = nindex % TCount;
306 buffer->idx + 1 < count &&
307 isCombiningT (buffer->cur(+1).codepoint))
309 /* <LV,T>, try to combine. */
310 unsigned int new_tindex = buffer->cur(+1).codepoint - TBase;
311 hb_codepoint_t new_s = s + new_tindex;
312 if (font->has_glyph (new_s))
314 buffer->replace_glyphs (2, 1, &new_s);
315 if (unlikely (buffer->in_error))
322 /* Otherwise, decompose if font doesn't support <LV> or <LVT>,
323 * or if having non-combining <LV,T>. Note that we already handled
324 * combining <LV,T> above. */
327 buffer->idx + 1 < count &&
328 isT (buffer->cur(+1).codepoint)))
330 hb_codepoint_t decomposed[3] = {LBase + lindex,
333 if (font->has_glyph (decomposed[0]) &&
334 font->has_glyph (decomposed[1]) &&
335 (!tindex || font->has_glyph (decomposed[2])))
337 unsigned int s_len = tindex ? 3 : 2;
338 buffer->replace_glyphs (1, s_len, decomposed);
339 if (unlikely (buffer->in_error))
342 /* We decomposed S: apply jamo features to the individual glyphs
343 * that are now in buffer->out_info.
345 hb_glyph_info_t *info = buffer->out_info;
347 /* If we decomposed an LV because of a non-combining T following,
348 * we want to include this T in the syllable.
350 if (has_glyph && !tindex)
352 buffer->next_glyph ();
357 unsigned int i = start;
358 info[i++].hangul_shaping_feature() = LJMO;
359 info[i++].hangul_shaping_feature() = VJMO;
361 info[i++].hangul_shaping_feature() = TJMO;
362 buffer->merge_out_clusters (start, end);
369 /* We didn't decompose the S, so just advance past it. */
371 buffer->next_glyph ();
376 /* Didn't find a recognizable syllable, so we leave end <= start;
377 * this will prevent tone-mark reordering happening.
379 buffer->next_glyph ();
381 buffer->swap_buffers ();
385 setup_masks_hangul (const hb_ot_shape_plan_t *plan,
387 hb_font_t *font HB_UNUSED)
389 const hangul_shape_plan_t *hangul_plan = (const hangul_shape_plan_t *) plan->data;
391 if (likely (hangul_plan))
393 unsigned int count = buffer->len;
394 hb_glyph_info_t *info = buffer->info;
395 for (unsigned int i = 0; i < count; i++, info++)
396 info->mask |= hangul_plan->mask_array[info->hangul_shaping_feature()];
399 HB_BUFFER_DEALLOCATE_VAR (buffer, hangul_shaping_feature);
403 const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hangul =
406 collect_features_hangul,
407 NULL, /* override_features */
408 data_create_hangul, /* data_create */
409 data_destroy_hangul, /* data_destroy */
410 preprocess_text_hangul,
411 HB_OT_SHAPE_NORMALIZATION_MODE_NONE,
412 NULL, /* decompose */
414 setup_masks_hangul, /* setup_masks */
415 HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
416 false, /* fallback_position */