?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update README.md
[puttycyg-ng.git] / minibidi.c
blobc5c60a6087d087ebbb2cad45586fedb3d1dd439a
1 /************************************************************************
2 * $Id: minibidi.c 6910 2006-11-18 15:10:48Z simon $
3 *
4 * ------------
5 * Description:
6 * ------------
7 * This is an implemention of Unicode's Bidirectional Algorithm
8 * (known as UAX #9).
9 *
10 * http://www.unicode.org/reports/tr9/
11 *
12 * Author: Ahmad Khalifa
13 *
14 * -----------------
15 * Revision Details: (Updated by Revision Control System)
16 * -----------------
17 * $Date: 2006-11-18 15:10:48 +0000 (Sat, 18 Nov 2006) $
18 * $Author: simon $
19 * $Revision: 6910 $
20 *
21 * (www.arabeyes.org - under MIT license)
22 *
23 ************************************************************************/
24
25 /*
26 * TODO:
27 * =====
28 * - Explicit marks need to be handled (they are not 100% now)
29 * - Ligatures
30 */
31
32 #include <stdlib.h> /* definition of wchar_t*/
33
34 #include "misc.h"
35
36 #define LMASK 0x3F /* Embedding Level mask */
37 #define OMASK 0xC0 /* Override mask */
38 #define OISL 0x80 /* Override is L */
39 #define OISR 0x40 /* Override is R */
40
41 /* For standalone compilation in a testing mode.
42 * Still depends on the PuTTY headers for snewn and sfree, but can avoid
43 * _linking_ with any other PuTTY code. */
44 #ifdef TEST_GETTYPE
45 #define safemalloc malloc
46 #define safefree free
47 #endif
48
49 /* Shaping Helpers */
50 #define STYPE(xh) ((((xh) >= SHAPE_FIRST) && ((xh) <= SHAPE_LAST)) ? \
51 shapetypes[(xh)-SHAPE_FIRST].type : SU) /*))*/
52 #define SISOLATED(xh) (shapetypes[(xh)-SHAPE_FIRST].form_b)
53 #define SFINAL(xh) ((xh)+1)
54 #define SINITIAL(xh) ((xh)+2)
55 #define SMEDIAL(ch) ((ch)+3)
56
57 #define leastGreaterOdd(x) ( ((x)+1) | 1 )
58 #define leastGreaterEven(x) ( ((x)+2) &~ 1 )
59
60 typedef struct bidi_char {
61 wchar_t origwc, wc;
62 unsigned short index;
63 } bidi_char;
64
65 /* function declarations */
66 void flipThisRun(bidi_char *from, unsigned char* level, int max, int count);
67 int findIndexOfRun(unsigned char* level , int start, int count, int tlevel);
68 unsigned char getType(int ch);
69 unsigned char setOverrideBits(unsigned char level, unsigned char override);
70 int getPreviousLevel(unsigned char* level, int from);
71 int do_shape(bidi_char *line, bidi_char *to, int count);
72 int do_bidi(bidi_char *line, int count);
73 void doMirror(wchar_t* ch);
74
75 /* character types */
76 enum {
77 L,
78 LRE,
79 LRO,
80 R,
81 AL,
82 RLE,
83 RLO,
84 PDF,
85 EN,
86 ES,
87 ET,
88 AN,
89 CS,
90 NSM,
91 BN,
92 B,
93 S,
94 WS,
95 ON
96 };
97
98 /* Shaping Types */
99 enum {
100 SL, /* Left-Joining, doesnt exist in U+0600 - U+06FF */
101 SR, /* Right-Joining, ie has Isolated, Final */
102 SD, /* Dual-Joining, ie has Isolated, Final, Initial, Medial */
103 SU, /* Non-Joining */
104 SC /* Join-Causing, like U+0640 (TATWEEL) */
105 };
106
107 typedef struct {
108 char type;
109 wchar_t form_b;
110 } shape_node;
111
112 /* Kept near the actual table, for verification. */
113 #define SHAPE_FIRST 0x621
114 #define SHAPE_LAST 0x64A
115
116 const shape_node shapetypes[] = {
117 /* index, Typ, Iso, Ligature Index*/
118 /* 621 */ {SU, 0xFE80},
119 /* 622 */ {SR, 0xFE81},
120 /* 623 */ {SR, 0xFE83},
121 /* 624 */ {SR, 0xFE85},
122 /* 625 */ {SR, 0xFE87},
123 /* 626 */ {SD, 0xFE89},
124 /* 627 */ {SR, 0xFE8D},
125 /* 628 */ {SD, 0xFE8F},
126 /* 629 */ {SR, 0xFE93},
127 /* 62A */ {SD, 0xFE95},
128 /* 62B */ {SD, 0xFE99},
129 /* 62C */ {SD, 0xFE9D},
130 /* 62D */ {SD, 0xFEA1},
131 /* 62E */ {SD, 0xFEA5},
132 /* 62F */ {SR, 0xFEA9},
133 /* 630 */ {SR, 0xFEAB},
134 /* 631 */ {SR, 0xFEAD},
135 /* 632 */ {SR, 0xFEAF},
136 /* 633 */ {SD, 0xFEB1},
137 /* 634 */ {SD, 0xFEB5},
138 /* 635 */ {SD, 0xFEB9},
139 /* 636 */ {SD, 0xFEBD},
140 /* 637 */ {SD, 0xFEC1},
141 /* 638 */ {SD, 0xFEC5},
142 /* 639 */ {SD, 0xFEC9},
143 /* 63A */ {SD, 0xFECD},
144 /* 63B */ {SU, 0x0},
145 /* 63C */ {SU, 0x0},
146 /* 63D */ {SU, 0x0},
147 /* 63E */ {SU, 0x0},
148 /* 63F */ {SU, 0x0},
149 /* 640 */ {SC, 0x0},
150 /* 641 */ {SD, 0xFED1},
151 /* 642 */ {SD, 0xFED5},
152 /* 643 */ {SD, 0xFED9},
153 /* 644 */ {SD, 0xFEDD},
154 /* 645 */ {SD, 0xFEE1},
155 /* 646 */ {SD, 0xFEE5},
156 /* 647 */ {SD, 0xFEE9},
157 /* 648 */ {SR, 0xFEED},
158 /* 649 */ {SR, 0xFEEF}, /* SD */
159 /* 64A */ {SD, 0xFEF1}
160 };
161
162 /*
163 * Flips the text buffer, according to max level, and
164 * all higher levels
165 *
166 * Input:
167 * from: text buffer, on which to apply flipping
168 * level: resolved levels buffer
169 * max: the maximum level found in this line (should be unsigned char)
170 * count: line size in bidi_char
171 */
172 void flipThisRun(bidi_char *from, unsigned char *level, int max, int count)
173 {
174 int i, j, k, tlevel;
175 bidi_char temp;
176
177 j = i = 0;
178 while (i<count && j<count) {
179
180 /* find the start of the run of level=max */
181 tlevel = max;
182 i = j = findIndexOfRun(level, i, count, max);
183 /* find the end of the run */
184 while (i<count && tlevel <= level[i]) {
185 i++;
186 }
187 for (k = i - 1; k > j; k--, j++) {
188 temp = from[k];
189 from[k] = from[j];
190 from[j] = temp;
191 }
192 }
193 }
194
195 /*
196 * Finds the index of a run with level equals tlevel
197 */
198 int findIndexOfRun(unsigned char* level , int start, int count, int tlevel)
199 {
200 int i;
201 for (i=start; i<count; i++) {
202 if (tlevel == level[i]) {
203 return i;
204 }
205 }
206 return count;
207 }
208
209 /*
210 * Returns the bidi character type of ch.
211 *
212 * The data table in this function is constructed from the Unicode
213 * Character Database, downloadable from unicode.org at the URL
214 *
215 * http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
216 *
217 * by the following fragment of Perl:
218
219 perl -ne 'split ";"; $num = hex $_[0]; $type = $_[4];' \
220 -e '$fl = ($_[1] =~ /First/ ? 1 : $_[1] =~ /Last/ ? 2 : 0);' \
221 -e 'if ($type eq $runtype and ($runend == $num-1 or ' \
222 -e ' ($fl==2 and $pfl==1))) {$runend = $num;} else { &reset; }' \
223 -e '$pfl=$fl; END { &reset }; sub reset {' \
224 -e 'printf" {0x%04x, 0x%04x, %s},\n",$runstart,$runend,$runtype' \
225 -e ' if defined $runstart and $runtype ne "ON";' \
226 -e '$runstart=$runend=$num; $runtype=$type;}' \
227 UnicodeData.txt
228
229 */
230 unsigned char getType(int ch)
231 {
232 static const struct {
233 int first, last, type;
234 } lookup[] = {
235 {0x0000, 0x0008, BN},
236 {0x0009, 0x0009, S},
237 {0x000a, 0x000a, B},
238 {0x000b, 0x000b, S},
239 {0x000c, 0x000c, WS},
240 {0x000d, 0x000d, B},
241 {0x000e, 0x001b, BN},
242 {0x001c, 0x001e, B},
243 {0x001f, 0x001f, S},
244 {0x0020, 0x0020, WS},
245 {0x0023, 0x0025, ET},
246 {0x002b, 0x002b, ES},
247 {0x002c, 0x002c, CS},
248 {0x002d, 0x002d, ES},
249 {0x002e, 0x002f, CS},
250 {0x0030, 0x0039, EN},
251 {0x003a, 0x003a, CS},
252 {0x0041, 0x005a, L},
253 {0x0061, 0x007a, L},
254 {0x007f, 0x0084, BN},
255 {0x0085, 0x0085, B},
256 {0x0086, 0x009f, BN},
257 {0x00a0, 0x00a0, CS},
258 {0x00a2, 0x00a5, ET},
259 {0x00aa, 0x00aa, L},
260 {0x00ad, 0x00ad, BN},
261 {0x00b0, 0x00b1, ET},
262 {0x00b2, 0x00b3, EN},
263 {0x00b5, 0x00b5, L},
264 {0x00b9, 0x00b9, EN},
265 {0x00ba, 0x00ba, L},
266 {0x00c0, 0x00d6, L},
267 {0x00d8, 0x00f6, L},
268 {0x00f8, 0x0236, L},
269 {0x0250, 0x02b8, L},
270 {0x02bb, 0x02c1, L},
271 {0x02d0, 0x02d1, L},
272 {0x02e0, 0x02e4, L},
273 {0x02ee, 0x02ee, L},
274 {0x0300, 0x0357, NSM},
275 {0x035d, 0x036f, NSM},
276 {0x037a, 0x037a, L},
277 {0x0386, 0x0386, L},
278 {0x0388, 0x038a, L},
279 {0x038c, 0x038c, L},
280 {0x038e, 0x03a1, L},
281 {0x03a3, 0x03ce, L},
282 {0x03d0, 0x03f5, L},
283 {0x03f7, 0x03fb, L},
284 {0x0400, 0x0482, L},
285 {0x0483, 0x0486, NSM},
286 {0x0488, 0x0489, NSM},
287 {0x048a, 0x04ce, L},
288 {0x04d0, 0x04f5, L},
289 {0x04f8, 0x04f9, L},
290 {0x0500, 0x050f, L},
291 {0x0531, 0x0556, L},
292 {0x0559, 0x055f, L},
293 {0x0561, 0x0587, L},
294 {0x0589, 0x0589, L},
295 {0x0591, 0x05a1, NSM},
296 {0x05a3, 0x05b9, NSM},
297 {0x05bb, 0x05bd, NSM},
298 {0x05be, 0x05be, R},
299 {0x05bf, 0x05bf, NSM},
300 {0x05c0, 0x05c0, R},
301 {0x05c1, 0x05c2, NSM},
302 {0x05c3, 0x05c3, R},
303 {0x05c4, 0x05c4, NSM},
304 {0x05d0, 0x05ea, R},
305 {0x05f0, 0x05f4, R},
306 {0x0600, 0x0603, AL},
307 {0x060c, 0x060c, CS},
308 {0x060d, 0x060d, AL},
309 {0x0610, 0x0615, NSM},
310 {0x061b, 0x061b, AL},
311 {0x061f, 0x061f, AL},
312 {0x0621, 0x063a, AL},
313 {0x0640, 0x064a, AL},
314 {0x064b, 0x0658, NSM},
315 {0x0660, 0x0669, AN},
316 {0x066a, 0x066a, ET},
317 {0x066b, 0x066c, AN},
318 {0x066d, 0x066f, AL},
319 {0x0670, 0x0670, NSM},
320 {0x0671, 0x06d5, AL},
321 {0x06d6, 0x06dc, NSM},
322 {0x06dd, 0x06dd, AL},
323 {0x06de, 0x06e4, NSM},
324 {0x06e5, 0x06e6, AL},
325 {0x06e7, 0x06e8, NSM},
326 {0x06ea, 0x06ed, NSM},
327 {0x06ee, 0x06ef, AL},
328 {0x06f0, 0x06f9, EN},
329 {0x06fa, 0x070d, AL},
330 {0x070f, 0x070f, BN},
331 {0x0710, 0x0710, AL},
332 {0x0711, 0x0711, NSM},
333 {0x0712, 0x072f, AL},
334 {0x0730, 0x074a, NSM},
335 {0x074d, 0x074f, AL},
336 {0x0780, 0x07a5, AL},
337 {0x07a6, 0x07b0, NSM},
338 {0x07b1, 0x07b1, AL},
339 {0x0901, 0x0902, NSM},
340 {0x0903, 0x0939, L},
341 {0x093c, 0x093c, NSM},
342 {0x093d, 0x0940, L},
343 {0x0941, 0x0948, NSM},
344 {0x0949, 0x094c, L},
345 {0x094d, 0x094d, NSM},
346 {0x0950, 0x0950, L},
347 {0x0951, 0x0954, NSM},
348 {0x0958, 0x0961, L},
349 {0x0962, 0x0963, NSM},
350 {0x0964, 0x0970, L},
351 {0x0981, 0x0981, NSM},
352 {0x0982, 0x0983, L},
353 {0x0985, 0x098c, L},
354 {0x098f, 0x0990, L},
355 {0x0993, 0x09a8, L},
356 {0x09aa, 0x09b0, L},
357 {0x09b2, 0x09b2, L},
358 {0x09b6, 0x09b9, L},
359 {0x09bc, 0x09bc, NSM},
360 {0x09bd, 0x09c0, L},
361 {0x09c1, 0x09c4, NSM},
362 {0x09c7, 0x09c8, L},
363 {0x09cb, 0x09cc, L},
364 {0x09cd, 0x09cd, NSM},
365 {0x09d7, 0x09d7, L},
366 {0x09dc, 0x09dd, L},
367 {0x09df, 0x09e1, L},
368 {0x09e2, 0x09e3, NSM},
369 {0x09e6, 0x09f1, L},
370 {0x09f2, 0x09f3, ET},
371 {0x09f4, 0x09fa, L},
372 {0x0a01, 0x0a02, NSM},
373 {0x0a03, 0x0a03, L},
374 {0x0a05, 0x0a0a, L},
375 {0x0a0f, 0x0a10, L},
376 {0x0a13, 0x0a28, L},
377 {0x0a2a, 0x0a30, L},
378 {0x0a32, 0x0a33, L},
379 {0x0a35, 0x0a36, L},
380 {0x0a38, 0x0a39, L},
381 {0x0a3c, 0x0a3c, NSM},
382 {0x0a3e, 0x0a40, L},
383 {0x0a41, 0x0a42, NSM},
384 {0x0a47, 0x0a48, NSM},
385 {0x0a4b, 0x0a4d, NSM},
386 {0x0a59, 0x0a5c, L},
387 {0x0a5e, 0x0a5e, L},
388 {0x0a66, 0x0a6f, L},
389 {0x0a70, 0x0a71, NSM},
390 {0x0a72, 0x0a74, L},
391 {0x0a81, 0x0a82, NSM},
392 {0x0a83, 0x0a83, L},
393 {0x0a85, 0x0a8d, L},
394 {0x0a8f, 0x0a91, L},
395 {0x0a93, 0x0aa8, L},
396 {0x0aaa, 0x0ab0, L},
397 {0x0ab2, 0x0ab3, L},
398 {0x0ab5, 0x0ab9, L},
399 {0x0abc, 0x0abc, NSM},
400 {0x0abd, 0x0ac0, L},
401 {0x0ac1, 0x0ac5, NSM},
402 {0x0ac7, 0x0ac8, NSM},
403 {0x0ac9, 0x0ac9, L},
404 {0x0acb, 0x0acc, L},
405 {0x0acd, 0x0acd, NSM},
406 {0x0ad0, 0x0ad0, L},
407 {0x0ae0, 0x0ae1, L},
408 {0x0ae2, 0x0ae3, NSM},
409 {0x0ae6, 0x0aef, L},
410 {0x0af1, 0x0af1, ET},
411 {0x0b01, 0x0b01, NSM},
412 {0x0b02, 0x0b03, L},
413 {0x0b05, 0x0b0c, L},
414 {0x0b0f, 0x0b10, L},
415 {0x0b13, 0x0b28, L},
416 {0x0b2a, 0x0b30, L},
417 {0x0b32, 0x0b33, L},
418 {0x0b35, 0x0b39, L},
419 {0x0b3c, 0x0b3c, NSM},
420 {0x0b3d, 0x0b3e, L},
421 {0x0b3f, 0x0b3f, NSM},
422 {0x0b40, 0x0b40, L},
423 {0x0b41, 0x0b43, NSM},
424 {0x0b47, 0x0b48, L},
425 {0x0b4b, 0x0b4c, L},
426 {0x0b4d, 0x0b4d, NSM},
427 {0x0b56, 0x0b56, NSM},
428 {0x0b57, 0x0b57, L},
429 {0x0b5c, 0x0b5d, L},
430 {0x0b5f, 0x0b61, L},
431 {0x0b66, 0x0b71, L},
432 {0x0b82, 0x0b82, NSM},
433 {0x0b83, 0x0b83, L},
434 {0x0b85, 0x0b8a, L},
435 {0x0b8e, 0x0b90, L},
436 {0x0b92, 0x0b95, L},
437 {0x0b99, 0x0b9a, L},
438 {0x0b9c, 0x0b9c, L},
439 {0x0b9e, 0x0b9f, L},
440 {0x0ba3, 0x0ba4, L},
441 {0x0ba8, 0x0baa, L},
442 {0x0bae, 0x0bb5, L},
443 {0x0bb7, 0x0bb9, L},
444 {0x0bbe, 0x0bbf, L},
445 {0x0bc0, 0x0bc0, NSM},
446 {0x0bc1, 0x0bc2, L},
447 {0x0bc6, 0x0bc8, L},
448 {0x0bca, 0x0bcc, L},
449 {0x0bcd, 0x0bcd, NSM},
450 {0x0bd7, 0x0bd7, L},
451 {0x0be7, 0x0bf2, L},
452 {0x0bf9, 0x0bf9, ET},
453 {0x0c01, 0x0c03, L},
454 {0x0c05, 0x0c0c, L},
455 {0x0c0e, 0x0c10, L},
456 {0x0c12, 0x0c28, L},
457 {0x0c2a, 0x0c33, L},
458 {0x0c35, 0x0c39, L},
459 {0x0c3e, 0x0c40, NSM},
460 {0x0c41, 0x0c44, L},
461 {0x0c46, 0x0c48, NSM},
462 {0x0c4a, 0x0c4d, NSM},
463 {0x0c55, 0x0c56, NSM},
464 {0x0c60, 0x0c61, L},
465 {0x0c66, 0x0c6f, L},
466 {0x0c82, 0x0c83, L},
467 {0x0c85, 0x0c8c, L},
468 {0x0c8e, 0x0c90, L},
469 {0x0c92, 0x0ca8, L},
470 {0x0caa, 0x0cb3, L},
471 {0x0cb5, 0x0cb9, L},
472 {0x0cbc, 0x0cbc, NSM},
473 {0x0cbd, 0x0cc4, L},
474 {0x0cc6, 0x0cc8, L},
475 {0x0cca, 0x0ccb, L},
476 {0x0ccc, 0x0ccd, NSM},
477 {0x0cd5, 0x0cd6, L},
478 {0x0cde, 0x0cde, L},
479 {0x0ce0, 0x0ce1, L},
480 {0x0ce6, 0x0cef, L},
481 {0x0d02, 0x0d03, L},
482 {0x0d05, 0x0d0c, L},
483 {0x0d0e, 0x0d10, L},
484 {0x0d12, 0x0d28, L},
485 {0x0d2a, 0x0d39, L},
486 {0x0d3e, 0x0d40, L},
487 {0x0d41, 0x0d43, NSM},
488 {0x0d46, 0x0d48, L},
489 {0x0d4a, 0x0d4c, L},
490 {0x0d4d, 0x0d4d, NSM},
491 {0x0d57, 0x0d57, L},
492 {0x0d60, 0x0d61, L},
493 {0x0d66, 0x0d6f, L},
494 {0x0d82, 0x0d83, L},
495 {0x0d85, 0x0d96, L},
496 {0x0d9a, 0x0db1, L},
497 {0x0db3, 0x0dbb, L},
498 {0x0dbd, 0x0dbd, L},
499 {0x0dc0, 0x0dc6, L},
500 {0x0dca, 0x0dca, NSM},
501 {0x0dcf, 0x0dd1, L},
502 {0x0dd2, 0x0dd4, NSM},
503 {0x0dd6, 0x0dd6, NSM},
504 {0x0dd8, 0x0ddf, L},
505 {0x0df2, 0x0df4, L},
506 {0x0e01, 0x0e30, L},
507 {0x0e31, 0x0e31, NSM},
508 {0x0e32, 0x0e33, L},
509 {0x0e34, 0x0e3a, NSM},
510 {0x0e3f, 0x0e3f, ET},
511 {0x0e40, 0x0e46, L},
512 {0x0e47, 0x0e4e, NSM},
513 {0x0e4f, 0x0e5b, L},
514 {0x0e81, 0x0e82, L},
515 {0x0e84, 0x0e84, L},
516 {0x0e87, 0x0e88, L},
517 {0x0e8a, 0x0e8a, L},
518 {0x0e8d, 0x0e8d, L},
519 {0x0e94, 0x0e97, L},
520 {0x0e99, 0x0e9f, L},
521 {0x0ea1, 0x0ea3, L},
522 {0x0ea5, 0x0ea5, L},
523 {0x0ea7, 0x0ea7, L},
524 {0x0eaa, 0x0eab, L},
525 {0x0ead, 0x0eb0, L},
526 {0x0eb1, 0x0eb1, NSM},
527 {0x0eb2, 0x0eb3, L},
528 {0x0eb4, 0x0eb9, NSM},
529 {0x0ebb, 0x0ebc, NSM},
530 {0x0ebd, 0x0ebd, L},
531 {0x0ec0, 0x0ec4, L},
532 {0x0ec6, 0x0ec6, L},
533 {0x0ec8, 0x0ecd, NSM},
534 {0x0ed0, 0x0ed9, L},
535 {0x0edc, 0x0edd, L},
536 {0x0f00, 0x0f17, L},
537 {0x0f18, 0x0f19, NSM},
538 {0x0f1a, 0x0f34, L},
539 {0x0f35, 0x0f35, NSM},
540 {0x0f36, 0x0f36, L},
541 {0x0f37, 0x0f37, NSM},
542 {0x0f38, 0x0f38, L},
543 {0x0f39, 0x0f39, NSM},
544 {0x0f3e, 0x0f47, L},
545 {0x0f49, 0x0f6a, L},
546 {0x0f71, 0x0f7e, NSM},
547 {0x0f7f, 0x0f7f, L},
548 {0x0f80, 0x0f84, NSM},
549 {0x0f85, 0x0f85, L},
550 {0x0f86, 0x0f87, NSM},
551 {0x0f88, 0x0f8b, L},
552 {0x0f90, 0x0f97, NSM},
553 {0x0f99, 0x0fbc, NSM},
554 {0x0fbe, 0x0fc5, L},
555 {0x0fc6, 0x0fc6, NSM},
556 {0x0fc7, 0x0fcc, L},
557 {0x0fcf, 0x0fcf, L},
558 {0x1000, 0x1021, L},
559 {0x1023, 0x1027, L},
560 {0x1029, 0x102a, L},
561 {0x102c, 0x102c, L},
562 {0x102d, 0x1030, NSM},
563 {0x1031, 0x1031, L},
564 {0x1032, 0x1032, NSM},
565 {0x1036, 0x1037, NSM},
566 {0x1038, 0x1038, L},
567 {0x1039, 0x1039, NSM},
568 {0x1040, 0x1057, L},
569 {0x1058, 0x1059, NSM},
570 {0x10a0, 0x10c5, L},
571 {0x10d0, 0x10f8, L},
572 {0x10fb, 0x10fb, L},
573 {0x1100, 0x1159, L},
574 {0x115f, 0x11a2, L},
575 {0x11a8, 0x11f9, L},
576 {0x1200, 0x1206, L},
577 {0x1208, 0x1246, L},
578 {0x1248, 0x1248, L},
579 {0x124a, 0x124d, L},
580 {0x1250, 0x1256, L},
581 {0x1258, 0x1258, L},
582 {0x125a, 0x125d, L},
583 {0x1260, 0x1286, L},
584 {0x1288, 0x1288, L},
585 {0x128a, 0x128d, L},
586 {0x1290, 0x12ae, L},
587 {0x12b0, 0x12b0, L},
588 {0x12b2, 0x12b5, L},
589 {0x12b8, 0x12be, L},
590 {0x12c0, 0x12c0, L},
591 {0x12c2, 0x12c5, L},
592 {0x12c8, 0x12ce, L},
593 {0x12d0, 0x12d6, L},
594 {0x12d8, 0x12ee, L},
595 {0x12f0, 0x130e, L},
596 {0x1310, 0x1310, L},
597 {0x1312, 0x1315, L},
598 {0x1318, 0x131e, L},
599 {0x1320, 0x1346, L},
600 {0x1348, 0x135a, L},
601 {0x1361, 0x137c, L},
602 {0x13a0, 0x13f4, L},
603 {0x1401, 0x1676, L},
604 {0x1680, 0x1680, WS},
605 {0x1681, 0x169a, L},
606 {0x16a0, 0x16f0, L},
607 {0x1700, 0x170c, L},
608 {0x170e, 0x1711, L},
609 {0x1712, 0x1714, NSM},
610 {0x1720, 0x1731, L},
611 {0x1732, 0x1734, NSM},
612 {0x1735, 0x1736, L},
613 {0x1740, 0x1751, L},
614 {0x1752, 0x1753, NSM},
615 {0x1760, 0x176c, L},
616 {0x176e, 0x1770, L},
617 {0x1772, 0x1773, NSM},
618 {0x1780, 0x17b6, L},
619 {0x17b7, 0x17bd, NSM},
620 {0x17be, 0x17c5, L},
621 {0x17c6, 0x17c6, NSM},
622 {0x17c7, 0x17c8, L},
623 {0x17c9, 0x17d3, NSM},
624 {0x17d4, 0x17da, L},
625 {0x17db, 0x17db, ET},
626 {0x17dc, 0x17dc, L},
627 {0x17dd, 0x17dd, NSM},
628 {0x17e0, 0x17e9, L},
629 {0x180b, 0x180d, NSM},
630 {0x180e, 0x180e, WS},
631 {0x1810, 0x1819, L},
632 {0x1820, 0x1877, L},
633 {0x1880, 0x18a8, L},
634 {0x18a9, 0x18a9, NSM},
635 {0x1900, 0x191c, L},
636 {0x1920, 0x1922, NSM},
637 {0x1923, 0x1926, L},
638 {0x1927, 0x192b, NSM},
639 {0x1930, 0x1931, L},
640 {0x1932, 0x1932, NSM},
641 {0x1933, 0x1938, L},
642 {0x1939, 0x193b, NSM},
643 {0x1946, 0x196d, L},
644 {0x1970, 0x1974, L},
645 {0x1d00, 0x1d6b, L},
646 {0x1e00, 0x1e9b, L},
647 {0x1ea0, 0x1ef9, L},
648 {0x1f00, 0x1f15, L},
649 {0x1f18, 0x1f1d, L},
650 {0x1f20, 0x1f45, L},
651 {0x1f48, 0x1f4d, L},
652 {0x1f50, 0x1f57, L},
653 {0x1f59, 0x1f59, L},
654 {0x1f5b, 0x1f5b, L},
655 {0x1f5d, 0x1f5d, L},
656 {0x1f5f, 0x1f7d, L},
657 {0x1f80, 0x1fb4, L},
658 {0x1fb6, 0x1fbc, L},
659 {0x1fbe, 0x1fbe, L},
660 {0x1fc2, 0x1fc4, L},
661 {0x1fc6, 0x1fcc, L},
662 {0x1fd0, 0x1fd3, L},
663 {0x1fd6, 0x1fdb, L},
664 {0x1fe0, 0x1fec, L},
665 {0x1ff2, 0x1ff4, L},
666 {0x1ff6, 0x1ffc, L},
667 {0x2000, 0x200a, WS},
668 {0x200b, 0x200d, BN},
669 {0x200e, 0x200e, L},
670 {0x200f, 0x200f, R},
671 {0x2028, 0x2028, WS},
672 {0x2029, 0x2029, B},
673 {0x202a, 0x202a, LRE},
674 {0x202b, 0x202b, RLE},
675 {0x202c, 0x202c, PDF},
676 {0x202d, 0x202d, LRO},
677 {0x202e, 0x202e, RLO},
678 {0x202f, 0x202f, WS},
679 {0x2030, 0x2034, ET},
680 {0x2044, 0x2044, CS},
681 {0x205f, 0x205f, WS},
682 {0x2060, 0x2063, BN},
683 {0x206a, 0x206f, BN},
684 {0x2070, 0x2070, EN},
685 {0x2071, 0x2071, L},
686 {0x2074, 0x2079, EN},
687 {0x207a, 0x207b, ET},
688 {0x207f, 0x207f, L},
689 {0x2080, 0x2089, EN},
690 {0x208a, 0x208b, ET},
691 {0x20a0, 0x20b1, ET},
692 {0x20d0, 0x20ea, NSM},
693 {0x2102, 0x2102, L},
694 {0x2107, 0x2107, L},
695 {0x210a, 0x2113, L},
696 {0x2115, 0x2115, L},
697 {0x2119, 0x211d, L},
698 {0x2124, 0x2124, L},
699 {0x2126, 0x2126, L},
700 {0x2128, 0x2128, L},
701 {0x212a, 0x212d, L},
702 {0x212e, 0x212e, ET},
703 {0x212f, 0x2131, L},
704 {0x2133, 0x2139, L},
705 {0x213d, 0x213f, L},
706 {0x2145, 0x2149, L},
707 {0x2160, 0x2183, L},
708 {0x2212, 0x2213, ET},
709 {0x2336, 0x237a, L},
710 {0x2395, 0x2395, L},
711 {0x2488, 0x249b, EN},
712 {0x249c, 0x24e9, L},
713 {0x2800, 0x28ff, L},
714 {0x3000, 0x3000, WS},
715 {0x3005, 0x3007, L},
716 {0x3021, 0x3029, L},
717 {0x302a, 0x302f, NSM},
718 {0x3031, 0x3035, L},
719 {0x3038, 0x303c, L},
720 {0x3041, 0x3096, L},
721 {0x3099, 0x309a, NSM},
722 {0x309d, 0x309f, L},
723 {0x30a1, 0x30fa, L},
724 {0x30fc, 0x30ff, L},
725 {0x3105, 0x312c, L},
726 {0x3131, 0x318e, L},
727 {0x3190, 0x31b7, L},
728 {0x31f0, 0x321c, L},
729 {0x3220, 0x3243, L},
730 {0x3260, 0x327b, L},
731 {0x327f, 0x32b0, L},
732 {0x32c0, 0x32cb, L},
733 {0x32d0, 0x32fe, L},
734 {0x3300, 0x3376, L},
735 {0x337b, 0x33dd, L},
736 {0x33e0, 0x33fe, L},
737 {0x3400, 0x4db5, L},
738 {0x4e00, 0x9fa5, L},
739 {0xa000, 0xa48c, L},
740 {0xac00, 0xd7a3, L},
741 {0xd800, 0xfa2d, L},
742 {0xfa30, 0xfa6a, L},
743 {0xfb00, 0xfb06, L},
744 {0xfb13, 0xfb17, L},
745 {0xfb1d, 0xfb1d, R},
746 {0xfb1e, 0xfb1e, NSM},
747 {0xfb1f, 0xfb28, R},
748 {0xfb29, 0xfb29, ET},
749 {0xfb2a, 0xfb36, R},
750 {0xfb38, 0xfb3c, R},
751 {0xfb3e, 0xfb3e, R},
752 {0xfb40, 0xfb41, R},
753 {0xfb43, 0xfb44, R},
754 {0xfb46, 0xfb4f, R},
755 {0xfb50, 0xfbb1, AL},
756 {0xfbd3, 0xfd3d, AL},
757 {0xfd50, 0xfd8f, AL},
758 {0xfd92, 0xfdc7, AL},
759 {0xfdf0, 0xfdfc, AL},
760 {0xfe00, 0xfe0f, NSM},
761 {0xfe20, 0xfe23, NSM},
762 {0xfe50, 0xfe50, CS},
763 {0xfe52, 0xfe52, CS},
764 {0xfe55, 0xfe55, CS},
765 {0xfe5f, 0xfe5f, ET},
766 {0xfe62, 0xfe63, ET},
767 {0xfe69, 0xfe6a, ET},
768 {0xfe70, 0xfe74, AL},
769 {0xfe76, 0xfefc, AL},
770 {0xfeff, 0xfeff, BN},
771 {0xff03, 0xff05, ET},
772 {0xff0b, 0xff0b, ET},
773 {0xff0c, 0xff0c, CS},
774 {0xff0d, 0xff0d, ET},
775 {0xff0e, 0xff0e, CS},
776 {0xff0f, 0xff0f, ES},
777 {0xff10, 0xff19, EN},
778 {0xff1a, 0xff1a, CS},
779 {0xff21, 0xff3a, L},
780 {0xff41, 0xff5a, L},
781 {0xff66, 0xffbe, L},
782 {0xffc2, 0xffc7, L},
783 {0xffca, 0xffcf, L},
784 {0xffd2, 0xffd7, L},
785 {0xffda, 0xffdc, L},
786 {0xffe0, 0xffe1, ET},
787 {0xffe5, 0xffe6, ET},
788 {0x10000, 0x1000b, L},
789 {0x1000d, 0x10026, L},
790 {0x10028, 0x1003a, L},
791 {0x1003c, 0x1003d, L},
792 {0x1003f, 0x1004d, L},
793 {0x10050, 0x1005d, L},
794 {0x10080, 0x100fa, L},
795 {0x10100, 0x10100, L},
796 {0x10102, 0x10102, L},
797 {0x10107, 0x10133, L},
798 {0x10137, 0x1013f, L},
799 {0x10300, 0x1031e, L},
800 {0x10320, 0x10323, L},
801 {0x10330, 0x1034a, L},
802 {0x10380, 0x1039d, L},
803 {0x1039f, 0x1039f, L},
804 {0x10400, 0x1049d, L},
805 {0x104a0, 0x104a9, L},
806 {0x10800, 0x10805, R},
807 {0x10808, 0x10808, R},
808 {0x1080a, 0x10835, R},
809 {0x10837, 0x10838, R},
810 {0x1083c, 0x1083c, R},
811 {0x1083f, 0x1083f, R},
812 {0x1d000, 0x1d0f5, L},
813 {0x1d100, 0x1d126, L},
814 {0x1d12a, 0x1d166, L},
815 {0x1d167, 0x1d169, NSM},
816 {0x1d16a, 0x1d172, L},
817 {0x1d173, 0x1d17a, BN},
818 {0x1d17b, 0x1d182, NSM},
819 {0x1d183, 0x1d184, L},
820 {0x1d185, 0x1d18b, NSM},
821 {0x1d18c, 0x1d1a9, L},
822 {0x1d1aa, 0x1d1ad, NSM},
823 {0x1d1ae, 0x1d1dd, L},
824 {0x1d400, 0x1d454, L},
825 {0x1d456, 0x1d49c, L},
826 {0x1d49e, 0x1d49f, L},
827 {0x1d4a2, 0x1d4a2, L},
828 {0x1d4a5, 0x1d4a6, L},
829 {0x1d4a9, 0x1d4ac, L},
830 {0x1d4ae, 0x1d4b9, L},
831 {0x1d4bb, 0x1d4bb, L},
832 {0x1d4bd, 0x1d4c3, L},
833 {0x1d4c5, 0x1d505, L},
834 {0x1d507, 0x1d50a, L},
835 {0x1d50d, 0x1d514, L},
836 {0x1d516, 0x1d51c, L},
837 {0x1d51e, 0x1d539, L},
838 {0x1d53b, 0x1d53e, L},
839 {0x1d540, 0x1d544, L},
840 {0x1d546, 0x1d546, L},
841 {0x1d54a, 0x1d550, L},
842 {0x1d552, 0x1d6a3, L},
843 {0x1d6a8, 0x1d7c9, L},
844 {0x1d7ce, 0x1d7ff, EN},
845 {0x20000, 0x2a6d6, L},
846 {0x2f800, 0x2fa1d, L},
847 {0xe0001, 0xe0001, BN},
848 {0xe0020, 0xe007f, BN},
849 {0xe0100, 0xe01ef, NSM},
850 {0xf0000, 0xffffd, L},
851 {0x100000, 0x10fffd, L}
852 };
853
854 int i, j, k;
855
856 i = -1;
857 j = lenof(lookup);
858
859 while (j - i > 1) {
860 k = (i + j) / 2;
861 if (ch < lookup[k].first)
862 j = k;
863 else if (ch > lookup[k].last)
864 i = k;
865 else
866 return lookup[k].type;
867 }
868
869 /*
870 * If we reach here, the character was not in any of the
871 * intervals listed in the lookup table. This means we return
872 * ON (`Other Neutrals'). This is the appropriate code for any
873 * character genuinely not listed in the Unicode table, and
874 * also the table above has deliberately left out any
875 * characters _explicitly_ listed as ON (to save space!).
876 */
877 return ON;
878 }
879
880 /*
881 * Function exported to front ends to allow them to identify
882 * bidi-active characters (in case, for example, the platform's
883 * text display function can't conveniently be prevented from doing
884 * its own bidi and so special treatment is required for characters
885 * that would cause the bidi algorithm to activate).
886 *
887 * This function is passed a single Unicode code point, and returns
888 * nonzero if the presence of this code point can possibly cause
889 * the bidi algorithm to do any reordering. Thus, any string
890 * composed entirely of characters for which is_rtl() returns zero
891 * should be safe to pass to a bidi-active platform display
892 * function without fear.
893 *
894 * (is_rtl() must therefore also return true for any character
895 * which would be affected by Arabic shaping, but this isn't
896 * important because all such characters are right-to-left so it
897 * would have flagged them anyway.)
898 */
899 int is_rtl(int c)
900 {
901 /*
902 * After careful reading of the Unicode bidi algorithm (URL as
903 * given at the top of this file) I believe that the only
904 * character classes which can possibly cause trouble are R,
905 * AL, RLE and RLO. I think that any string containing no
906 * character in any of those classes will be displayed
907 * uniformly left-to-right by the Unicode bidi algorithm.
908 */
909 const int mask = (1<<R) | (1<<AL) | (1<<RLE) | (1<<RLO);
910
911 return mask & (1 << (getType(c)));
912 }
913
914 /*
915 * The most significant 2 bits of each level are used to store
916 * Override status of each character
917 * This function sets the override bits of level according
918 * to the value in override, and reurns the new byte.
919 */
920 unsigned char setOverrideBits(unsigned char level, unsigned char override)
921 {
922 if (override == ON)
923 return level;
924 else if (override == R)
925 return level | OISR;
926 else if (override == L)
927 return level | OISL;
928 return level;
929 }
930
931 /*
932 * Find the most recent run of the same value in `level', and
933 * return the value _before_ it. Used to process U+202C POP
934 * DIRECTIONAL FORMATTING.
935 */
936 int getPreviousLevel(unsigned char* level, int from)
937 {
938 if (from > 0) {
939 unsigned char current = level[--from];
940
941 while (from >= 0 && level[from] == current)
942 from--;
943
944 if (from >= 0)
945 return level[from];
946
947 return -1;
948 } else
949 return -1;
950 }
951
952 /* The Main shaping function, and the only one to be used
953 * by the outside world.
954 *
955 * line: buffer to apply shaping to. this must be passed by doBidi() first
956 * to: output buffer for the shaped data
957 * count: number of characters in line
958 */
959 int do_shape(bidi_char *line, bidi_char *to, int count)
960 {
961 int i, tempShape, ligFlag;
962
963 for (ligFlag=i=0; i<count; i++) {
964 to[i] = line[i];
965 tempShape = STYPE(line[i].wc);
966 switch (tempShape) {
967 case SC:
968 break;
969
970 case SU:
971 break;
972
973 case SR:
974 tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
975 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
976 to[i].wc = SFINAL((SISOLATED(line[i].wc)));
977 else
978 to[i].wc = SISOLATED(line[i].wc);
979 break;
980
981
982 case SD:
983 /* Make Ligatures */
984 tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
985 if (line[i].wc == 0x644) {
986 if (i > 0) switch (line[i-1].wc) {
987 case 0x622:
988 ligFlag = 1;
989 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
990 to[i].wc = 0xFEF6;
991 else
992 to[i].wc = 0xFEF5;
993 break;
994 case 0x623:
995 ligFlag = 1;
996 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
997 to[i].wc = 0xFEF8;
998 else
999 to[i].wc = 0xFEF7;
1000 break;
1001 case 0x625:
1002 ligFlag = 1;
1003 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
1004 to[i].wc = 0xFEFA;
1005 else
1006 to[i].wc = 0xFEF9;
1007 break;
1008 case 0x627:
1009 ligFlag = 1;
1010 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
1011 to[i].wc = 0xFEFC;
1012 else
1013 to[i].wc = 0xFEFB;
1014 break;
1015 }
1016 if (ligFlag) {
1017 to[i-1].wc = 0x20;
1018 ligFlag = 0;
1019 break;
1020 }
1021 }
1022
1023 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC)) {
1024 tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
1025 if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
1026 to[i].wc = SMEDIAL((SISOLATED(line[i].wc)));
1027 else
1028 to[i].wc = SFINAL((SISOLATED(line[i].wc)));
1029 break;
1030 }
1031
1032 tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
1033 if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
1034 to[i].wc = SINITIAL((SISOLATED(line[i].wc)));
1035 else
1036 to[i].wc = SISOLATED(line[i].wc);
1037 break;
1038
1039
1040 }
1041 }
1042 return 1;
1043 }
1044
1045 /*
1046 * The Main Bidi Function, and the only function that should
1047 * be used by the outside world.
1048 *
1049 * line: a buffer of size count containing text to apply
1050 * the Bidirectional algorithm to.
1051 */
1052
1053 int do_bidi(bidi_char *line, int count)
1054 {
1055 unsigned char* types;
1056 unsigned char* levels;
1057 unsigned char paragraphLevel;
1058 unsigned char currentEmbedding;
1059 unsigned char currentOverride;
1060 unsigned char tempType;
1061 int i, j, imax, yes, bover;
1062
1063 /* Check the presence of R or AL types as optimization */
1064 yes = 0;
1065 for (i=0; i<count; i++) {
1066 int type = getType(line[i].wc);
1067 if (type == R || type == AL) {
1068 yes = 1;
1069 break;
1070 }
1071 }
1072 if (yes == 0)
1073 return L;
1074
1075 /* Initialize types, levels */
1076 types = snewn(count, unsigned char);
1077 levels = snewn(count, unsigned char);
1078
1079 /* Rule (P1) NOT IMPLEMENTED
1080 * P1. Split the text into separate paragraphs. A paragraph separator is
1081 * kept with the previous paragraph. Within each paragraph, apply all the
1082 * other rules of this algorithm.
1083 */
1084
1085 /* Rule (P2), (P3)
1086 * P2. In each paragraph, find the first character of type L, AL, or R.
1087 * P3. If a character is found in P2 and it is of type AL or R, then set
1088 * the paragraph embedding level to one; otherwise, set it to zero.
1089 */
1090 paragraphLevel = 0;
1091 for (i=0; i<count ; i++) {
1092 int type = getType(line[i].wc);
1093 if (type == R || type == AL) {
1094 paragraphLevel = 1;
1095 break;
1096 } else if (type == L)
1097 break;
1098 }
1099
1100 /* Rule (X1)
1101 * X1. Begin by setting the current embedding level to the paragraph
1102 * embedding level. Set the directional override status to neutral.
1103 */
1104 currentEmbedding = paragraphLevel;
1105 currentOverride = ON;
1106
1107 /* Rule (X2), (X3), (X4), (X5), (X6), (X7), (X8)
1108 * X2. With each RLE, compute the least greater odd embedding level.
1109 * X3. With each LRE, compute the least greater even embedding level.
1110 * X4. With each RLO, compute the least greater odd embedding level.
1111 * X5. With each LRO, compute the least greater even embedding level.
1112 * X6. For all types besides RLE, LRE, RLO, LRO, and PDF:
1113 * a. Set the level of the current character to the current
1114 * embedding level.
1115 * b. Whenever the directional override status is not neutral,
1116 * reset the current character type to the directional
1117 * override status.
1118 * X7. With each PDF, determine the matching embedding or override code.
1119 * If there was a valid matching code, restore (pop) the last
1120 * remembered (pushed) embedding level and directional override.
1121 * X8. All explicit directional embeddings and overrides are completely
1122 * terminated at the end of each paragraph. Paragraph separators are not
1123 * included in the embedding. (Useless here) NOT IMPLEMENTED
1124 */
1125 bover = 0;
1126 for (i=0; i<count; i++) {
1127 tempType = getType(line[i].wc);
1128 switch (tempType) {
1129 case RLE:
1130 currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
1131 levels[i] = setOverrideBits(levels[i], currentOverride);
1132 currentOverride = ON;
1133 break;
1134
1135 case LRE:
1136 currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
1137 levels[i] = setOverrideBits(levels[i], currentOverride);
1138 currentOverride = ON;
1139 break;
1140
1141 case RLO:
1142 currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
1143 tempType = currentOverride = R;
1144 bover = 1;
1145 break;
1146
1147 case LRO:
1148 currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
1149 tempType = currentOverride = L;
1150 bover = 1;
1151 break;
1152
1153 case PDF:
1154 {
1155 int prevlevel = getPreviousLevel(levels, i);
1156
1157 if (prevlevel == -1) {
1158 currentEmbedding = paragraphLevel;
1159 currentOverride = ON;
1160 } else {
1161 currentOverride = currentEmbedding & OMASK;
1162 currentEmbedding = currentEmbedding & ~OMASK;
1163 }
1164 }
1165 levels[i] = currentEmbedding;
1166 break;
1167
1168 /* Whitespace is treated as neutral for now */
1169 case WS:
1170 case S:
1171 levels[i] = currentEmbedding;
1172 tempType = ON;
1173 if (currentOverride != ON)
1174 tempType = currentOverride;
1175 break;
1176
1177 default:
1178 levels[i] = currentEmbedding;
1179 if (currentOverride != ON)
1180 tempType = currentOverride;
1181 break;
1182
1183 }
1184 types[i] = tempType;
1185 }
1186 /* this clears out all overrides, so we can use levels safely... */
1187 /* checks bover first */
1188 if (bover)
1189 for (i=0; i<count; i++)
1190 levels[i] = levels[i] & LMASK;
1191
1192 /* Rule (X9)
1193 * X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
1194 * Here, they're converted to BN.
1195 */
1196 for (i=0; i<count; i++) {
1197 switch (types[i]) {
1198 case RLE:
1199 case LRE:
1200 case RLO:
1201 case LRO:
1202 case PDF:
1203 types[i] = BN;
1204 break;
1205 }
1206 }
1207
1208 /* Rule (W1)
1209 * W1. Examine each non-spacing mark (NSM) in the level run, and change
1210 * the type of the NSM to the type of the previous character. If the NSM
1211 * is at the start of the level run, it will get the type of sor.
1212 */
1213 if (types[0] == NSM)
1214 types[0] = paragraphLevel;
1215
1216 for (i=1; i<count; i++) {
1217 if (types[i] == NSM)
1218 types[i] = types[i-1];
1219 /* Is this a safe assumption?
1220 * I assumed the previous, IS a character.
1221 */
1222 }
1223
1224 /* Rule (W2)
1225 * W2. Search backwards from each instance of a European number until the
1226 * first strong type (R, L, AL, or sor) is found. If an AL is found,
1227 * change the type of the European number to Arabic number.
1228 */
1229 for (i=0; i<count; i++) {
1230 if (types[i] == EN) {
1231 j=i;
1232 while (j >= 0) {
1233 if (types[j] == AL) {
1234 types[i] = AN;
1235 break;
1236 } else if (types[j] == R || types[j] == L) {
1237 break;
1238 }
1239 j--;
1240 }
1241 }
1242 }
1243
1244 /* Rule (W3)
1245 * W3. Change all ALs to R.
1246 *
1247 * Optimization: on Rule Xn, we might set a flag on AL type
1248 * to prevent this loop in L R lines only...
1249 */
1250 for (i=0; i<count; i++) {
1251 if (types[i] == AL)
1252 types[i] = R;
1253 }
1254
1255 /* Rule (W4)
1256 * W4. A single European separator between two European numbers changes
1257 * to a European number. A single common separator between two numbers
1258 * of the same type changes to that type.
1259 */
1260 for (i=1; i<(count-1); i++) {
1261 if (types[i] == ES) {
1262 if (types[i-1] == EN && types[i+1] == EN)
1263 types[i] = EN;
1264 } else if (types[i] == CS) {
1265 if (types[i-1] == EN && types[i+1] == EN)
1266 types[i] = EN;
1267 else if (types[i-1] == AN && types[i+1] == AN)
1268 types[i] = AN;
1269 }
1270 }
1271
1272 /* Rule (W5)
1273 * W5. A sequence of European terminators adjacent to European numbers
1274 * changes to all European numbers.
1275 *
1276 * Optimization: lots here... else ifs need rearrangement
1277 */
1278 for (i=0; i<count; i++) {
1279 if (types[i] == ET) {
1280 if (i > 0 && types[i-1] == EN) {
1281 types[i] = EN;
1282 continue;
1283 } else if (i < count-1 && types[i+1] == EN) {
1284 types[i] = EN;
1285 continue;
1286 } else if (i < count-1 && types[i+1] == ET) {
1287 j=i;
1288 while (j <count && types[j] == ET) {
1289 j++;
1290 }
1291 if (types[j] == EN)
1292 types[i] = EN;
1293 }
1294 }
1295 }
1296
1297 /* Rule (W6)
1298 * W6. Otherwise, separators and terminators change to Other Neutral:
1299 */
1300 for (i=0; i<count; i++) {
1301 switch (types[i]) {
1302 case ES:
1303 case ET:
1304 case CS:
1305 types[i] = ON;
1306 break;
1307 }
1308 }
1309
1310 /* Rule (W7)
1311 * W7. Search backwards from each instance of a European number until
1312 * the first strong type (R, L, or sor) is found. If an L is found,
1313 * then change the type of the European number to L.
1314 */
1315 for (i=0; i<count; i++) {
1316 if (types[i] == EN) {
1317 j=i;
1318 while (j >= 0) {
1319 if (types[j] == L) {
1320 types[i] = L;
1321 break;
1322 } else if (types[j] == R || types[j] == AL) {
1323 break;
1324 }
1325 j--;
1326 }
1327 }
1328 }
1329
1330 /* Rule (N1)
1331 * N1. A sequence of neutrals takes the direction of the surrounding
1332 * strong text if the text on both sides has the same direction. European
1333 * and Arabic numbers are treated as though they were R.
1334 */
1335 if (count >= 2 && types[0] == ON) {
1336 if ((types[1] == R) || (types[1] == EN) || (types[1] == AN))
1337 types[0] = R;
1338 else if (types[1] == L)
1339 types[0] = L;
1340 }
1341 for (i=1; i<(count-1); i++) {
1342 if (types[i] == ON) {
1343 if (types[i-1] == L) {
1344 j=i;
1345 while (j<(count-1) && types[j] == ON) {
1346 j++;
1347 }
1348 if (types[j] == L) {
1349 while (i<j) {
1350 types[i] = L;
1351 i++;
1352 }
1353 }
1354
1355 } else if ((types[i-1] == R) ||
1356 (types[i-1] == EN) ||
1357 (types[i-1] == AN)) {
1358 j=i;
1359 while (j<(count-1) && types[j] == ON) {
1360 j++;
1361 }
1362 if ((types[j] == R) ||
1363 (types[j] == EN) ||
1364 (types[j] == AN)) {
1365 while (i<j) {
1366 types[i] = R;
1367 i++;
1368 }
1369 }
1370 }
1371 }
1372 }
1373 if (count >= 2 && types[count-1] == ON) {
1374 if (types[count-2] == R || types[count-2] == EN || types[count-2] == AN)
1375 types[count-1] = R;
1376 else if (types[count-2] == L)
1377 types[count-1] = L;
1378 }
1379
1380 /* Rule (N2)
1381 * N2. Any remaining neutrals take the embedding direction.
1382 */
1383 for (i=0; i<count; i++) {
1384 if (types[i] == ON) {
1385 if ((levels[i] % 2) == 0)
1386 types[i] = L;
1387 else
1388 types[i] = R;
1389 }
1390 }
1391
1392 /* Rule (I1)
1393 * I1. For all characters with an even (left-to-right) embedding
1394 * direction, those of type R go up one level and those of type AN or
1395 * EN go up two levels.
1396 */
1397 for (i=0; i<count; i++) {
1398 if ((levels[i] % 2) == 0) {
1399 if (types[i] == R)
1400 levels[i] += 1;
1401 else if (types[i] == AN || types[i] == EN)
1402 levels[i] += 2;
1403 }
1404 }
1405
1406 /* Rule (I2)
1407 * I2. For all characters with an odd (right-to-left) embedding direction,
1408 * those of type L, EN or AN go up one level.
1409 */
1410 for (i=0; i<count; i++) {
1411 if ((levels[i] % 2) == 1) {
1412 if (types[i] == L || types[i] == EN || types[i] == AN)
1413 levels[i] += 1;
1414 }
1415 }
1416
1417 /* Rule (L1)
1418 * L1. On each line, reset the embedding level of the following characters
1419 * to the paragraph embedding level:
1420 * (1)segment separators, (2)paragraph separators,
1421 * (3)any sequence of whitespace characters preceding
1422 * a segment separator or paragraph separator,
1423 * (4)and any sequence of white space characters
1424 * at the end of the line.
1425 * The types of characters used here are the original types, not those
1426 * modified by the previous phase.
1427 */
1428 j=count-1;
1429 while (j>0 && (getType(line[j].wc) == WS)) {
1430 j--;
1431 }
1432 if (j < (count-1)) {
1433 for (j++; j<count; j++)
1434 levels[j] = paragraphLevel;
1435 }
1436 for (i=0; i<count; i++) {
1437 tempType = getType(line[i].wc);
1438 if (tempType == WS) {
1439 j=i;
1440 while (j<count && (getType(line[j].wc) == WS)) {
1441 j++;
1442 }
1443 if (j==count || getType(line[j].wc) == B ||
1444 getType(line[j].wc) == S) {
1445 for (j--; j>=i ; j--) {
1446 levels[j] = paragraphLevel;
1447 }
1448 }
1449 } else if (tempType == B || tempType == S) {
1450 levels[i] = paragraphLevel;
1451 }
1452 }
1453
1454 /* Rule (L4) NOT IMPLEMENTED
1455 * L4. A character that possesses the mirrored property as specified by
1456 * Section 4.7, Mirrored, must be depicted by a mirrored glyph if the
1457 * resolved directionality of that character is R.
1458 */
1459 /* Note: this is implemented before L2 for efficiency */
1460 for (i=0; i<count; i++)
1461 if ((levels[i] % 2) == 1)
1462 doMirror(&line[i].wc);
1463
1464 /* Rule (L2)
1465 * L2. From the highest level found in the text to the lowest odd level on
1466 * each line, including intermediate levels not actually present in the
1467 * text, reverse any contiguous sequence of characters that are at that
1468 * level or higher
1469 */
1470 /* we flip the character string and leave the level array */
1471 imax = 0;
1472 i=0;
1473 tempType = levels[0];
1474 while (i < count) {
1475 if (levels[i] > tempType) {
1476 tempType = levels[i];
1477 imax=i;
1478 }
1479 i++;
1480 }
1481 /* maximum level in tempType, its index in imax. */
1482 while (tempType > 0) { /* loop from highest level to the least odd, */
1483 /* which i assume is 1 */
1484 flipThisRun(line, levels, tempType, count);
1485 tempType--;
1486 }
1487
1488 /* Rule (L3) NOT IMPLEMENTED
1489 * L3. Combining marks applied to a right-to-left base character will at
1490 * this point precede their base character. If the rendering engine
1491 * expects them to follow the base characters in the final display
1492 * process, then the ordering of the marks and the base character must
1493 * be reversed.
1494 */
1495 sfree(types);
1496 sfree(levels);
1497 return R;
1498 }
1499
1500
1501 /*
1502 * Bad, Horrible function
1503 * takes a pointer to a character that is checked for
1504 * having a mirror glyph.
1505 */
1506 void doMirror(wchar_t* ch)
1507 {
1508 if ((*ch & 0xFF00) == 0) {
1509 switch (*ch) {
1510 case 0x0028: *ch = 0x0029; break;
1511 case 0x0029: *ch = 0x0028; break;
1512 case 0x003C: *ch = 0x003E; break;
1513 case 0x003E: *ch = 0x003C; break;
1514 case 0x005B: *ch = 0x005D; break;
1515 case 0x005D: *ch = 0x005B; break;
1516 case 0x007B: *ch = 0x007D; break;
1517 case 0x007D: *ch = 0x007B; break;
1518 case 0x00AB: *ch = 0x00BB; break;
1519 case 0x00BB: *ch = 0x00AB; break;
1520 }
1521 } else if ((*ch & 0xFF00) == 0x2000) {
1522 switch (*ch) {
1523 case 0x2039: *ch = 0x203A; break;
1524 case 0x203A: *ch = 0x2039; break;
1525 case 0x2045: *ch = 0x2046; break;
1526 case 0x2046: *ch = 0x2045; break;
1527 case 0x207D: *ch = 0x207E; break;
1528 case 0x207E: *ch = 0x207D; break;
1529 case 0x208D: *ch = 0x208E; break;
1530 case 0x208E: *ch = 0x208D; break;
1531 }
1532 } else if ((*ch & 0xFF00) == 0x2200) {
1533 switch (*ch) {
1534 case 0x2208: *ch = 0x220B; break;
1535 case 0x2209: *ch = 0x220C; break;
1536 case 0x220A: *ch = 0x220D; break;
1537 case 0x220B: *ch = 0x2208; break;
1538 case 0x220C: *ch = 0x2209; break;
1539 case 0x220D: *ch = 0x220A; break;
1540 case 0x2215: *ch = 0x29F5; break;
1541 case 0x223C: *ch = 0x223D; break;
1542 case 0x223D: *ch = 0x223C; break;
1543 case 0x2243: *ch = 0x22CD; break;
1544 case 0x2252: *ch = 0x2253; break;
1545 case 0x2253: *ch = 0x2252; break;
1546 case 0x2254: *ch = 0x2255; break;
1547 case 0x2255: *ch = 0x2254; break;
1548 case 0x2264: *ch = 0x2265; break;
1549 case 0x2265: *ch = 0x2264; break;
1550 case 0x2266: *ch = 0x2267; break;
1551 case 0x2267: *ch = 0x2266; break;
1552 case 0x2268: *ch = 0x2269; break;
1553 case 0x2269: *ch = 0x2268; break;
1554 case 0x226A: *ch = 0x226B; break;
1555 case 0x226B: *ch = 0x226A; break;
1556 case 0x226E: *ch = 0x226F; break;
1557 case 0x226F: *ch = 0x226E; break;
1558 case 0x2270: *ch = 0x2271; break;
1559 case 0x2271: *ch = 0x2270; break;
1560 case 0x2272: *ch = 0x2273; break;
1561 case 0x2273: *ch = 0x2272; break;
1562 case 0x2274: *ch = 0x2275; break;
1563 case 0x2275: *ch = 0x2274; break;
1564 case 0x2276: *ch = 0x2277; break;
1565 case 0x2277: *ch = 0x2276; break;
1566 case 0x2278: *ch = 0x2279; break;
1567 case 0x2279: *ch = 0x2278; break;
1568 case 0x227A: *ch = 0x227B; break;
1569 case 0x227B: *ch = 0x227A; break;
1570 case 0x227C: *ch = 0x227D; break;
1571 case 0x227D: *ch = 0x227C; break;
1572 case 0x227E: *ch = 0x227F; break;
1573 case 0x227F: *ch = 0x227E; break;
1574 case 0x2280: *ch = 0x2281; break;
1575 case 0x2281: *ch = 0x2280; break;
1576 case 0x2282: *ch = 0x2283; break;
1577 case 0x2283: *ch = 0x2282; break;
1578 case 0x2284: *ch = 0x2285; break;
1579 case 0x2285: *ch = 0x2284; break;
1580 case 0x2286: *ch = 0x2287; break;
1581 case 0x2287: *ch = 0x2286; break;
1582 case 0x2288: *ch = 0x2289; break;
1583 case 0x2289: *ch = 0x2288; break;
1584 case 0x228A: *ch = 0x228B; break;
1585 case 0x228B: *ch = 0x228A; break;
1586 case 0x228F: *ch = 0x2290; break;
1587 case 0x2290: *ch = 0x228F; break;
1588 case 0x2291: *ch = 0x2292; break;
1589 case 0x2292: *ch = 0x2291; break;
1590 case 0x2298: *ch = 0x29B8; break;
1591 case 0x22A2: *ch = 0x22A3; break;
1592 case 0x22A3: *ch = 0x22A2; break;
1593 case 0x22A6: *ch = 0x2ADE; break;
1594 case 0x22A8: *ch = 0x2AE4; break;
1595 case 0x22A9: *ch = 0x2AE3; break;
1596 case 0x22AB: *ch = 0x2AE5; break;
1597 case 0x22B0: *ch = 0x22B1; break;
1598 case 0x22B1: *ch = 0x22B0; break;
1599 case 0x22B2: *ch = 0x22B3; break;
1600 case 0x22B3: *ch = 0x22B2; break;
1601 case 0x22B4: *ch = 0x22B5; break;
1602 case 0x22B5: *ch = 0x22B4; break;
1603 case 0x22B6: *ch = 0x22B7; break;
1604 case 0x22B7: *ch = 0x22B6; break;
1605 case 0x22C9: *ch = 0x22CA; break;
1606 case 0x22CA: *ch = 0x22C9; break;
1607 case 0x22CB: *ch = 0x22CC; break;
1608 case 0x22CC: *ch = 0x22CB; break;
1609 case 0x22CD: *ch = 0x2243; break;
1610 case 0x22D0: *ch = 0x22D1; break;
1611 case 0x22D1: *ch = 0x22D0; break;
1612 case 0x22D6: *ch = 0x22D7; break;
1613 case 0x22D7: *ch = 0x22D6; break;
1614 case 0x22D8: *ch = 0x22D9; break;
1615 case 0x22D9: *ch = 0x22D8; break;
1616 case 0x22DA: *ch = 0x22DB; break;
1617 case 0x22DB: *ch = 0x22DA; break;
1618 case 0x22DC: *ch = 0x22DD; break;
1619 case 0x22DD: *ch = 0x22DC; break;
1620 case 0x22DE: *ch = 0x22DF; break;
1621 case 0x22DF: *ch = 0x22DE; break;
1622 case 0x22E0: *ch = 0x22E1; break;
1623 case 0x22E1: *ch = 0x22E0; break;
1624 case 0x22E2: *ch = 0x22E3; break;
1625 case 0x22E3: *ch = 0x22E2; break;
1626 case 0x22E4: *ch = 0x22E5; break;
1627 case 0x22E5: *ch = 0x22E4; break;
1628 case 0x22E6: *ch = 0x22E7; break;
1629 case 0x22E7: *ch = 0x22E6; break;
1630 case 0x22E8: *ch = 0x22E9; break;
1631 case 0x22E9: *ch = 0x22E8; break;
1632 case 0x22EA: *ch = 0x22EB; break;
1633 case 0x22EB: *ch = 0x22EA; break;
1634 case 0x22EC: *ch = 0x22ED; break;
1635 case 0x22ED: *ch = 0x22EC; break;
1636 case 0x22F0: *ch = 0x22F1; break;
1637 case 0x22F1: *ch = 0x22F0; break;
1638 case 0x22F2: *ch = 0x22FA; break;
1639 case 0x22F3: *ch = 0x22FB; break;
1640 case 0x22F4: *ch = 0x22FC; break;
1641 case 0x22F6: *ch = 0x22FD; break;
1642 case 0x22F7: *ch = 0x22FE; break;
1643 case 0x22FA: *ch = 0x22F2; break;
1644 case 0x22FB: *ch = 0x22F3; break;
1645 case 0x22FC: *ch = 0x22F4; break;
1646 case 0x22FD: *ch = 0x22F6; break;
1647 case 0x22FE: *ch = 0x22F7; break;
1648 }
1649 } else if ((*ch & 0xFF00) == 0x2300) {
1650 switch (*ch) {
1651 case 0x2308: *ch = 0x2309; break;
1652 case 0x2309: *ch = 0x2308; break;
1653 case 0x230A: *ch = 0x230B; break;
1654 case 0x230B: *ch = 0x230A; break;
1655 case 0x2329: *ch = 0x232A; break;
1656 case 0x232A: *ch = 0x2329; break;
1657 }
1658 } else if ((*ch & 0xFF00) == 0x2700) {
1659 switch (*ch) {
1660 case 0x2768: *ch = 0x2769; break;
1661 case 0x2769: *ch = 0x2768; break;
1662 case 0x276A: *ch = 0x276B; break;
1663 case 0x276B: *ch = 0x276A; break;
1664 case 0x276C: *ch = 0x276D; break;
1665 case 0x276D: *ch = 0x276C; break;
1666 case 0x276E: *ch = 0x276F; break;
1667 case 0x276F: *ch = 0x276E; break;
1668 case 0x2770: *ch = 0x2771; break;
1669 case 0x2771: *ch = 0x2770; break;
1670 case 0x2772: *ch = 0x2773; break;
1671 case 0x2773: *ch = 0x2772; break;
1672 case 0x2774: *ch = 0x2775; break;
1673 case 0x2775: *ch = 0x2774; break;
1674 case 0x27D5: *ch = 0x27D6; break;
1675 case 0x27D6: *ch = 0x27D5; break;
1676 case 0x27DD: *ch = 0x27DE; break;
1677 case 0x27DE: *ch = 0x27DD; break;
1678 case 0x27E2: *ch = 0x27E3; break;
1679 case 0x27E3: *ch = 0x27E2; break;
1680 case 0x27E4: *ch = 0x27E5; break;
1681 case 0x27E5: *ch = 0x27E4; break;
1682 case 0x27E6: *ch = 0x27E7; break;
1683 case 0x27E7: *ch = 0x27E6; break;
1684 case 0x27E8: *ch = 0x27E9; break;
1685 case 0x27E9: *ch = 0x27E8; break;
1686 case 0x27EA: *ch = 0x27EB; break;
1687 case 0x27EB: *ch = 0x27EA; break;
1688 }
1689 } else if ((*ch & 0xFF00) == 0x2900) {
1690 switch (*ch) {
1691 case 0x2983: *ch = 0x2984; break;
1692 case 0x2984: *ch = 0x2983; break;
1693 case 0x2985: *ch = 0x2986; break;
1694 case 0x2986: *ch = 0x2985; break;
1695 case 0x2987: *ch = 0x2988; break;
1696 case 0x2988: *ch = 0x2987; break;
1697 case 0x2989: *ch = 0x298A; break;
1698 case 0x298A: *ch = 0x2989; break;
1699 case 0x298B: *ch = 0x298C; break;
1700 case 0x298C: *ch = 0x298B; break;
1701 case 0x298D: *ch = 0x2990; break;
1702 case 0x298E: *ch = 0x298F; break;
1703 case 0x298F: *ch = 0x298E; break;
1704 case 0x2990: *ch = 0x298D; break;
1705 case 0x2991: *ch = 0x2992; break;
1706 case 0x2992: *ch = 0x2991; break;
1707 case 0x2993: *ch = 0x2994; break;
1708 case 0x2994: *ch = 0x2993; break;
1709 case 0x2995: *ch = 0x2996; break;
1710 case 0x2996: *ch = 0x2995; break;
1711 case 0x2997: *ch = 0x2998; break;
1712 case 0x2998: *ch = 0x2997; break;
1713 case 0x29B8: *ch = 0x2298; break;
1714 case 0x29C0: *ch = 0x29C1; break;
1715 case 0x29C1: *ch = 0x29C0; break;
1716 case 0x29C4: *ch = 0x29C5; break;
1717 case 0x29C5: *ch = 0x29C4; break;
1718 case 0x29CF: *ch = 0x29D0; break;
1719 case 0x29D0: *ch = 0x29CF; break;
1720 case 0x29D1: *ch = 0x29D2; break;
1721 case 0x29D2: *ch = 0x29D1; break;
1722 case 0x29D4: *ch = 0x29D5; break;
1723 case 0x29D5: *ch = 0x29D4; break;
1724 case 0x29D8: *ch = 0x29D9; break;
1725 case 0x29D9: *ch = 0x29D8; break;
1726 case 0x29DA: *ch = 0x29DB; break;
1727 case 0x29DB: *ch = 0x29DA; break;
1728 case 0x29F5: *ch = 0x2215; break;
1729 case 0x29F8: *ch = 0x29F9; break;
1730 case 0x29F9: *ch = 0x29F8; break;
1731 case 0x29FC: *ch = 0x29FD; break;
1732 case 0x29FD: *ch = 0x29FC; break;
1733 }
1734 } else if ((*ch & 0xFF00) == 0x2A00) {
1735 switch (*ch) {
1736 case 0x2A2B: *ch = 0x2A2C; break;
1737 case 0x2A2C: *ch = 0x2A2B; break;
1738 case 0x2A2D: *ch = 0x2A2C; break;
1739 case 0x2A2E: *ch = 0x2A2D; break;
1740 case 0x2A34: *ch = 0x2A35; break;
1741 case 0x2A35: *ch = 0x2A34; break;
1742 case 0x2A3C: *ch = 0x2A3D; break;
1743 case 0x2A3D: *ch = 0x2A3C; break;
1744 case 0x2A64: *ch = 0x2A65; break;
1745 case 0x2A65: *ch = 0x2A64; break;
1746 case 0x2A79: *ch = 0x2A7A; break;
1747 case 0x2A7A: *ch = 0x2A79; break;
1748 case 0x2A7D: *ch = 0x2A7E; break;
1749 case 0x2A7E: *ch = 0x2A7D; break;
1750 case 0x2A7F: *ch = 0x2A80; break;
1751 case 0x2A80: *ch = 0x2A7F; break;
1752 case 0x2A81: *ch = 0x2A82; break;
1753 case 0x2A82: *ch = 0x2A81; break;
1754 case 0x2A83: *ch = 0x2A84; break;
1755 case 0x2A84: *ch = 0x2A83; break;
1756 case 0x2A8B: *ch = 0x2A8C; break;
1757 case 0x2A8C: *ch = 0x2A8B; break;
1758 case 0x2A91: *ch = 0x2A92; break;
1759 case 0x2A92: *ch = 0x2A91; break;
1760 case 0x2A93: *ch = 0x2A94; break;
1761 case 0x2A94: *ch = 0x2A93; break;
1762 case 0x2A95: *ch = 0x2A96; break;
1763 case 0x2A96: *ch = 0x2A95; break;
1764 case 0x2A97: *ch = 0x2A98; break;
1765 case 0x2A98: *ch = 0x2A97; break;
1766 case 0x2A99: *ch = 0x2A9A; break;
1767 case 0x2A9A: *ch = 0x2A99; break;
1768 case 0x2A9B: *ch = 0x2A9C; break;
1769 case 0x2A9C: *ch = 0x2A9B; break;
1770 case 0x2AA1: *ch = 0x2AA2; break;
1771 case 0x2AA2: *ch = 0x2AA1; break;
1772 case 0x2AA6: *ch = 0x2AA7; break;
1773 case 0x2AA7: *ch = 0x2AA6; break;
1774 case 0x2AA8: *ch = 0x2AA9; break;
1775 case 0x2AA9: *ch = 0x2AA8; break;
1776 case 0x2AAA: *ch = 0x2AAB; break;
1777 case 0x2AAB: *ch = 0x2AAA; break;
1778 case 0x2AAC: *ch = 0x2AAD; break;
1779 case 0x2AAD: *ch = 0x2AAC; break;
1780 case 0x2AAF: *ch = 0x2AB0; break;
1781 case 0x2AB0: *ch = 0x2AAF; break;
1782 case 0x2AB3: *ch = 0x2AB4; break;
1783 case 0x2AB4: *ch = 0x2AB3; break;
1784 case 0x2ABB: *ch = 0x2ABC; break;
1785 case 0x2ABC: *ch = 0x2ABB; break;
1786 case 0x2ABD: *ch = 0x2ABE; break;
1787 case 0x2ABE: *ch = 0x2ABD; break;
1788 case 0x2ABF: *ch = 0x2AC0; break;
1789 case 0x2AC0: *ch = 0x2ABF; break;
1790 case 0x2AC1: *ch = 0x2AC2; break;
1791 case 0x2AC2: *ch = 0x2AC1; break;
1792 case 0x2AC3: *ch = 0x2AC4; break;
1793 case 0x2AC4: *ch = 0x2AC3; break;
1794 case 0x2AC5: *ch = 0x2AC6; break;
1795 case 0x2AC6: *ch = 0x2AC5; break;
1796 case 0x2ACD: *ch = 0x2ACE; break;
1797 case 0x2ACE: *ch = 0x2ACD; break;
1798 case 0x2ACF: *ch = 0x2AD0; break;
1799 case 0x2AD0: *ch = 0x2ACF; break;
1800 case 0x2AD1: *ch = 0x2AD2; break;
1801 case 0x2AD2: *ch = 0x2AD1; break;
1802 case 0x2AD3: *ch = 0x2AD4; break;
1803 case 0x2AD4: *ch = 0x2AD3; break;
1804 case 0x2AD5: *ch = 0x2AD6; break;
1805 case 0x2AD6: *ch = 0x2AD5; break;
1806 case 0x2ADE: *ch = 0x22A6; break;
1807 case 0x2AE3: *ch = 0x22A9; break;
1808 case 0x2AE4: *ch = 0x22A8; break;
1809 case 0x2AE5: *ch = 0x22AB; break;
1810 case 0x2AEC: *ch = 0x2AED; break;
1811 case 0x2AED: *ch = 0x2AEC; break;
1812 case 0x2AF7: *ch = 0x2AF8; break;
1813 case 0x2AF8: *ch = 0x2AF7; break;
1814 case 0x2AF9: *ch = 0x2AFA; break;
1815 case 0x2AFA: *ch = 0x2AF9; break;
1816 }
1817 } else if ((*ch & 0xFF00) == 0x3000) {
1818 switch (*ch) {
1819 case 0x3008: *ch = 0x3009; break;
1820 case 0x3009: *ch = 0x3008; break;
1821 case 0x300A: *ch = 0x300B; break;
1822 case 0x300B: *ch = 0x300A; break;
1823 case 0x300C: *ch = 0x300D; break;
1824 case 0x300D: *ch = 0x300C; break;
1825 case 0x300E: *ch = 0x300F; break;
1826 case 0x300F: *ch = 0x300E; break;
1827 case 0x3010: *ch = 0x3011; break;
1828 case 0x3011: *ch = 0x3010; break;
1829 case 0x3014: *ch = 0x3015; break;
1830 case 0x3015: *ch = 0x3014; break;
1831 case 0x3016: *ch = 0x3017; break;
1832 case 0x3017: *ch = 0x3016; break;
1833 case 0x3018: *ch = 0x3019; break;
1834 case 0x3019: *ch = 0x3018; break;
1835 case 0x301A: *ch = 0x301B; break;
1836 case 0x301B: *ch = 0x301A; break;
1837 }
1838 } else if ((*ch & 0xFF00) == 0xFF00) {
1839 switch (*ch) {
1840 case 0xFF08: *ch = 0xFF09; break;
1841 case 0xFF09: *ch = 0xFF08; break;
1842 case 0xFF1C: *ch = 0xFF1E; break;
1843 case 0xFF1E: *ch = 0xFF1C; break;
1844 case 0xFF3B: *ch = 0xFF3D; break;
1845 case 0xFF3D: *ch = 0xFF3B; break;
1846 case 0xFF5B: *ch = 0xFF5D; break;
1847 case 0xFF5D: *ch = 0xFF5B; break;
1848 case 0xFF5F: *ch = 0xFF60; break;
1849 case 0xFF60: *ch = 0xFF5F; break;
1850 case 0xFF62: *ch = 0xFF63; break;
1851 case 0xFF63: *ch = 0xFF62; break;
1852 }
1853 }
1854 }
1855
1856 #ifdef TEST_GETTYPE
1857
1858 #include <stdio.h>
1859 #include <assert.h>
1860
1861 int main(int argc, char **argv)
1862 {
1863 static const struct { int type; char *name; } typetoname[] = {
1864 #define TYPETONAME(X) { X , #X }
1865 TYPETONAME(L),
1866 TYPETONAME(LRE),
1867 TYPETONAME(LRO),
1868 TYPETONAME(R),
1869 TYPETONAME(AL),
1870 TYPETONAME(RLE),
1871 TYPETONAME(RLO),
1872 TYPETONAME(PDF),
1873 TYPETONAME(EN),
1874 TYPETONAME(ES),
1875 TYPETONAME(ET),
1876 TYPETONAME(AN),
1877 TYPETONAME(CS),
1878 TYPETONAME(NSM),
1879 TYPETONAME(BN),
1880 TYPETONAME(B),
1881 TYPETONAME(S),
1882 TYPETONAME(WS),
1883 TYPETONAME(ON),
1884 #undef TYPETONAME
1885 };
1886 int i;
1887
1888 for (i = 1; i < argc; i++) {
1889 unsigned long chr = strtoul(argv[i], NULL, 0);
1890 int type = getType(chr);
1891 assert(typetoname[type].type == type);
1892 printf("U+%04x: %s\n", chr, typetoname[type].name);
1893 }
1894
1895 return 0;
1896 }
1897
1898 #endif
Legendacy Cygwin terminal emulator with minimum perceived latency