The Tor Browser / file comparison

comparison: gfx/harfbuzz/src/hb-ot-shape-complex-myanmar.cc

gfx/harfbuzz/src/hb-ot-shape-complex-myanmar.cc

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:462fdb5dde3b
1 /*
2 * Copyright © 2011,2012,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-indic-private.hh"
28
29 /* buffer var allocations */
30 #define myanmar_category() complex_var_u8_0() /* myanmar_category_t */
31 #define myanmar_position() complex_var_u8_1() /* myanmar_position_t */
32
33
34 /*
35 * Myanmar shaper.
36 */
37
38 static const hb_tag_t
39 basic_features[] =
40 {
41 /*
42 * Basic features.
43 * These features are applied in order, one at a time, after initial_reordering.
44 */
45 HB_TAG('r','p','h','f'),
46 HB_TAG('p','r','e','f'),
47 HB_TAG('b','l','w','f'),
48 HB_TAG('p','s','t','f'),
49 };
50 static const hb_tag_t
51 other_features[] =
52 {
53 /*
54 * Other features.
55 * These features are applied all at once, after final_reordering.
56 */
57 HB_TAG('p','r','e','s'),
58 HB_TAG('a','b','v','s'),
59 HB_TAG('b','l','w','s'),
60 HB_TAG('p','s','t','s'),
61 /* Positioning features, though we don't care about the types. */
62 HB_TAG('d','i','s','t'),
63 /* Pre-release version of Windows 8 Myanmar font had abvm,blwm
64 * features. The released Windows 8 version of the font (as well
65 * as the released spec) used 'mark' instead. The Windows 8
66 * shaper however didn't apply 'mark' but did apply 'mkmk'.
67 * Perhaps it applied abvm/blwm. This was fixed in a Windows 8
68 * update, so now it applies mark/mkmk. We are guessing that
69 * it still applies abvm/blwm too.
70 */
71 HB_TAG('a','b','v','m'),
72 HB_TAG('b','l','w','m'),
73 };
74
75 static void
76 setup_syllables (const hb_ot_shape_plan_t *plan,
77 hb_font_t *font,
78 hb_buffer_t *buffer);
79 static void
80 initial_reordering (const hb_ot_shape_plan_t *plan,
81 hb_font_t *font,
82 hb_buffer_t *buffer);
83 static void
84 final_reordering (const hb_ot_shape_plan_t *plan,
85 hb_font_t *font,
86 hb_buffer_t *buffer);
87
88 static void
89 collect_features_myanmar (hb_ot_shape_planner_t *plan)
90 {
91 hb_ot_map_builder_t *map = &plan->map;
92
93 /* Do this before any lookups have been applied. */
94 map->add_gsub_pause (setup_syllables);
95
96 map->add_global_bool_feature (HB_TAG('l','o','c','l'));
97 /* The Indic specs do not require ccmp, but we apply it here since if
98 * there is a use of it, it's typically at the beginning. */
99 map->add_global_bool_feature (HB_TAG('c','c','m','p'));
100
101
102 map->add_gsub_pause (initial_reordering);
103 for (unsigned int i = 0; i < ARRAY_LENGTH (basic_features); i++)
104 {
105 map->add_feature (basic_features[i], 1, F_GLOBAL | F_MANUAL_ZWJ);
106 map->add_gsub_pause (NULL);
107 }
108 map->add_gsub_pause (final_reordering);
109 for (unsigned int i = 0; i < ARRAY_LENGTH (other_features); i++)
110 map->add_feature (other_features[i], 1, F_GLOBAL | F_MANUAL_ZWJ);
111 }
112
113 static void
114 override_features_myanmar (hb_ot_shape_planner_t *plan)
115 {
116 plan->map.add_feature (HB_TAG('l','i','g','a'), 0, F_GLOBAL);
117 }
118
119
120 enum syllable_type_t {
121 consonant_syllable,
122 punctuation_cluster,
123 broken_cluster,
124 non_myanmar_cluster,
125 };
126
127 #include "hb-ot-shape-complex-myanmar-machine.hh"
128
129
130 /* Note: This enum is duplicated in the -machine.rl source file.
131 * Not sure how to avoid duplication. */
132 enum myanmar_category_t {
133 OT_As = 18, /* Asat */
134 OT_D = 19, /* Digits except zero */
135 OT_D0 = 20, /* Digit zero */
136 OT_DB = OT_N, /* Dot below */
137 OT_GB = OT_DOTTEDCIRCLE,
138 OT_MH = 21, /* Various consonant medial types */
139 OT_MR = 22, /* Various consonant medial types */
140 OT_MW = 23, /* Various consonant medial types */
141 OT_MY = 24, /* Various consonant medial types */
142 OT_PT = 25, /* Pwo and other tones */
143 OT_VAbv = 26,
144 OT_VBlw = 27,
145 OT_VPre = 28,
146 OT_VPst = 29,
147 OT_VS = 30, /* Variation selectors */
148 OT_P = 31 /* Punctuation */
149 };
150
151
152 static inline bool
153 is_one_of (const hb_glyph_info_t &info, unsigned int flags)
154 {
155 /* If it ligated, all bets are off. */
156 if (_hb_glyph_info_ligated (&info)) return false;
157 return !!(FLAG (info.myanmar_category()) & flags);
158 }
159
160 /* Note:
161 *
162 * We treat Vowels and placeholders as if they were consonants. This is safe because Vowels
163 * cannot happen in a consonant syllable. The plus side however is, we can call the
164 * consonant syllable logic from the vowel syllable function and get it all right! */
165 #define CONSONANT_FLAGS (FLAG (OT_C) | FLAG (OT_CM) | FLAG (OT_Ra) | FLAG (OT_V) | FLAG (OT_NBSP) | FLAG (OT_GB))
166 static inline bool
167 is_consonant (const hb_glyph_info_t &info)
168 {
169 return is_one_of (info, CONSONANT_FLAGS);
170 }
171
172
173 static inline void
174 set_myanmar_properties (hb_glyph_info_t &info)
175 {
176 hb_codepoint_t u = info.codepoint;
177 unsigned int type = hb_indic_get_categories (u);
178 indic_category_t cat = (indic_category_t) (type & 0x7F);
179 indic_position_t pos = (indic_position_t) (type >> 8);
180
181 /* Myanmar
182 * http://www.microsoft.com/typography/OpenTypeDev/myanmar/intro.htm#analyze
183 */
184 if (unlikely (hb_in_range<hb_codepoint_t> (u, 0xFE00, 0xFE0F)))
185 cat = (indic_category_t) OT_VS;
186 else if (unlikely (u == 0x200C)) cat = (indic_category_t) OT_ZWNJ;
187 else if (unlikely (u == 0x200D)) cat = (indic_category_t) OT_ZWJ;
188
189 switch (u)
190 {
191 case 0x104E:
192 cat = (indic_category_t) OT_C; /* The spec says C, IndicSyllableCategory doesn't have. */
193 break;
194
195 case 0x002D: case 0x00A0: case 0x00D7: case 0x2012:
196 case 0x2013: case 0x2014: case 0x2015: case 0x2022:
197 case 0x25CC: case 0x25FB: case 0x25FC: case 0x25FD:
198 case 0x25FE:
199 cat = (indic_category_t) OT_GB;
200 break;
201
202 case 0x1004: case 0x101B: case 0x105A:
203 cat = (indic_category_t) OT_Ra;
204 break;
205
206 case 0x1032: case 0x1036:
207 cat = (indic_category_t) OT_A;
208 break;
209
210 case 0x103A:
211 cat = (indic_category_t) OT_As;
212 break;
213
214 case 0x1041: case 0x1042: case 0x1043: case 0x1044:
215 case 0x1045: case 0x1046: case 0x1047: case 0x1048:
216 case 0x1049: case 0x1090: case 0x1091: case 0x1092:
217 case 0x1093: case 0x1094: case 0x1095: case 0x1096:
218 case 0x1097: case 0x1098: case 0x1099:
219 cat = (indic_category_t) OT_D;
220 break;
221
222 case 0x1040:
223 cat = (indic_category_t) OT_D; /* XXX The spec says D0, but Uniscribe doesn't seem to do. */
224 break;
225
226 case 0x103E: case 0x1060:
227 cat = (indic_category_t) OT_MH;
228 break;
229
230 case 0x103C:
231 cat = (indic_category_t) OT_MR;
232 break;
233
234 case 0x103D: case 0x1082:
235 cat = (indic_category_t) OT_MW;
236 break;
237
238 case 0x103B: case 0x105E: case 0x105F:
239 cat = (indic_category_t) OT_MY;
240 break;
241
242 case 0x1063: case 0x1064: case 0x1069: case 0x106A:
243 case 0x106B: case 0x106C: case 0x106D: case 0xAA7B:
244 cat = (indic_category_t) OT_PT;
245 break;
246
247 case 0x1038: case 0x1087: case 0x1088: case 0x1089:
248 case 0x108A: case 0x108B: case 0x108C: case 0x108D:
249 case 0x108F: case 0x109A: case 0x109B: case 0x109C:
250 cat = (indic_category_t) OT_SM;
251 break;
252
253 case 0x104A: case 0x104B:
254 cat = (indic_category_t) OT_P;
255 break;
256 }
257
258 if (cat == OT_M)
259 {
260 switch ((int) pos)
261 {
262 case POS_PRE_C: cat = (indic_category_t) OT_VPre;
263 pos = POS_PRE_M; break;
264 case POS_ABOVE_C: cat = (indic_category_t) OT_VAbv; break;
265 case POS_BELOW_C: cat = (indic_category_t) OT_VBlw; break;
266 case POS_POST_C: cat = (indic_category_t) OT_VPst; break;
267 }
268 }
269
270 info.myanmar_category() = (myanmar_category_t) cat;
271 info.myanmar_position() = pos;
272 }
273
274
275
276 static void
277 setup_masks_myanmar (const hb_ot_shape_plan_t *plan HB_UNUSED,
278 hb_buffer_t *buffer,
279 hb_font_t *font HB_UNUSED)
280 {
281 HB_BUFFER_ALLOCATE_VAR (buffer, myanmar_category);
282 HB_BUFFER_ALLOCATE_VAR (buffer, myanmar_position);
283
284 /* We cannot setup masks here. We save information about characters
285 * and setup masks later on in a pause-callback. */
286
287 unsigned int count = buffer->len;
288 for (unsigned int i = 0; i < count; i++)
289 set_myanmar_properties (buffer->info[i]);
290 }
291
292 static void
293 setup_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,
294 hb_font_t *font HB_UNUSED,
295 hb_buffer_t *buffer)
296 {
297 find_syllables (buffer);
298 }
299
300 static int
301 compare_myanmar_order (const hb_glyph_info_t *pa, const hb_glyph_info_t *pb)
302 {
303 int a = pa->myanmar_position();
304 int b = pb->myanmar_position();
305
306 return a < b ? -1 : a == b ? 0 : +1;
307 }
308
309
310 /* Rules from:
311 * http://www.microsoft.com/typography/OpenTypeDev/myanmar/intro.htm */
312
313 static void
314 initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
315 hb_face_t *face,
316 hb_buffer_t *buffer,
317 unsigned int start, unsigned int end)
318 {
319 hb_glyph_info_t *info = buffer->info;
320
321 unsigned int base = end;
322 bool has_reph = false;
323
324 {
325 unsigned int limit = start;
326 if (start + 3 <= end &&
327 info[start ].myanmar_category() == OT_Ra &&
328 info[start+1].myanmar_category() == OT_As &&
329 info[start+2].myanmar_category() == OT_H)
330 {
331 limit += 3;
332 base = start;
333 has_reph = true;
334 }
335
336 {
337 if (!has_reph)
338 base = limit;
339
340 for (unsigned int i = limit; i < end; i++)
341 if (is_consonant (info[i]))
342 {
343 base = i;
344 break;
345 }
346 }
347 }
348
349 /* Reorder! */
350 {
351 unsigned int i = start;
352 for (; i < start + (has_reph ? 3 : 0); i++)
353 info[i].myanmar_position() = POS_AFTER_MAIN;
354 for (; i < base; i++)
355 info[i].myanmar_position() = POS_PRE_C;
356 if (i < end)
357 {
358 info[i].myanmar_position() = POS_BASE_C;
359 i++;
360 }
361 indic_position_t pos = POS_AFTER_MAIN;
362 /* The following loop may be ugly, but it implements all of
363 * Myanmar reordering! */
364 for (; i < end; i++)
365 {
366 if (info[i].myanmar_category() == OT_MR) /* Pre-base reordering */
367 {
368 info[i].myanmar_position() = POS_PRE_C;
369 continue;
370 }
371 if (info[i].myanmar_position() < POS_BASE_C) /* Left matra */
372 {
373 continue;
374 }
375
376 if (pos == POS_AFTER_MAIN && info[i].myanmar_category() == OT_VBlw)
377 {
378 pos = POS_BELOW_C;
379 info[i].myanmar_position() = pos;
380 continue;
381 }
382
383 if (pos == POS_BELOW_C && info[i].myanmar_category() == OT_A)
384 {
385 info[i].myanmar_position() = POS_BEFORE_SUB;
386 continue;
387 }
388 if (pos == POS_BELOW_C && info[i].myanmar_category() == OT_VBlw)
389 {
390 info[i].myanmar_position() = pos;
391 continue;
392 }
393 if (pos == POS_BELOW_C && info[i].myanmar_category() != OT_A)
394 {
395 pos = POS_AFTER_SUB;
396 info[i].myanmar_position() = pos;
397 continue;
398 }
399 info[i].myanmar_position() = pos;
400 }
401 }
402
403 buffer->merge_clusters (start, end);
404 /* Sit tight, rock 'n roll! */
405 hb_bubble_sort (info + start, end - start, compare_myanmar_order);
406 }
407
408 static void
409 initial_reordering_broken_cluster (const hb_ot_shape_plan_t *plan,
410 hb_face_t *face,
411 hb_buffer_t *buffer,
412 unsigned int start, unsigned int end)
413 {
414 /* We already inserted dotted-circles, so just call the consonant_syllable. */
415 initial_reordering_consonant_syllable (plan, face, buffer, start, end);
416 }
417
418 static void
419 initial_reordering_punctuation_cluster (const hb_ot_shape_plan_t *plan HB_UNUSED,
420 hb_face_t *face HB_UNUSED,
421 hb_buffer_t *buffer HB_UNUSED,
422 unsigned int start HB_UNUSED, unsigned int end HB_UNUSED)
423 {
424 /* Nothing to do right now. If we ever switch to using the output
425 * buffer in the reordering process, we'd need to next_glyph() here. */
426 }
427
428 static void
429 initial_reordering_non_myanmar_cluster (const hb_ot_shape_plan_t *plan HB_UNUSED,
430 hb_face_t *face HB_UNUSED,
431 hb_buffer_t *buffer HB_UNUSED,
432 unsigned int start HB_UNUSED, unsigned int end HB_UNUSED)
433 {
434 /* Nothing to do right now. If we ever switch to using the output
435 * buffer in the reordering process, we'd need to next_glyph() here. */
436 }
437
438
439 static void
440 initial_reordering_syllable (const hb_ot_shape_plan_t *plan,
441 hb_face_t *face,
442 hb_buffer_t *buffer,
443 unsigned int start, unsigned int end)
444 {
445 syllable_type_t syllable_type = (syllable_type_t) (buffer->info[start].syllable() & 0x0F);
446 switch (syllable_type) {
447 case consonant_syllable: initial_reordering_consonant_syllable (plan, face, buffer, start, end); return;
448 case punctuation_cluster: initial_reordering_punctuation_cluster (plan, face, buffer, start, end); return;
449 case broken_cluster: initial_reordering_broken_cluster (plan, face, buffer, start, end); return;
450 case non_myanmar_cluster: initial_reordering_non_myanmar_cluster (plan, face, buffer, start, end); return;
451 }
452 }
453
454 static inline void
455 insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
456 hb_font_t *font,
457 hb_buffer_t *buffer)
458 {
459 /* Note: This loop is extra overhead, but should not be measurable. */
460 bool has_broken_syllables = false;
461 unsigned int count = buffer->len;
462 for (unsigned int i = 0; i < count; i++)
463 if ((buffer->info[i].syllable() & 0x0F) == broken_cluster) {
464 has_broken_syllables = true;
465 break;
466 }
467 if (likely (!has_broken_syllables))
468 return;
469
470
471 hb_codepoint_t dottedcircle_glyph;
472 if (!font->get_glyph (0x25CC, 0, &dottedcircle_glyph))
473 return;
474
475 hb_glyph_info_t dottedcircle = {0};
476 dottedcircle.codepoint = 0x25CC;
477 set_myanmar_properties (dottedcircle);
478 dottedcircle.codepoint = dottedcircle_glyph;
479
480 buffer->clear_output ();
481
482 buffer->idx = 0;
483 unsigned int last_syllable = 0;
484 while (buffer->idx < buffer->len)
485 {
486 unsigned int syllable = buffer->cur().syllable();
487 syllable_type_t syllable_type = (syllable_type_t) (syllable & 0x0F);
488 if (unlikely (last_syllable != syllable && syllable_type == broken_cluster))
489 {
490 last_syllable = syllable;
491
492 hb_glyph_info_t info = dottedcircle;
493 info.cluster = buffer->cur().cluster;
494 info.mask = buffer->cur().mask;
495 info.syllable() = buffer->cur().syllable();
496
497 buffer->output_info (info);
498 }
499 else
500 buffer->next_glyph ();
501 }
502
503 buffer->swap_buffers ();
504 }
505
506 static void
507 initial_reordering (const hb_ot_shape_plan_t *plan,
508 hb_font_t *font,
509 hb_buffer_t *buffer)
510 {
511 insert_dotted_circles (plan, font, buffer);
512
513 hb_glyph_info_t *info = buffer->info;
514 unsigned int count = buffer->len;
515 if (unlikely (!count)) return;
516 unsigned int last = 0;
517 unsigned int last_syllable = info[0].syllable();
518 for (unsigned int i = 1; i < count; i++)
519 if (last_syllable != info[i].syllable()) {
520 initial_reordering_syllable (plan, font->face, buffer, last, i);
521 last = i;
522 last_syllable = info[last].syllable();
523 }
524 initial_reordering_syllable (plan, font->face, buffer, last, count);
525 }
526
527 static void
528 final_reordering (const hb_ot_shape_plan_t *plan,
529 hb_font_t *font HB_UNUSED,
530 hb_buffer_t *buffer)
531 {
532 hb_glyph_info_t *info = buffer->info;
533 unsigned int count = buffer->len;
534
535 /* Zero syllables now... */
536 for (unsigned int i = 0; i < count; i++)
537 info[i].syllable() = 0;
538
539 HB_BUFFER_DEALLOCATE_VAR (buffer, myanmar_category);
540 HB_BUFFER_DEALLOCATE_VAR (buffer, myanmar_position);
541 }
542
543
544 const hb_ot_complex_shaper_t _hb_ot_complex_shaper_myanmar =
545 {
546 "myanmar",
547 collect_features_myanmar,
548 override_features_myanmar,
549 NULL, /* data_create */
550 NULL, /* data_destroy */
551 NULL, /* preprocess_text */
552 HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
553 NULL, /* decompose */
554 NULL, /* compose */
555 setup_masks_myanmar,
556 HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY,
557 false, /* fallback_position */
558 };

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial