Skip to main content

harfrust/ot/shaper/
vowel_constraints.rs

1/* == Start of generated functions == */
2// WARNING: this file was generated by ../../harfbuzz/src/gen-vowel-constraints.py --rust
3
4#![allow(clippy::single_match)]
5
6use crate::buffer::Buffer;
7use crate::BufferFlags;
8use crate::Script;
9
10/// The glyph `i` places past the current one, or 0, which matches nothing.
11fn cur_glyph(buffer: &Buffer, i: usize) -> u32 {
12    buffer.cur(i).map_or(0, |info| info.glyph_id)
13}
14
15fn output_dotted_circle(buffer: &mut Buffer) {
16    buffer.output_glyph(0x25CC);
17    {
18        let out_idx = buffer.out_len - 1;
19        if let Some(info) = buffer.out_info_mut().get_mut(out_idx) {
20            info.clear_continuation();
21        }
22    }
23}
24
25fn output_with_dotted_circle(buffer: &mut Buffer) {
26    output_dotted_circle(buffer);
27    buffer.next_glyph();
28}
29
30pub fn preprocess_text_vowel_constraints(buffer: &mut Buffer) {
31    if buffer
32        .flags
33        .contains(BufferFlags::DO_NOT_INSERT_DOTTED_CIRCLE)
34    {
35        return;
36    }
37
38    // UGLY UGLY UGLY business of adding dotted-circle in the middle of
39    // vowel-sequences that look like another vowel.  Data for each script
40    // collected from the USE script development spec.
41    //
42    // https://github.com/harfbuzz/harfbuzz/issues/1019
43    buffer.clear_output();
44    match buffer.script {
45        Some(Script::DEVANAGARI) => {
46            buffer.idx = 0;
47            while buffer.idx + 1 < buffer.len {
48                #[allow(unused_mut)]
49                let mut matched = false;
50                match cur_glyph(buffer, 0) {
51                    0x0905 => match cur_glyph(buffer, 1) {
52                        0x093A | 0x093B | 0x093E | 0x0945 | 0x0946 | 0x0949 | 0x094A | 0x094B
53                        | 0x094C | 0x094F | 0x0956 | 0x0957 => {
54                            matched = true;
55                        }
56                        _ => {}
57                    },
58                    0x0906 => match cur_glyph(buffer, 1) {
59                        0x093A | 0x0945 | 0x0946 | 0x0947 | 0x0948 => {
60                            matched = true;
61                        }
62                        _ => {}
63                    },
64                    0x0909 => {
65                        matched = 0x0941 == cur_glyph(buffer, 1);
66                    }
67                    0x090F => match cur_glyph(buffer, 1) {
68                        0x0945 | 0x0946 | 0x0947 => {
69                            matched = true;
70                        }
71                        _ => {}
72                    },
73                    0x0930 => {
74                        if 0x094D == cur_glyph(buffer, 1)
75                            && buffer.idx + 2 < buffer.len
76                            && 0x0907 == cur_glyph(buffer, 2)
77                        {
78                            buffer.next_glyph();
79                            buffer.next_glyph();
80                            output_dotted_circle(buffer);
81                        }
82                    }
83                    _ => {}
84                }
85                buffer.next_glyph();
86                if matched {
87                    output_with_dotted_circle(buffer);
88                }
89            }
90        }
91
92        Some(Script::BENGALI) => {
93            buffer.idx = 0;
94            while buffer.idx + 1 < buffer.len {
95                #[allow(unused_mut)]
96                let mut matched = false;
97                match cur_glyph(buffer, 0) {
98                    0x0985 => {
99                        matched = 0x09BE == cur_glyph(buffer, 1);
100                    }
101                    0x098B => {
102                        matched = 0x09C3 == cur_glyph(buffer, 1);
103                    }
104                    0x098C => {
105                        matched = 0x09E2 == cur_glyph(buffer, 1);
106                    }
107                    _ => {}
108                }
109                buffer.next_glyph();
110                if matched {
111                    output_with_dotted_circle(buffer);
112                }
113            }
114        }
115
116        Some(Script::GURMUKHI) => {
117            buffer.idx = 0;
118            while buffer.idx + 1 < buffer.len {
119                #[allow(unused_mut)]
120                let mut matched = false;
121                match cur_glyph(buffer, 0) {
122                    0x0A05 => match cur_glyph(buffer, 1) {
123                        0x0A3E | 0x0A48 | 0x0A4C => {
124                            matched = true;
125                        }
126                        _ => {}
127                    },
128                    0x0A72 => match cur_glyph(buffer, 1) {
129                        0x0A3F | 0x0A40 | 0x0A47 => {
130                            matched = true;
131                        }
132                        _ => {}
133                    },
134                    0x0A73 => match cur_glyph(buffer, 1) {
135                        0x0A41 | 0x0A42 | 0x0A4B => {
136                            matched = true;
137                        }
138                        _ => {}
139                    },
140                    _ => {}
141                }
142                buffer.next_glyph();
143                if matched {
144                    output_with_dotted_circle(buffer);
145                }
146            }
147        }
148
149        Some(Script::GUJARATI) => {
150            buffer.idx = 0;
151            while buffer.idx + 1 < buffer.len {
152                #[allow(unused_mut)]
153                let mut matched = false;
154                match cur_glyph(buffer, 0) {
155                    0x0A85 => match cur_glyph(buffer, 1) {
156                        0x0ABE | 0x0AC5 | 0x0AC7 | 0x0AC8 | 0x0AC9 | 0x0ACB | 0x0ACC => {
157                            matched = true;
158                        }
159                        _ => {}
160                    },
161                    0x0AC5 => {
162                        matched = 0x0ABE == cur_glyph(buffer, 1);
163                    }
164                    _ => {}
165                }
166                buffer.next_glyph();
167                if matched {
168                    output_with_dotted_circle(buffer);
169                }
170            }
171        }
172
173        Some(Script::ORIYA) => {
174            buffer.idx = 0;
175            while buffer.idx + 1 < buffer.len {
176                #[allow(unused_mut)]
177                let mut matched = false;
178                match cur_glyph(buffer, 0) {
179                    0x0B05 => {
180                        matched = 0x0B3E == cur_glyph(buffer, 1);
181                    }
182                    0x0B0F | 0x0B13 => {
183                        matched = 0x0B57 == cur_glyph(buffer, 1);
184                    }
185                    _ => {}
186                }
187                buffer.next_glyph();
188                if matched {
189                    output_with_dotted_circle(buffer);
190                }
191            }
192        }
193
194        Some(Script::TAMIL) => {
195            buffer.idx = 0;
196            while buffer.idx + 1 < buffer.len {
197                #[allow(unused_mut)]
198                let mut matched = false;
199                if 0x0B85 == cur_glyph(buffer, 0) && 0x0BC2 == cur_glyph(buffer, 1) {
200                    buffer.next_glyph();
201                    output_dotted_circle(buffer);
202                }
203                buffer.next_glyph();
204                if matched {
205                    output_with_dotted_circle(buffer);
206                }
207            }
208        }
209
210        Some(Script::TELUGU) => {
211            buffer.idx = 0;
212            while buffer.idx + 1 < buffer.len {
213                #[allow(unused_mut)]
214                let mut matched = false;
215                match cur_glyph(buffer, 0) {
216                    0x0C12 => match cur_glyph(buffer, 1) {
217                        0x0C4C | 0x0C55 => {
218                            matched = true;
219                        }
220                        _ => {}
221                    },
222                    0x0C3F | 0x0C46 | 0x0C4A => {
223                        matched = 0x0C55 == cur_glyph(buffer, 1);
224                    }
225                    _ => {}
226                }
227                buffer.next_glyph();
228                if matched {
229                    output_with_dotted_circle(buffer);
230                }
231            }
232        }
233
234        Some(Script::KANNADA) => {
235            buffer.idx = 0;
236            while buffer.idx + 1 < buffer.len {
237                #[allow(unused_mut)]
238                let mut matched = false;
239                match cur_glyph(buffer, 0) {
240                    0x0C89 | 0x0C8B => {
241                        matched = 0x0CBE == cur_glyph(buffer, 1);
242                    }
243                    0x0C92 => {
244                        matched = 0x0CCC == cur_glyph(buffer, 1);
245                    }
246                    _ => {}
247                }
248                buffer.next_glyph();
249                if matched {
250                    output_with_dotted_circle(buffer);
251                }
252            }
253        }
254
255        Some(Script::MALAYALAM) => {
256            buffer.idx = 0;
257            while buffer.idx + 1 < buffer.len {
258                #[allow(unused_mut)]
259                let mut matched = false;
260                match cur_glyph(buffer, 0) {
261                    0x0D07 | 0x0D09 => {
262                        matched = 0x0D57 == cur_glyph(buffer, 1);
263                    }
264                    0x0D0E => {
265                        matched = 0x0D46 == cur_glyph(buffer, 1);
266                    }
267                    0x0D12 => match cur_glyph(buffer, 1) {
268                        0x0D3E | 0x0D57 => {
269                            matched = true;
270                        }
271                        _ => {}
272                    },
273                    _ => {}
274                }
275                buffer.next_glyph();
276                if matched {
277                    output_with_dotted_circle(buffer);
278                }
279            }
280        }
281
282        Some(Script::SINHALA) => {
283            buffer.idx = 0;
284            while buffer.idx + 1 < buffer.len {
285                #[allow(unused_mut)]
286                let mut matched = false;
287                match cur_glyph(buffer, 0) {
288                    0x0D85 => match cur_glyph(buffer, 1) {
289                        0x0DCF | 0x0DD0 | 0x0DD1 => {
290                            matched = true;
291                        }
292                        _ => {}
293                    },
294                    0x0D8B | 0x0D8F | 0x0D94 => {
295                        matched = 0x0DDF == cur_glyph(buffer, 1);
296                    }
297                    0x0D8D => {
298                        matched = 0x0DD8 == cur_glyph(buffer, 1);
299                    }
300                    0x0D91 => match cur_glyph(buffer, 1) {
301                        0x0DCA | 0x0DD9 | 0x0DDA | 0x0DDC | 0x0DDD | 0x0DDE => {
302                            matched = true;
303                        }
304                        _ => {}
305                    },
306                    _ => {}
307                }
308                buffer.next_glyph();
309                if matched {
310                    output_with_dotted_circle(buffer);
311                }
312            }
313        }
314
315        Some(Script::BRAHMI) => {
316            buffer.idx = 0;
317            while buffer.idx + 1 < buffer.len {
318                #[allow(unused_mut)]
319                let mut matched = false;
320                match cur_glyph(buffer, 0) {
321                    0x11005 => {
322                        matched = 0x11038 == cur_glyph(buffer, 1);
323                    }
324                    0x1100B => {
325                        matched = 0x1103E == cur_glyph(buffer, 1);
326                    }
327                    0x1100F => {
328                        matched = 0x11042 == cur_glyph(buffer, 1);
329                    }
330                    _ => {}
331                }
332                buffer.next_glyph();
333                if matched {
334                    output_with_dotted_circle(buffer);
335                }
336            }
337        }
338
339        Some(Script::KHOJKI) => {
340            buffer.idx = 0;
341            while buffer.idx + 1 < buffer.len {
342                #[allow(unused_mut)]
343                let mut matched = false;
344                match cur_glyph(buffer, 0) {
345                    0x11200 => match cur_glyph(buffer, 1) {
346                        0x1122C | 0x11231 | 0x11233 => {
347                            matched = true;
348                        }
349                        _ => {}
350                    },
351                    0x11206 => {
352                        matched = 0x1122C == cur_glyph(buffer, 1);
353                    }
354                    0x1122C => match cur_glyph(buffer, 1) {
355                        0x11230 | 0x11231 => {
356                            matched = true;
357                        }
358                        _ => {}
359                    },
360                    0x11240 => {
361                        matched = 0x1122E == cur_glyph(buffer, 1);
362                    }
363                    _ => {}
364                }
365                buffer.next_glyph();
366                if matched {
367                    output_with_dotted_circle(buffer);
368                }
369            }
370        }
371
372        Some(Script::KHUDAWADI) => {
373            buffer.idx = 0;
374            while buffer.idx + 1 < buffer.len {
375                #[allow(unused_mut)]
376                let mut matched = false;
377                match cur_glyph(buffer, 0) {
378                    0x112B0 => match cur_glyph(buffer, 1) {
379                        0x112E0 | 0x112E5 | 0x112E6 | 0x112E7 | 0x112E8 => {
380                            matched = true;
381                        }
382                        _ => {}
383                    },
384                    _ => {}
385                }
386                buffer.next_glyph();
387                if matched {
388                    output_with_dotted_circle(buffer);
389                }
390            }
391        }
392
393        Some(Script::TIRHUTA) => {
394            buffer.idx = 0;
395            while buffer.idx + 1 < buffer.len {
396                #[allow(unused_mut)]
397                let mut matched = false;
398                match cur_glyph(buffer, 0) {
399                    0x11481 => {
400                        matched = 0x114B0 == cur_glyph(buffer, 1);
401                    }
402                    0x1148B | 0x1148D => {
403                        matched = 0x114BA == cur_glyph(buffer, 1);
404                    }
405                    0x114AA => match cur_glyph(buffer, 1) {
406                        0x114B5 | 0x114B6 => {
407                            matched = true;
408                        }
409                        _ => {}
410                    },
411                    _ => {}
412                }
413                buffer.next_glyph();
414                if matched {
415                    output_with_dotted_circle(buffer);
416                }
417            }
418        }
419
420        Some(Script::MODI) => {
421            buffer.idx = 0;
422            while buffer.idx + 1 < buffer.len {
423                #[allow(unused_mut)]
424                let mut matched = false;
425                match cur_glyph(buffer, 0) {
426                    0x11600 | 0x11601 => match cur_glyph(buffer, 1) {
427                        0x11639 | 0x1163A => {
428                            matched = true;
429                        }
430                        _ => {}
431                    },
432                    _ => {}
433                }
434                buffer.next_glyph();
435                if matched {
436                    output_with_dotted_circle(buffer);
437                }
438            }
439        }
440
441        Some(Script::TAKRI) => {
442            buffer.idx = 0;
443            while buffer.idx + 1 < buffer.len {
444                #[allow(unused_mut)]
445                let mut matched = false;
446                match cur_glyph(buffer, 0) {
447                    0x11680 => match cur_glyph(buffer, 1) {
448                        0x116AD | 0x116B4 | 0x116B5 => {
449                            matched = true;
450                        }
451                        _ => {}
452                    },
453                    0x11686 => {
454                        matched = 0x116B2 == cur_glyph(buffer, 1);
455                    }
456                    _ => {}
457                }
458                buffer.next_glyph();
459                if matched {
460                    output_with_dotted_circle(buffer);
461                }
462            }
463        }
464
465        _ => {}
466    }
467    buffer.sync();
468}
469/* == End of generated functions == */