Line data Source code
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
54 0 : collect_features_hangul (hb_ot_shape_planner_t *plan)
55 : {
56 0 : hb_ot_map_builder_t *map = &plan->map;
57 :
58 0 : for (unsigned int i = FIRST_HANGUL_FEATURE; i < HANGUL_FEATURE_COUNT; i++)
59 0 : map->add_feature (hangul_features[i], 1, F_NONE);
60 0 : }
61 :
62 : static void
63 0 : 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 0 : plan->map.add_feature (HB_TAG('c','a','l','t'), 0, F_GLOBAL);
69 0 : }
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 0 : data_create_hangul (const hb_ot_shape_plan_t *plan)
80 : {
81 0 : hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) calloc (1, sizeof (hangul_shape_plan_t));
82 0 : if (unlikely (!hangul_plan))
83 0 : return NULL;
84 :
85 0 : for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++)
86 0 : hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]);
87 :
88 0 : return hangul_plan;
89 : }
90 :
91 : static void
92 0 : data_destroy_hangul (void *data)
93 : {
94 0 : free (data);
95 0 : }
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 0 : is_zero_width_char (hb_font_t *font,
124 : hb_codepoint_t unicode)
125 : {
126 : hb_codepoint_t glyph;
127 0 : return hb_font_get_glyph (font, unicode, 0, &glyph) && hb_font_get_glyph_h_advance (font, glyph) == 0;
128 : }
129 :
130 : static void
131 0 : preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
132 : hb_buffer_t *buffer,
133 : hb_font_t *font)
134 : {
135 0 : 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 0 : buffer->clear_output ();
186 0 : unsigned int start = 0, end = 0; /* Extent of most recently seen syllable;
187 : * valid only if start < end
188 : */
189 0 : unsigned int count = buffer->len;
190 :
191 0 : for (buffer->idx = 0; buffer->idx < count && !buffer->in_error;)
192 : {
193 0 : hb_codepoint_t u = buffer->cur().codepoint;
194 :
195 0 : 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 0 : 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 0 : buffer->next_glyph ();
206 0 : if (!is_zero_width_char (font, u))
207 : {
208 0 : buffer->merge_out_clusters (start, end + 1);
209 0 : hb_glyph_info_t *info = buffer->out_info;
210 0 : hb_glyph_info_t tone = info[end];
211 0 : memmove (&info[start + 1], &info[start], (end - start) * sizeof (hb_glyph_info_t));
212 0 : info[start] = tone;
213 0 : }
214 : }
215 : else
216 : {
217 : /* No valid syllable as base for tone mark; try to insert dotted circle. */
218 0 : if (font->has_glyph (0x25CCu))
219 : {
220 : hb_codepoint_t chars[2];
221 0 : if (!is_zero_width_char (font, u)) {
222 0 : chars[0] = u;
223 0 : chars[1] = 0x25CCu;
224 : } else {
225 0 : chars[0] = 0x25CCu;
226 0 : chars[1] = u;
227 : }
228 0 : buffer->replace_glyphs (1, 2, chars);
229 : }
230 : else
231 : {
232 : /* No dotted circle available in the font; just leave tone mark untouched. */
233 0 : buffer->next_glyph ();
234 : }
235 : }
236 0 : start = end = buffer->out_len;
237 0 : continue;
238 : }
239 :
240 0 : 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 0 : if (isL (u) && buffer->idx + 1 < count)
245 : {
246 0 : hb_codepoint_t l = u;
247 0 : hb_codepoint_t v = buffer->cur(+1).codepoint;
248 0 : if (isV (v))
249 : {
250 : /* Have <L,V> or <L,V,T>. */
251 0 : hb_codepoint_t t = 0;
252 0 : unsigned int tindex = 0;
253 0 : if (buffer->idx + 2 < count)
254 : {
255 0 : t = buffer->cur(+2).codepoint;
256 0 : if (isT (t))
257 0 : tindex = t - TBase; /* Only used if isCombiningT (t); otherwise invalid. */
258 : else
259 0 : 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 0 : if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t)))
264 : {
265 : /* Try to compose; if this succeeds, end is set to start+1. */
266 0 : hb_codepoint_t s = SBase + (l - LBase) * NCount + (v - VBase) * TCount + tindex;
267 0 : if (font->has_glyph (s))
268 : {
269 0 : buffer->replace_glyphs (t ? 3 : 2, 1, &s);
270 0 : if (unlikely (buffer->in_error))
271 0 : return;
272 0 : end = start + 1;
273 0 : 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 0 : buffer->cur().hangul_shaping_feature() = LJMO;
283 0 : buffer->next_glyph ();
284 0 : buffer->cur().hangul_shaping_feature() = VJMO;
285 0 : buffer->next_glyph ();
286 0 : if (t)
287 : {
288 0 : buffer->cur().hangul_shaping_feature() = TJMO;
289 0 : buffer->next_glyph ();
290 0 : end = start + 3;
291 : }
292 : else
293 0 : end = start + 2;
294 0 : if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
295 0 : buffer->merge_out_clusters (start, end);
296 0 : continue;
297 : }
298 : }
299 :
300 0 : else if (isCombinedS (u))
301 : {
302 : /* Have <LV>, <LVT>, or <LV,T> */
303 0 : hb_codepoint_t s = u;
304 0 : bool has_glyph = font->has_glyph (s);
305 0 : unsigned int lindex = (s - SBase) / NCount;
306 0 : unsigned int nindex = (s - SBase) % NCount;
307 0 : unsigned int vindex = nindex / TCount;
308 0 : unsigned int tindex = nindex % TCount;
309 :
310 0 : if (!tindex &&
311 0 : buffer->idx + 1 < count &&
312 0 : isCombiningT (buffer->cur(+1).codepoint))
313 : {
314 : /* <LV,T>, try to combine. */
315 0 : unsigned int new_tindex = buffer->cur(+1).codepoint - TBase;
316 0 : hb_codepoint_t new_s = s + new_tindex;
317 0 : if (font->has_glyph (new_s))
318 : {
319 0 : buffer->replace_glyphs (2, 1, &new_s);
320 0 : if (unlikely (buffer->in_error))
321 0 : return;
322 0 : end = start + 1;
323 0 : 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 0 : if (!has_glyph ||
331 0 : (!tindex &&
332 0 : buffer->idx + 1 < count &&
333 0 : isT (buffer->cur(+1).codepoint)))
334 : {
335 0 : hb_codepoint_t decomposed[3] = {LBase + lindex,
336 0 : VBase + vindex,
337 0 : TBase + tindex};
338 0 : if (font->has_glyph (decomposed[0]) &&
339 0 : font->has_glyph (decomposed[1]) &&
340 0 : (!tindex || font->has_glyph (decomposed[2])))
341 : {
342 0 : unsigned int s_len = tindex ? 3 : 2;
343 0 : buffer->replace_glyphs (1, s_len, decomposed);
344 0 : if (unlikely (buffer->in_error))
345 0 : return;
346 :
347 : /* We decomposed S: apply jamo features to the individual glyphs
348 : * that are now in buffer->out_info.
349 : */
350 0 : 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 0 : if (has_glyph && !tindex)
356 : {
357 0 : buffer->next_glyph ();
358 0 : s_len++;
359 : }
360 0 : end = start + s_len;
361 :
362 0 : unsigned int i = start;
363 0 : info[i++].hangul_shaping_feature() = LJMO;
364 0 : info[i++].hangul_shaping_feature() = VJMO;
365 0 : if (i < end)
366 0 : info[i++].hangul_shaping_feature() = TJMO;
367 0 : if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
368 0 : buffer->merge_out_clusters (start, end);
369 0 : continue;
370 : }
371 : }
372 :
373 0 : if (has_glyph)
374 : {
375 : /* We didn't decompose the S, so just advance past it. */
376 0 : end = start + 1;
377 0 : buffer->next_glyph ();
378 0 : 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 0 : buffer->next_glyph ();
386 : }
387 0 : buffer->swap_buffers ();
388 : }
389 :
390 : static void
391 0 : setup_masks_hangul (const hb_ot_shape_plan_t *plan,
392 : hb_buffer_t *buffer,
393 : hb_font_t *font HB_UNUSED)
394 : {
395 0 : const hangul_shape_plan_t *hangul_plan = (const hangul_shape_plan_t *) plan->data;
396 :
397 0 : if (likely (hangul_plan))
398 : {
399 0 : unsigned int count = buffer->len;
400 0 : hb_glyph_info_t *info = buffer->info;
401 0 : for (unsigned int i = 0; i < count; i++, info++)
402 0 : info->mask |= hangul_plan->mask_array[info->hangul_shaping_feature()];
403 : }
404 :
405 0 : HB_BUFFER_DEALLOCATE_VAR (buffer, hangul_shaping_feature);
406 0 : }
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 : };
|
