Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/harfbuzz/src/hb-ot-shaper-hangul.cc @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
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.hh"
28
29 #ifndef HB_NO_OT_SHAPE
30
31 #include "hb-ot-shaper.hh"
32
33
34 /* Hangul shaper */
35
36
37 /* Same order as the feature array below */
38 enum {
39 _JMO,
40
41 LJMO,
42 VJMO,
43 TJMO,
44
45 FIRST_HANGUL_FEATURE = LJMO,
46 HANGUL_FEATURE_COUNT = TJMO + 1
47 };
48
49 static const hb_tag_t hangul_features[HANGUL_FEATURE_COUNT] =
50 {
51 HB_TAG_NONE,
52 HB_TAG('l','j','m','o'),
53 HB_TAG('v','j','m','o'),
54 HB_TAG('t','j','m','o')
55 };
56
57 static void
58 collect_features_hangul (hb_ot_shape_planner_t *plan)
59 {
60 hb_ot_map_builder_t *map = &plan->map;
61
62 for (unsigned int i = FIRST_HANGUL_FEATURE; i < HANGUL_FEATURE_COUNT; i++)
63 map->add_feature (hangul_features[i]);
64 }
65
66 static void
67 override_features_hangul (hb_ot_shape_planner_t *plan)
68 {
69 /* Uniscribe does not apply 'calt' for Hangul, and certain fonts
70 * (Noto Sans CJK, Source Sans Han, etc) apply all of jamo lookups
71 * in calt, which is not desirable. */
72 plan->map.disable_feature (HB_TAG('c','a','l','t'));
73 }
74
75 struct hangul_shape_plan_t
76 {
77 hb_mask_t mask_array[HANGUL_FEATURE_COUNT];
78 };
79
80 static void *
81 data_create_hangul (const hb_ot_shape_plan_t *plan)
82 {
83 hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) hb_calloc (1, sizeof (hangul_shape_plan_t));
84 if (unlikely (!hangul_plan))
85 return nullptr;
86
87 for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++)
88 hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]);
89
90 return hangul_plan;
91 }
92
93 static void
94 data_destroy_hangul (void *data)
95 {
96 hb_free (data);
97 }
98
99 /* Constants for algorithmic hangul syllable [de]composition. */
100 #define LBase 0x1100u
101 #define VBase 0x1161u
102 #define TBase 0x11A7u
103 #define LCount 19u
104 #define VCount 21u
105 #define TCount 28u
106 #define SBase 0xAC00u
107 #define NCount (VCount * TCount)
108 #define SCount (LCount * NCount)
109
110 #define isCombiningL(u) (hb_in_range<hb_codepoint_t> ((u), LBase, LBase+LCount-1))
111 #define isCombiningV(u) (hb_in_range<hb_codepoint_t> ((u), VBase, VBase+VCount-1))
112 #define isCombiningT(u) (hb_in_range<hb_codepoint_t> ((u), TBase+1, TBase+TCount-1))
113 #define isCombinedS(u) (hb_in_range<hb_codepoint_t> ((u), SBase, SBase+SCount-1))
114
115 #define isL(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1100u, 0x115Fu, 0xA960u, 0xA97Cu))
116 #define isV(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1160u, 0x11A7u, 0xD7B0u, 0xD7C6u))
117 #define isT(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x11A8u, 0x11FFu, 0xD7CBu, 0xD7FBu))
118
119 #define isHangulTone(u) (hb_in_range<hb_codepoint_t> ((u), 0x302Eu, 0x302Fu))
120
121 /* buffer var allocations */
122 #define hangul_shaping_feature() ot_shaper_var_u8_auxiliary() /* hangul jamo shaping feature */
123
124 static bool
125 is_zero_width_char (hb_font_t *font,
126 hb_codepoint_t unicode)
127 {
128 hb_codepoint_t glyph;
129 return hb_font_get_glyph (font, unicode, 0, &glyph) && hb_font_get_glyph_h_advance (font, glyph) == 0;
130 }
131
132 static void
133 preprocess_text_hangul (const hb_ot_shape_plan_t *plan HB_UNUSED,
134 hb_buffer_t *buffer,
135 hb_font_t *font)
136 {
137 HB_BUFFER_ALLOCATE_VAR (buffer, hangul_shaping_feature);
138
139 /* Hangul syllables come in two shapes: LV, and LVT. Of those:
140 *
141 * - LV can be precomposed, or decomposed. Lets call those
142 * <LV> and <L,V>,
143 * - LVT can be fully precomposed, partially precomposed, or
144 * fully decomposed. Ie. <LVT>, <LV,T>, or <L,V,T>.
145 *
146 * The composition / decomposition is mechanical. However, not
147 * all <L,V> sequences compose, and not all <LV,T> sequences
148 * compose.
149 *
150 * Here are the specifics:
151 *
152 * - <L>: U+1100..115F, U+A960..A97F
153 * - <V>: U+1160..11A7, U+D7B0..D7C7
154 * - <T>: U+11A8..11FF, U+D7CB..D7FB
155 *
156 * - Only the <L,V> sequences for some of the U+11xx ranges combine.
157 * - Only <LV,T> sequences for some of the Ts in U+11xx range combine.
158 *
159 * Here is what we want to accomplish in this shaper:
160 *
161 * - If the whole syllable can be precomposed, do that,
162 * - Otherwise, fully decompose and apply ljmo/vjmo/tjmo features.
163 * - If a valid syllable is followed by a Hangul tone mark, reorder the tone
164 * mark to precede the whole syllable - unless it is a zero-width glyph, in
165 * which case we leave it untouched, assuming it's designed to overstrike.
166 *
167 * That is, of the different possible syllables:
168 *
169 * <L>
170 * <L,V>
171 * <L,V,T>
172 * <LV>
173 * <LVT>
174 * <LV, T>
175 *
176 * - <L> needs no work.
177 *
178 * - <LV> and <LVT> can stay the way they are if the font supports them, otherwise we
179 * should fully decompose them if font supports.
180 *
181 * - <L,V> and <L,V,T> we should compose if the whole thing can be composed.
182 *
183 * - <LV,T> we should compose if the whole thing can be composed, otherwise we should
184 * decompose.
185 */
186
187 buffer->clear_output ();
188 unsigned int start = 0, end = 0; /* Extent of most recently seen syllable;
189 * valid only if start < end
190 */
191 unsigned int count = buffer->len;
192
193 for (buffer->idx = 0; buffer->idx < count && buffer->successful;)
194 {
195 hb_codepoint_t u = buffer->cur().codepoint;
196
197 if (isHangulTone (u))
198 {
199 /*
200 * We could cache the width of the tone marks and the existence of dotted-circle,
201 * but the use of the Hangul tone mark characters seems to be rare enough that
202 * I didn't bother for now.
203 */
204 if (start < end && end == buffer->out_len)
205 {
206 /* Tone mark follows a valid syllable; move it in front, unless it's zero width. */
207 buffer->unsafe_to_break_from_outbuffer (start, buffer->idx);
208 if (unlikely (!buffer->next_glyph ())) break;
209 if (!is_zero_width_char (font, u))
210 {
211 buffer->merge_out_clusters (start, end + 1);
212 hb_glyph_info_t *info = buffer->out_info;
213 hb_glyph_info_t tone = info[end];
214 memmove (&info[start + 1], &info[start], (end - start) * sizeof (hb_glyph_info_t));
215 info[start] = tone;
216 }
217 }
218 else
219 {
220 /* No valid syllable as base for tone mark; try to insert dotted circle. */
221 if (!(buffer->flags & HB_BUFFER_FLAG_DO_NOT_INSERT_DOTTED_CIRCLE) &&
222 font->has_glyph (0x25CCu))
223 {
224 hb_codepoint_t chars[2];
225 if (!is_zero_width_char (font, u))
226 {
227 chars[0] = u;
228 chars[1] = 0x25CCu;
229 } else
230 {
231 chars[0] = 0x25CCu;
232 chars[1] = u;
233 }
234 (void) buffer->replace_glyphs (1, 2, chars);
235 }
236 else
237 {
238 /* No dotted circle available in the font; just leave tone mark untouched. */
239 (void) buffer->next_glyph ();
240 }
241 }
242 start = end = buffer->out_len;
243 continue;
244 }
245
246 start = buffer->out_len; /* Remember current position as a potential syllable start;
247 * will only be used if we set end to a later position.
248 */
249
250 if (isL (u) && buffer->idx + 1 < count)
251 {
252 hb_codepoint_t l = u;
253 hb_codepoint_t v = buffer->cur(+1).codepoint;
254 if (isV (v))
255 {
256 /* Have <L,V> or <L,V,T>. */
257 hb_codepoint_t t = 0;
258 unsigned int tindex = 0;
259 if (buffer->idx + 2 < count)
260 {
261 t = buffer->cur(+2).codepoint;
262 if (isT (t))
263 tindex = t - TBase; /* Only used if isCombiningT (t); otherwise invalid. */
264 else
265 t = 0; /* The next character was not a trailing jamo. */
266 }
267 buffer->unsafe_to_break (buffer->idx, buffer->idx + (t ? 3 : 2));
268
269 /* We've got a syllable <L,V,T?>; see if it can potentially be composed. */
270 if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t)))
271 {
272 /* Try to compose; if this succeeds, end is set to start+1. */
273 hb_codepoint_t s = SBase + (l - LBase) * NCount + (v - VBase) * TCount + tindex;
274 if (font->has_glyph (s))
275 {
276 (void) buffer->replace_glyphs (t ? 3 : 2, 1, &s);
277 end = start + 1;
278 continue;
279 }
280 }
281
282 /* We didn't compose, either because it's an Old Hangul syllable without a
283 * precomposed character in Unicode, or because the font didn't support the
284 * necessary precomposed glyph.
285 * Set jamo features on the individual glyphs, and advance past them.
286 */
287 buffer->cur().hangul_shaping_feature() = LJMO;
288 (void) buffer->next_glyph ();
289 buffer->cur().hangul_shaping_feature() = VJMO;
290 (void) buffer->next_glyph ();
291 if (t)
292 {
293 buffer->cur().hangul_shaping_feature() = TJMO;
294 (void) buffer->next_glyph ();
295 end = start + 3;
296 }
297 else
298 end = start + 2;
299 if (unlikely (!buffer->successful))
300 break;
301 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
302 buffer->merge_out_clusters (start, end);
303 continue;
304 }
305 }
306
307 else if (isCombinedS (u))
308 {
309 /* Have <LV>, <LVT>, or <LV,T> */
310 hb_codepoint_t s = u;
311 bool has_glyph = font->has_glyph (s);
312 unsigned int lindex = (s - SBase) / NCount;
313 unsigned int nindex = (s - SBase) % NCount;
314 unsigned int vindex = nindex / TCount;
315 unsigned int tindex = nindex % TCount;
316
317 if (!tindex &&
318 buffer->idx + 1 < count &&
319 isCombiningT (buffer->cur(+1).codepoint))
320 {
321 /* <LV,T>, try to combine. */
322 unsigned int new_tindex = buffer->cur(+1).codepoint - TBase;
323 hb_codepoint_t new_s = s + new_tindex;
324 if (font->has_glyph (new_s))
325 {
326 (void) buffer->replace_glyphs (2, 1, &new_s);
327 end = start + 1;
328 continue;
329 }
330 else
331 buffer->unsafe_to_break (buffer->idx, buffer->idx + 2); /* Mark unsafe between LV and T. */
332 }
333
334 /* Otherwise, decompose if font doesn't support <LV> or <LVT>,
335 * or if having non-combining <LV,T>. Note that we already handled
336 * combining <LV,T> above. */
337 if (!has_glyph ||
338 (!tindex &&
339 buffer->idx + 1 < count &&
340 isT (buffer->cur(+1).codepoint)))
341 {
342 hb_codepoint_t decomposed[3] = {LBase + lindex,
343 VBase + vindex,
344 TBase + tindex};
345 if (font->has_glyph (decomposed[0]) &&
346 font->has_glyph (decomposed[1]) &&
347 (!tindex || font->has_glyph (decomposed[2])))
348 {
349 unsigned int s_len = tindex ? 3 : 2;
350 (void) buffer->replace_glyphs (1, s_len, decomposed);
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 (void) buffer->next_glyph ();
358 s_len++;
359 }
360 if (unlikely (!buffer->successful))
361 break;
362
363 /* We decomposed S: apply jamo features to the individual glyphs
364 * that are now in buffer->out_info.
365 */
366 hb_glyph_info_t *info = buffer->out_info;
367 end = start + s_len;
368
369 unsigned int i = start;
370 info[i++].hangul_shaping_feature() = LJMO;
371 info[i++].hangul_shaping_feature() = VJMO;
372 if (i < end)
373 info[i++].hangul_shaping_feature() = TJMO;
374
375 if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
376 buffer->merge_out_clusters (start, end);
377 continue;
378 }
379 else if ((!tindex && buffer->idx + 1 < count && isT (buffer->cur(+1).codepoint)))
380 buffer->unsafe_to_break (buffer->idx, buffer->idx + 2); /* Mark unsafe between LV and T. */
381 }
382
383 if (has_glyph)
384 {
385 /* We didn't decompose the S, so just advance past it and fall through. */
386 end = start + 1;
387 }
388 }
389
390 /* Didn't find a recognizable syllable, so we leave end <= start;
391 * this will prevent tone-mark reordering happening.
392 */
393 (void) buffer->next_glyph ();
394 }
395 buffer->sync ();
396 }
397
398 static void
399 setup_masks_hangul (const hb_ot_shape_plan_t *plan,
400 hb_buffer_t *buffer,
401 hb_font_t *font HB_UNUSED)
402 {
403 const hangul_shape_plan_t *hangul_plan = (const hangul_shape_plan_t *) plan->data;
404
405 if (likely (hangul_plan))
406 {
407 unsigned int count = buffer->len;
408 hb_glyph_info_t *info = buffer->info;
409 for (unsigned int i = 0; i < count; i++, info++)
410 info->mask |= hangul_plan->mask_array[info->hangul_shaping_feature()];
411 }
412
413 HB_BUFFER_DEALLOCATE_VAR (buffer, hangul_shaping_feature);
414 }
415
416
417 const hb_ot_shaper_t _hb_ot_shaper_hangul =
418 {
419 collect_features_hangul,
420 override_features_hangul,
421 data_create_hangul,
422 data_destroy_hangul,
423 preprocess_text_hangul,
424 nullptr, /* postprocess_glyphs */
425 nullptr, /* decompose */
426 nullptr, /* compose */
427 setup_masks_hangul,
428 nullptr, /* reorder_marks */
429 HB_TAG_NONE, /* gpos_tag */
430 HB_OT_SHAPE_NORMALIZATION_MODE_NONE,
431 HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
432 false, /* fallback_position */
433 };
434
435
436 #endif