1 /************************************************************************
7 * This is an implemention of Unicode's Bidirectional Algorithm
10 * http://www.unicode.org/reports/tr9/
12 * Author: Ahmad Khalifa
15 * Revision Details: (Updated by Revision Control System)
21 * (www.arabeyes.org - under MIT license)
23 ************************************************************************/
28 * - Explicit marks need to be handled (they are not 100% now)
32 #include <stdlib.h> /* definition of wchar_t*/
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 */
42 #define STYPE(xh) ((((xh) >= SHAPE_FIRST) && ((xh) <= SHAPE_LAST)) ? \
43 shapetypes[(xh)-SHAPE_FIRST].type : SU) /*))*/
44 #define SISOLATED(xh) (shapetypes[(xh)-SHAPE_FIRST].form_b)
45 #define SFINAL(xh) ((xh)+1)
46 #define SINITIAL(xh) ((xh)+2)
47 #define SMEDIAL(ch) ((ch)+3)
49 #define leastGreaterOdd(x) ( ((x)+1) | 1 )
50 #define leastGreaterEven(x) ( ((x)+2) &~ 1 )
52 typedef struct bidi_char {
57 /* function declarations */
58 void flipThisRun(bidi_char *from, unsigned char* level, int max, int count);
59 int findIndexOfRun(unsigned char* level , int start, int count, int tlevel);
60 unsigned char getType(int ch);
61 unsigned char setOverrideBits(unsigned char level, unsigned char override);
62 int getPreviousLevel(unsigned char* level, int from);
63 int do_shape(bidi_char *line, bidi_char *to, int count);
64 int do_bidi(bidi_char *line, int count);
65 void doMirror(wchar_t* ch);
92 SL, /* Left-Joining, doesnt exist in U+0600 - U+06FF */
93 SR, /* Right-Joining, ie has Isolated, Final */
94 SD, /* Dual-Joining, ie has Isolated, Final, Initial, Medial */
96 SC /* Join-Causing, like U+0640 (TATWEEL) */
104 /* Kept near the actual table, for verification. */
105 #define SHAPE_FIRST 0x621
106 #define SHAPE_LAST 0x64A
108 const shape_node shapetypes[] = {
109 /* index, Typ, Iso, Ligature Index*/
110 /* 621 */ {SU, 0xFE80},
111 /* 622 */ {SR, 0xFE81},
112 /* 623 */ {SR, 0xFE83},
113 /* 624 */ {SR, 0xFE85},
114 /* 625 */ {SR, 0xFE87},
115 /* 626 */ {SD, 0xFE89},
116 /* 627 */ {SR, 0xFE8D},
117 /* 628 */ {SD, 0xFE8F},
118 /* 629 */ {SR, 0xFE93},
119 /* 62A */ {SD, 0xFE95},
120 /* 62B */ {SD, 0xFE99},
121 /* 62C */ {SD, 0xFE9D},
122 /* 62D */ {SD, 0xFEA1},
123 /* 62E */ {SD, 0xFEA5},
124 /* 62F */ {SR, 0xFEA9},
125 /* 630 */ {SR, 0xFEAB},
126 /* 631 */ {SR, 0xFEAD},
127 /* 632 */ {SR, 0xFEAF},
128 /* 633 */ {SD, 0xFEB1},
129 /* 634 */ {SD, 0xFEB5},
130 /* 635 */ {SD, 0xFEB9},
131 /* 636 */ {SD, 0xFEBD},
132 /* 637 */ {SD, 0xFEC1},
133 /* 638 */ {SD, 0xFEC5},
134 /* 639 */ {SD, 0xFEC9},
135 /* 63A */ {SD, 0xFECD},
142 /* 641 */ {SD, 0xFED1},
143 /* 642 */ {SD, 0xFED5},
144 /* 643 */ {SD, 0xFED9},
145 /* 644 */ {SD, 0xFEDD},
146 /* 645 */ {SD, 0xFEE1},
147 /* 646 */ {SD, 0xFEE5},
148 /* 647 */ {SD, 0xFEE9},
149 /* 648 */ {SR, 0xFEED},
150 /* 649 */ {SR, 0xFEEF}, /* SD */
151 /* 64A */ {SD, 0xFEF1},
155 * Flips the text buffer, according to max level, and
159 * from: text buffer, on which to apply flipping
160 * level: resolved levels buffer
161 * max: the maximum level found in this line (should be unsigned char)
162 * count: line size in bidi_char
164 void flipThisRun(bidi_char *from, unsigned char *level, int max, int count)
170 while (i<count && j<count) {
172 /* find the start of the run of level=max */
174 i = j = findIndexOfRun(level, i, count, max);
175 /* find the end of the run */
176 while (i<count && tlevel <= level[i]) {
179 for (k = i - 1; k > j; k--, j++) {
188 * Finds the index of a run with level equals tlevel
190 int findIndexOfRun(unsigned char* level , int start, int count, int tlevel)
193 for (i=start; i<count; i++) {
194 if (tlevel == level[i]) {
202 * Returns the bidi character type of ch.
204 * The data table in this function is constructed from the Unicode
205 * Character Database, downloadable from unicode.org at the URL
207 * http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
209 * by the following fragment of Perl:
211 perl -ne 'split ";"; $num = hex $_[0]; $type = $_[4];' \
212 -e '$fl = ($_[1] =~ /First/ ? 1 : $_[1] =~ /Last/ ? 2 : 0);' \
213 -e 'if ($type eq $runtype and ($runend == $num-1 or ' \
214 -e ' ($fl==2 and $pfl==1))) {$runend = $num;} else { &reset; }' \
215 -e '$pfl=$fl; END { &reset }; sub reset {' \
216 -e 'printf" {0x%04x, 0x%04x, %s},\n",$runstart,$runend,$runtype' \
217 -e ' if defined $runstart and $runtype ne "ON";' \
218 -e '$runstart=$runend=$num; $runtype=$type;}' \
222 unsigned char getType(int ch)
224 static const struct {
225 int first, last, type;
227 {0x0000, 0x0008, BN},
231 {0x000c, 0x000c, WS},
233 {0x000e, 0x001b, BN},
236 {0x0020, 0x0020, WS},
237 {0x0023, 0x0025, ET},
238 {0x002b, 0x002b, ES},
239 {0x002c, 0x002c, CS},
240 {0x002d, 0x002d, ES},
241 {0x002e, 0x002f, CS},
242 {0x0030, 0x0039, EN},
243 {0x003a, 0x003a, CS},
246 {0x007f, 0x0084, BN},
248 {0x0086, 0x009f, BN},
249 {0x00a0, 0x00a0, CS},
250 {0x00a2, 0x00a5, ET},
252 {0x00ad, 0x00ad, BN},
253 {0x00b0, 0x00b1, ET},
254 {0x00b2, 0x00b3, EN},
256 {0x00b9, 0x00b9, EN},
266 {0x0300, 0x0357, NSM},
267 {0x035d, 0x036f, NSM},
277 {0x0483, 0x0486, NSM},
278 {0x0488, 0x0489, NSM},
287 {0x0591, 0x05a1, NSM},
288 {0x05a3, 0x05b9, NSM},
289 {0x05bb, 0x05bd, NSM},
291 {0x05bf, 0x05bf, NSM},
293 {0x05c1, 0x05c2, NSM},
295 {0x05c4, 0x05c4, NSM},
298 {0x0600, 0x0603, AL},
299 {0x060c, 0x060c, CS},
300 {0x060d, 0x060d, AL},
301 {0x0610, 0x0615, NSM},
302 {0x061b, 0x061b, AL},
303 {0x061f, 0x061f, AL},
304 {0x0621, 0x063a, AL},
305 {0x0640, 0x064a, AL},
306 {0x064b, 0x0658, NSM},
307 {0x0660, 0x0669, AN},
308 {0x066a, 0x066a, ET},
309 {0x066b, 0x066c, AN},
310 {0x066d, 0x066f, AL},
311 {0x0670, 0x0670, NSM},
312 {0x0671, 0x06d5, AL},
313 {0x06d6, 0x06dc, NSM},
314 {0x06dd, 0x06dd, AL},
315 {0x06de, 0x06e4, NSM},
316 {0x06e5, 0x06e6, AL},
317 {0x06e7, 0x06e8, NSM},
318 {0x06ea, 0x06ed, NSM},
319 {0x06ee, 0x06ef, AL},
320 {0x06f0, 0x06f9, EN},
321 {0x06fa, 0x070d, AL},
322 {0x070f, 0x070f, BN},
323 {0x0710, 0x0710, AL},
324 {0x0711, 0x0711, NSM},
325 {0x0712, 0x072f, AL},
326 {0x0730, 0x074a, NSM},
327 {0x074d, 0x074f, AL},
328 {0x0780, 0x07a5, AL},
329 {0x07a6, 0x07b0, NSM},
330 {0x07b1, 0x07b1, AL},
331 {0x0901, 0x0902, NSM},
333 {0x093c, 0x093c, NSM},
335 {0x0941, 0x0948, NSM},
337 {0x094d, 0x094d, NSM},
339 {0x0951, 0x0954, NSM},
341 {0x0962, 0x0963, NSM},
343 {0x0981, 0x0981, NSM},
351 {0x09bc, 0x09bc, NSM},
353 {0x09c1, 0x09c4, NSM},
356 {0x09cd, 0x09cd, NSM},
360 {0x09e2, 0x09e3, NSM},
362 {0x09f2, 0x09f3, ET},
364 {0x0a01, 0x0a02, NSM},
373 {0x0a3c, 0x0a3c, NSM},
375 {0x0a41, 0x0a42, NSM},
376 {0x0a47, 0x0a48, NSM},
377 {0x0a4b, 0x0a4d, NSM},
381 {0x0a70, 0x0a71, NSM},
383 {0x0a81, 0x0a82, NSM},
391 {0x0abc, 0x0abc, NSM},
393 {0x0ac1, 0x0ac5, NSM},
394 {0x0ac7, 0x0ac8, NSM},
397 {0x0acd, 0x0acd, NSM},
400 {0x0ae2, 0x0ae3, NSM},
402 {0x0af1, 0x0af1, ET},
403 {0x0b01, 0x0b01, NSM},
411 {0x0b3c, 0x0b3c, NSM},
413 {0x0b3f, 0x0b3f, NSM},
415 {0x0b41, 0x0b43, NSM},
418 {0x0b4d, 0x0b4d, NSM},
419 {0x0b56, 0x0b56, NSM},
424 {0x0b82, 0x0b82, NSM},
437 {0x0bc0, 0x0bc0, NSM},
441 {0x0bcd, 0x0bcd, NSM},
444 {0x0bf9, 0x0bf9, ET},
451 {0x0c3e, 0x0c40, NSM},
453 {0x0c46, 0x0c48, NSM},
454 {0x0c4a, 0x0c4d, NSM},
455 {0x0c55, 0x0c56, NSM},
464 {0x0cbc, 0x0cbc, NSM},
468 {0x0ccc, 0x0ccd, NSM},
479 {0x0d41, 0x0d43, NSM},
482 {0x0d4d, 0x0d4d, NSM},
492 {0x0dca, 0x0dca, NSM},
494 {0x0dd2, 0x0dd4, NSM},
495 {0x0dd6, 0x0dd6, NSM},
499 {0x0e31, 0x0e31, NSM},
501 {0x0e34, 0x0e3a, NSM},
502 {0x0e3f, 0x0e3f, ET},
504 {0x0e47, 0x0e4e, NSM},
518 {0x0eb1, 0x0eb1, NSM},
520 {0x0eb4, 0x0eb9, NSM},
521 {0x0ebb, 0x0ebc, NSM},
525 {0x0ec8, 0x0ecd, NSM},
529 {0x0f18, 0x0f19, NSM},
531 {0x0f35, 0x0f35, NSM},
533 {0x0f37, 0x0f37, NSM},
535 {0x0f39, 0x0f39, NSM},
538 {0x0f71, 0x0f7e, NSM},
540 {0x0f80, 0x0f84, NSM},
542 {0x0f86, 0x0f87, NSM},
544 {0x0f90, 0x0f97, NSM},
545 {0x0f99, 0x0fbc, NSM},
547 {0x0fc6, 0x0fc6, NSM},
554 {0x102d, 0x1030, NSM},
556 {0x1032, 0x1032, NSM},
557 {0x1036, 0x1037, NSM},
559 {0x1039, 0x1039, NSM},
561 {0x1058, 0x1059, NSM},
596 {0x1680, 0x1680, WS},
601 {0x1712, 0x1714, NSM},
603 {0x1732, 0x1734, NSM},
606 {0x1752, 0x1753, NSM},
609 {0x1772, 0x1773, NSM},
611 {0x17b7, 0x17bd, NSM},
613 {0x17c6, 0x17c6, NSM},
615 {0x17c9, 0x17d3, NSM},
617 {0x17db, 0x17db, ET},
619 {0x17dd, 0x17dd, NSM},
621 {0x180b, 0x180d, NSM},
622 {0x180e, 0x180e, WS},
626 {0x18a9, 0x18a9, NSM},
628 {0x1920, 0x1922, NSM},
630 {0x1927, 0x192b, NSM},
632 {0x1932, 0x1932, NSM},
634 {0x1939, 0x193b, NSM},
659 {0x2000, 0x200a, WS},
660 {0x200b, 0x200d, BN},
663 {0x2028, 0x2028, WS},
665 {0x202a, 0x202a, LRE},
666 {0x202b, 0x202b, RLE},
667 {0x202c, 0x202c, PDF},
668 {0x202d, 0x202d, LRO},
669 {0x202e, 0x202e, RLO},
670 {0x202f, 0x202f, WS},
671 {0x2030, 0x2034, ET},
672 {0x2044, 0x2044, CS},
673 {0x205f, 0x205f, WS},
674 {0x2060, 0x2063, BN},
675 {0x206a, 0x206f, BN},
676 {0x2070, 0x2070, EN},
678 {0x2074, 0x2079, EN},
679 {0x207a, 0x207b, ET},
681 {0x2080, 0x2089, EN},
682 {0x208a, 0x208b, ET},
683 {0x20a0, 0x20b1, ET},
684 {0x20d0, 0x20ea, NSM},
694 {0x212e, 0x212e, ET},
700 {0x2212, 0x2213, ET},
703 {0x2488, 0x249b, EN},
706 {0x3000, 0x3000, WS},
709 {0x302a, 0x302f, NSM},
713 {0x3099, 0x309a, NSM},
738 {0xfb1e, 0xfb1e, NSM},
740 {0xfb29, 0xfb29, ET},
747 {0xfb50, 0xfbb1, AL},
748 {0xfbd3, 0xfd3d, AL},
749 {0xfd50, 0xfd8f, AL},
750 {0xfd92, 0xfdc7, AL},
751 {0xfdf0, 0xfdfc, AL},
752 {0xfe00, 0xfe0f, NSM},
753 {0xfe20, 0xfe23, NSM},
754 {0xfe50, 0xfe50, CS},
755 {0xfe52, 0xfe52, CS},
756 {0xfe55, 0xfe55, CS},
757 {0xfe5f, 0xfe5f, ET},
758 {0xfe62, 0xfe63, ET},
759 {0xfe69, 0xfe6a, ET},
760 {0xfe70, 0xfe74, AL},
761 {0xfe76, 0xfefc, AL},
762 {0xfeff, 0xfeff, BN},
763 {0xff03, 0xff05, ET},
764 {0xff0b, 0xff0b, ET},
765 {0xff0c, 0xff0c, CS},
766 {0xff0d, 0xff0d, ET},
767 {0xff0e, 0xff0e, CS},
768 {0xff0f, 0xff0f, ES},
769 {0xff10, 0xff19, EN},
770 {0xff1a, 0xff1a, CS},
778 {0xffe0, 0xffe1, ET},
779 {0xffe5, 0xffe6, ET},
780 {0x10000, 0x1000b, L},
781 {0x1000d, 0x10026, L},
782 {0x10028, 0x1003a, L},
783 {0x1003c, 0x1003d, L},
784 {0x1003f, 0x1004d, L},
785 {0x10050, 0x1005d, L},
786 {0x10080, 0x100fa, L},
787 {0x10100, 0x10100, L},
788 {0x10102, 0x10102, L},
789 {0x10107, 0x10133, L},
790 {0x10137, 0x1013f, L},
791 {0x10300, 0x1031e, L},
792 {0x10320, 0x10323, L},
793 {0x10330, 0x1034a, L},
794 {0x10380, 0x1039d, L},
795 {0x1039f, 0x1039f, L},
796 {0x10400, 0x1049d, L},
797 {0x104a0, 0x104a9, L},
798 {0x10800, 0x10805, R},
799 {0x10808, 0x10808, R},
800 {0x1080a, 0x10835, R},
801 {0x10837, 0x10838, R},
802 {0x1083c, 0x1083c, R},
803 {0x1083f, 0x1083f, R},
804 {0x1d000, 0x1d0f5, L},
805 {0x1d100, 0x1d126, L},
806 {0x1d12a, 0x1d166, L},
807 {0x1d167, 0x1d169, NSM},
808 {0x1d16a, 0x1d172, L},
809 {0x1d173, 0x1d17a, BN},
810 {0x1d17b, 0x1d182, NSM},
811 {0x1d183, 0x1d184, L},
812 {0x1d185, 0x1d18b, NSM},
813 {0x1d18c, 0x1d1a9, L},
814 {0x1d1aa, 0x1d1ad, NSM},
815 {0x1d1ae, 0x1d1dd, L},
816 {0x1d400, 0x1d454, L},
817 {0x1d456, 0x1d49c, L},
818 {0x1d49e, 0x1d49f, L},
819 {0x1d4a2, 0x1d4a2, L},
820 {0x1d4a5, 0x1d4a6, L},
821 {0x1d4a9, 0x1d4ac, L},
822 {0x1d4ae, 0x1d4b9, L},
823 {0x1d4bb, 0x1d4bb, L},
824 {0x1d4bd, 0x1d4c3, L},
825 {0x1d4c5, 0x1d505, L},
826 {0x1d507, 0x1d50a, L},
827 {0x1d50d, 0x1d514, L},
828 {0x1d516, 0x1d51c, L},
829 {0x1d51e, 0x1d539, L},
830 {0x1d53b, 0x1d53e, L},
831 {0x1d540, 0x1d544, L},
832 {0x1d546, 0x1d546, L},
833 {0x1d54a, 0x1d550, L},
834 {0x1d552, 0x1d6a3, L},
835 {0x1d6a8, 0x1d7c9, L},
836 {0x1d7ce, 0x1d7ff, EN},
837 {0x20000, 0x2a6d6, L},
838 {0x2f800, 0x2fa1d, L},
839 {0xe0001, 0xe0001, BN},
840 {0xe0020, 0xe007f, BN},
841 {0xe0100, 0xe01ef, NSM},
842 {0xf0000, 0xffffd, L},
843 {0x100000, 0x10fffd, L},
853 if (ch < lookup[k].first)
855 else if (ch > lookup[k].last)
858 return lookup[k].type;
862 * If we reach here, the character was not in any of the
863 * intervals listed in the lookup table. This means we return
864 * ON (`Other Neutrals'). This is the appropriate code for any
865 * character genuinely not listed in the Unicode table, and
866 * also the table above has deliberately left out any
867 * characters _explicitly_ listed as ON (to save space!).
873 * The most significant 2 bits of each level are used to store
874 * Override status of each character
875 * This function sets the override bits of level according
876 * to the value in override, and reurns the new byte.
878 unsigned char setOverrideBits(unsigned char level, unsigned char override)
882 else if (override == R)
884 else if (override == L)
890 * Find the most recent run of the same value in `level', and
891 * return the value _before_ it. Used to process U+202C POP
892 * DIRECTIONAL FORMATTING.
894 int getPreviousLevel(unsigned char* level, int from)
897 unsigned char current = level[--from];
899 while (from >= 0 && level[from] == current)
910 /* The Main shaping function, and the only one to be used
911 * by the outside world.
913 * line: buffer to apply shaping to. this must be passed by doBidi() first
914 * to: output buffer for the shaped data
915 * count: number of characters in line
917 int do_shape(bidi_char *line, bidi_char *to, int count)
919 int i, tempShape, ligFlag;
921 for (ligFlag=i=0; i<count; i++) {
923 tempShape = STYPE(line[i].wc);
932 tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
933 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
934 to[i].wc = SFINAL((SISOLATED(line[i].wc)));
936 to[i].wc = SISOLATED(line[i].wc);
942 tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
943 if (line[i].wc == 0x644) {
944 if (i > 0) switch (line[i-1].wc) {
947 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
954 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
961 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
968 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
981 if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC)) {
982 tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
983 if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
984 to[i].wc = SMEDIAL((SISOLATED(line[i].wc)));
986 to[i].wc = SFINAL((SISOLATED(line[i].wc)));
990 tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
991 if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
992 to[i].wc = SINITIAL((SISOLATED(line[i].wc)));
994 to[i].wc = SISOLATED(line[i].wc);
1004 * The Main Bidi Function, and the only function that should
1005 * be used by the outside world.
1007 * line: a buffer of size count containing text to apply
1008 * the Bidirectional algorithm to.
1011 int do_bidi(bidi_char *line, int count)
1013 unsigned char* types;
1014 unsigned char* levels;
1015 unsigned char paragraphLevel;
1016 unsigned char currentEmbedding;
1017 unsigned char currentOverride;
1018 unsigned char tempType;
1019 int i, j, imax, yes, bover;
1021 /* Check the presence of R or AL types as optimization */
1023 for (i=0; i<count; i++) {
1024 int type = getType(line[i].wc);
1025 if (type == R || type == AL) {
1033 /* Initialize types, levels */
1034 types = snewn(count, unsigned char);
1035 levels = snewn(count, unsigned char);
1037 /* Rule (P1) NOT IMPLEMENTED
1038 * P1. Split the text into separate paragraphs. A paragraph separator is
1039 * kept with the previous paragraph. Within each paragraph, apply all the
1040 * other rules of this algorithm.
1044 * P2. In each paragraph, find the first character of type L, AL, or R.
1045 * P3. If a character is found in P2 and it is of type AL or R, then set
1046 * the paragraph embedding level to one; otherwise, set it to zero.
1049 for (i=0; i<count ; i++) {
1050 int type = getType(line[i].wc);
1051 if (type == R || type == AL) {
1054 } else if (type == L)
1059 * X1. Begin by setting the current embedding level to the paragraph
1060 * embedding level. Set the directional override status to neutral.
1062 currentEmbedding = paragraphLevel;
1063 currentOverride = ON;
1065 /* Rule (X2), (X3), (X4), (X5), (X6), (X7), (X8)
1066 * X2. With each RLE, compute the least greater odd embedding level.
1067 * X3. With each LRE, compute the least greater even embedding level.
1068 * X4. With each RLO, compute the least greater odd embedding level.
1069 * X5. With each LRO, compute the least greater even embedding level.
1070 * X6. For all types besides RLE, LRE, RLO, LRO, and PDF:
1071 * a. Set the level of the current character to the current
1073 * b. Whenever the directional override status is not neutral,
1074 * reset the current character type to the directional
1076 * X7. With each PDF, determine the matching embedding or override code.
1077 * If there was a valid matching code, restore (pop) the last
1078 * remembered (pushed) embedding level and directional override.
1079 * X8. All explicit directional embeddings and overrides are completely
1080 * terminated at the end of each paragraph. Paragraph separators are not
1081 * included in the embedding. (Useless here) NOT IMPLEMENTED
1084 for (i=0; i<count; i++) {
1085 tempType = getType(line[i].wc);
1088 currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
1089 levels[i] = setOverrideBits(levels[i], currentOverride);
1090 currentOverride = ON;
1094 currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
1095 levels[i] = setOverrideBits(levels[i], currentOverride);
1096 currentOverride = ON;
1100 currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
1101 tempType = currentOverride = R;
1106 currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
1107 tempType = currentOverride = L;
1113 int prevlevel = getPreviousLevel(levels, i);
1115 if (prevlevel == -1) {
1116 currentEmbedding = paragraphLevel;
1117 currentOverride = ON;
1119 currentOverride = currentEmbedding & OMASK;
1120 currentEmbedding = currentEmbedding & ~OMASK;
1123 levels[i] = currentEmbedding;
1126 /* Whitespace is treated as neutral for now */
1129 levels[i] = currentEmbedding;
1131 if (currentOverride != ON)
1132 tempType = currentOverride;
1136 levels[i] = currentEmbedding;
1137 if (currentOverride != ON)
1138 tempType = currentOverride;
1142 types[i] = tempType;
1144 /* this clears out all overrides, so we can use levels safely... */
1145 /* checks bover first */
1147 for (i=0; i<count; i++)
1148 levels[i] = levels[i] & LMASK;
1151 * X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
1152 * Here, they're converted to BN.
1154 for (i=0; i<count; i++) {
1167 * W1. Examine each non-spacing mark (NSM) in the level run, and change
1168 * the type of the NSM to the type of the previous character. If the NSM
1169 * is at the start of the level run, it will get the type of sor.
1171 if (types[0] == NSM)
1172 types[0] = paragraphLevel;
1174 for (i=1; i<count; i++) {
1175 if (types[i] == NSM)
1176 types[i] = types[i-1];
1177 /* Is this a safe assumption?
1178 * I assumed the previous, IS a character.
1183 * W2. Search backwards from each instance of a European number until the
1184 * first strong type (R, L, AL, or sor) is found. If an AL is found,
1185 * change the type of the European number to Arabic number.
1187 for (i=0; i<count; i++) {
1188 if (types[i] == EN) {
1191 if (types[j] == AL) {
1194 } else if (types[j] == R || types[j] == L) {
1203 * W3. Change all ALs to R.
1205 * Optimization: on Rule Xn, we might set a flag on AL type
1206 * to prevent this loop in L R lines only...
1208 for (i=0; i<count; i++) {
1214 * W4. A single European separator between two European numbers changes
1215 * to a European number. A single common separator between two numbers
1216 * of the same type changes to that type.
1218 for (i=1; i<(count-1); i++) {
1219 if (types[i] == ES) {
1220 if (types[i-1] == EN && types[i+1] == EN)
1222 } else if (types[i] == CS) {
1223 if (types[i-1] == EN && types[i+1] == EN)
1225 else if (types[i-1] == AN && types[i+1] == AN)
1231 * W5. A sequence of European terminators adjacent to European numbers
1232 * changes to all European numbers.
1234 * Optimization: lots here... else ifs need rearrangement
1236 for (i=0; i<count; i++) {
1237 if (types[i] == ET) {
1238 if (i > 0 && types[i-1] == EN) {
1241 } else if (i < count-1 && types[i+1] == EN) {
1244 } else if (i < count-1 && types[i+1] == ET) {
1246 while (j <count && types[j] == ET) {
1256 * W6. Otherwise, separators and terminators change to Other Neutral:
1258 for (i=0; i<count; i++) {
1269 * W7. Search backwards from each instance of a European number until
1270 * the first strong type (R, L, or sor) is found. If an L is found,
1271 * then change the type of the European number to L.
1273 for (i=0; i<count; i++) {
1274 if (types[i] == EN) {
1277 if (types[j] == L) {
1280 } else if (types[j] == R || types[j] == AL) {
1289 * N1. A sequence of neutrals takes the direction of the surrounding
1290 * strong text if the text on both sides has the same direction. European
1291 * and Arabic numbers are treated as though they were R.
1293 if (count >= 2 && types[0] == ON) {
1294 if ((types[1] == R) || (types[1] == EN) || (types[1] == AN))
1296 else if (types[1] == L)
1299 for (i=1; i<(count-1); i++) {
1300 if (types[i] == ON) {
1301 if (types[i-1] == L) {
1303 while (j<(count-1) && types[j] == ON) {
1306 if (types[j] == L) {
1313 } else if ((types[i-1] == R) ||
1314 (types[i-1] == EN) ||
1315 (types[i-1] == AN)) {
1317 while (j<(count-1) && types[j] == ON) {
1320 if ((types[j] == R) ||
1331 if (count >= 2 && types[count-1] == ON) {
1332 if (types[count-2] == R || types[count-2] == EN || types[count-2] == AN)
1334 else if (types[count-2] == L)
1339 * N2. Any remaining neutrals take the embedding direction.
1341 for (i=0; i<count; i++) {
1342 if (types[i] == ON) {
1343 if ((levels[i] % 2) == 0)
1351 * I1. For all characters with an even (left-to-right) embedding
1352 * direction, those of type R go up one level and those of type AN or
1353 * EN go up two levels.
1355 for (i=0; i<count; i++) {
1356 if ((levels[i] % 2) == 0) {
1359 else if (types[i] == AN || types[i] == EN)
1365 * I2. For all characters with an odd (right-to-left) embedding direction,
1366 * those of type L, EN or AN go up one level.
1368 for (i=0; i<count; i++) {
1369 if ((levels[i] % 2) == 1) {
1370 if (types[i] == L || types[i] == EN || types[i] == AN)
1376 * L1. On each line, reset the embedding level of the following characters
1377 * to the paragraph embedding level:
1378 * (1)segment separators, (2)paragraph separators,
1379 * (3)any sequence of whitespace characters preceding
1380 * a segment separator or paragraph separator,
1381 * (4)and any sequence of white space characters
1382 * at the end of the line.
1383 * The types of characters used here are the original types, not those
1384 * modified by the previous phase.
1387 while (j>0 && (getType(line[j].wc) == WS)) {
1390 if (j < (count-1)) {
1391 for (j++; j<count; j++)
1392 levels[j] = paragraphLevel;
1394 for (i=0; i<count; i++) {
1395 tempType = getType(line[i].wc);
1396 if (tempType == WS) {
1398 while (j<count && (getType(line[j].wc) == WS)) {
1401 if (j==count || getType(line[j].wc) == B ||
1402 getType(line[j].wc) == S) {
1403 for (j--; j>=i ; j--) {
1404 levels[j] = paragraphLevel;
1407 } else if (tempType == B || tempType == S) {
1408 levels[i] = paragraphLevel;
1412 /* Rule (L4) NOT IMPLEMENTED
1413 * L4. A character that possesses the mirrored property as specified by
1414 * Section 4.7, Mirrored, must be depicted by a mirrored glyph if the
1415 * resolved directionality of that character is R.
1417 /* Note: this is implemented before L2 for efficiency */
1418 for (i=0; i<count; i++)
1419 if ((levels[i] % 2) == 1)
1420 doMirror(&line[i].wc);
1423 * L2. From the highest level found in the text to the lowest odd level on
1424 * each line, including intermediate levels not actually present in the
1425 * text, reverse any contiguous sequence of characters that are at that
1428 /* we flip the character string and leave the level array */
1431 tempType = levels[0];
1433 if (levels[i] > tempType) {
1434 tempType = levels[i];
1439 /* maximum level in tempType, its index in imax. */
1440 while (tempType > 0) { /* loop from highest level to the least odd, */
1441 /* which i assume is 1 */
1442 flipThisRun(line, levels, tempType, count);
1446 /* Rule (L3) NOT IMPLEMENTED
1447 * L3. Combining marks applied to a right-to-left base character will at
1448 * this point precede their base character. If the rendering engine
1449 * expects them to follow the base characters in the final display
1450 * process, then the ordering of the marks and the base character must
1460 * Bad, Horrible function
1461 * takes a pointer to a character that is checked for
1462 * having a mirror glyph.
1464 void doMirror(wchar_t* ch)
1466 if ((*ch & 0xFF00) == 0) {
1468 case 0x0028: *ch = 0x0029; break;
1469 case 0x0029: *ch = 0x0028; break;
1470 case 0x003C: *ch = 0x003E; break;
1471 case 0x003E: *ch = 0x003C; break;
1472 case 0x005B: *ch = 0x005D; break;
1473 case 0x005D: *ch = 0x005B; break;
1474 case 0x007B: *ch = 0x007D; break;
1475 case 0x007D: *ch = 0x007B; break;
1476 case 0x00AB: *ch = 0x00BB; break;
1477 case 0x00BB: *ch = 0x00AB; break;
1479 } else if ((*ch & 0xFF00) == 0x2000) {
1481 case 0x2039: *ch = 0x203A; break;
1482 case 0x203A: *ch = 0x2039; break;
1483 case 0x2045: *ch = 0x2046; break;
1484 case 0x2046: *ch = 0x2045; break;
1485 case 0x207D: *ch = 0x207E; break;
1486 case 0x207E: *ch = 0x207D; break;
1487 case 0x208D: *ch = 0x208E; break;
1488 case 0x208E: *ch = 0x208D; break;
1490 } else if ((*ch & 0xFF00) == 0x2200) {
1492 case 0x2208: *ch = 0x220B; break;
1493 case 0x2209: *ch = 0x220C; break;
1494 case 0x220A: *ch = 0x220D; break;
1495 case 0x220B: *ch = 0x2208; break;
1496 case 0x220C: *ch = 0x2209; break;
1497 case 0x220D: *ch = 0x220A; break;
1498 case 0x2215: *ch = 0x29F5; break;
1499 case 0x223C: *ch = 0x223D; break;
1500 case 0x223D: *ch = 0x223C; break;
1501 case 0x2243: *ch = 0x22CD; break;
1502 case 0x2252: *ch = 0x2253; break;
1503 case 0x2253: *ch = 0x2252; break;
1504 case 0x2254: *ch = 0x2255; break;
1505 case 0x2255: *ch = 0x2254; break;
1506 case 0x2264: *ch = 0x2265; break;
1507 case 0x2265: *ch = 0x2264; break;
1508 case 0x2266: *ch = 0x2267; break;
1509 case 0x2267: *ch = 0x2266; break;
1510 case 0x2268: *ch = 0x2269; break;
1511 case 0x2269: *ch = 0x2268; break;
1512 case 0x226A: *ch = 0x226B; break;
1513 case 0x226B: *ch = 0x226A; break;
1514 case 0x226E: *ch = 0x226F; break;
1515 case 0x226F: *ch = 0x226E; break;
1516 case 0x2270: *ch = 0x2271; break;
1517 case 0x2271: *ch = 0x2270; break;
1518 case 0x2272: *ch = 0x2273; break;
1519 case 0x2273: *ch = 0x2272; break;
1520 case 0x2274: *ch = 0x2275; break;
1521 case 0x2275: *ch = 0x2274; break;
1522 case 0x2276: *ch = 0x2277; break;
1523 case 0x2277: *ch = 0x2276; break;
1524 case 0x2278: *ch = 0x2279; break;
1525 case 0x2279: *ch = 0x2278; break;
1526 case 0x227A: *ch = 0x227B; break;
1527 case 0x227B: *ch = 0x227A; break;
1528 case 0x227C: *ch = 0x227D; break;
1529 case 0x227D: *ch = 0x227C; break;
1530 case 0x227E: *ch = 0x227F; break;
1531 case 0x227F: *ch = 0x227E; break;
1532 case 0x2280: *ch = 0x2281; break;
1533 case 0x2281: *ch = 0x2280; break;
1534 case 0x2282: *ch = 0x2283; break;
1535 case 0x2283: *ch = 0x2282; break;
1536 case 0x2284: *ch = 0x2285; break;
1537 case 0x2285: *ch = 0x2284; break;
1538 case 0x2286: *ch = 0x2287; break;
1539 case 0x2287: *ch = 0x2286; break;
1540 case 0x2288: *ch = 0x2289; break;
1541 case 0x2289: *ch = 0x2288; break;
1542 case 0x228A: *ch = 0x228B; break;
1543 case 0x228B: *ch = 0x228A; break;
1544 case 0x228F: *ch = 0x2290; break;
1545 case 0x2290: *ch = 0x228F; break;
1546 case 0x2291: *ch = 0x2292; break;
1547 case 0x2292: *ch = 0x2291; break;
1548 case 0x2298: *ch = 0x29B8; break;
1549 case 0x22A2: *ch = 0x22A3; break;
1550 case 0x22A3: *ch = 0x22A2; break;
1551 case 0x22A6: *ch = 0x2ADE; break;
1552 case 0x22A8: *ch = 0x2AE4; break;
1553 case 0x22A9: *ch = 0x2AE3; break;
1554 case 0x22AB: *ch = 0x2AE5; break;
1555 case 0x22B0: *ch = 0x22B1; break;
1556 case 0x22B1: *ch = 0x22B0; break;
1557 case 0x22B2: *ch = 0x22B3; break;
1558 case 0x22B3: *ch = 0x22B2; break;
1559 case 0x22B4: *ch = 0x22B5; break;
1560 case 0x22B5: *ch = 0x22B4; break;
1561 case 0x22B6: *ch = 0x22B7; break;
1562 case 0x22B7: *ch = 0x22B6; break;
1563 case 0x22C9: *ch = 0x22CA; break;
1564 case 0x22CA: *ch = 0x22C9; break;
1565 case 0x22CB: *ch = 0x22CC; break;
1566 case 0x22CC: *ch = 0x22CB; break;
1567 case 0x22CD: *ch = 0x2243; break;
1568 case 0x22D0: *ch = 0x22D1; break;
1569 case 0x22D1: *ch = 0x22D0; break;
1570 case 0x22D6: *ch = 0x22D7; break;
1571 case 0x22D7: *ch = 0x22D6; break;
1572 case 0x22D8: *ch = 0x22D9; break;
1573 case 0x22D9: *ch = 0x22D8; break;
1574 case 0x22DA: *ch = 0x22DB; break;
1575 case 0x22DB: *ch = 0x22DA; break;
1576 case 0x22DC: *ch = 0x22DD; break;
1577 case 0x22DD: *ch = 0x22DC; break;
1578 case 0x22DE: *ch = 0x22DF; break;
1579 case 0x22DF: *ch = 0x22DE; break;
1580 case 0x22E0: *ch = 0x22E1; break;
1581 case 0x22E1: *ch = 0x22E0; break;
1582 case 0x22E2: *ch = 0x22E3; break;
1583 case 0x22E3: *ch = 0x22E2; break;
1584 case 0x22E4: *ch = 0x22E5; break;
1585 case 0x22E5: *ch = 0x22E4; break;
1586 case 0x22E6: *ch = 0x22E7; break;
1587 case 0x22E7: *ch = 0x22E6; break;
1588 case 0x22E8: *ch = 0x22E9; break;
1589 case 0x22E9: *ch = 0x22E8; break;
1590 case 0x22EA: *ch = 0x22EB; break;
1591 case 0x22EB: *ch = 0x22EA; break;
1592 case 0x22EC: *ch = 0x22ED; break;
1593 case 0x22ED: *ch = 0x22EC; break;
1594 case 0x22F0: *ch = 0x22F1; break;
1595 case 0x22F1: *ch = 0x22F0; break;
1596 case 0x22F2: *ch = 0x22FA; break;
1597 case 0x22F3: *ch = 0x22FB; break;
1598 case 0x22F4: *ch = 0x22FC; break;
1599 case 0x22F6: *ch = 0x22FD; break;
1600 case 0x22F7: *ch = 0x22FE; break;
1601 case 0x22FA: *ch = 0x22F2; break;
1602 case 0x22FB: *ch = 0x22F3; break;
1603 case 0x22FC: *ch = 0x22F4; break;
1604 case 0x22FD: *ch = 0x22F6; break;
1605 case 0x22FE: *ch = 0x22F7; break;
1607 } else if ((*ch & 0xFF00) == 0x2300) {
1609 case 0x2308: *ch = 0x2309; break;
1610 case 0x2309: *ch = 0x2308; break;
1611 case 0x230A: *ch = 0x230B; break;
1612 case 0x230B: *ch = 0x230A; break;
1613 case 0x2329: *ch = 0x232A; break;
1614 case 0x232A: *ch = 0x2329; break;
1616 } else if ((*ch & 0xFF00) == 0x2700) {
1618 case 0x2768: *ch = 0x2769; break;
1619 case 0x2769: *ch = 0x2768; break;
1620 case 0x276A: *ch = 0x276B; break;
1621 case 0x276B: *ch = 0x276A; break;
1622 case 0x276C: *ch = 0x276D; break;
1623 case 0x276D: *ch = 0x276C; break;
1624 case 0x276E: *ch = 0x276F; break;
1625 case 0x276F: *ch = 0x276E; break;
1626 case 0x2770: *ch = 0x2771; break;
1627 case 0x2771: *ch = 0x2770; break;
1628 case 0x2772: *ch = 0x2773; break;
1629 case 0x2773: *ch = 0x2772; break;
1630 case 0x2774: *ch = 0x2775; break;
1631 case 0x2775: *ch = 0x2774; break;
1632 case 0x27D5: *ch = 0x27D6; break;
1633 case 0x27D6: *ch = 0x27D5; break;
1634 case 0x27DD: *ch = 0x27DE; break;
1635 case 0x27DE: *ch = 0x27DD; break;
1636 case 0x27E2: *ch = 0x27E3; break;
1637 case 0x27E3: *ch = 0x27E2; break;
1638 case 0x27E4: *ch = 0x27E5; break;
1639 case 0x27E5: *ch = 0x27E4; break;
1640 case 0x27E6: *ch = 0x27E7; break;
1641 case 0x27E7: *ch = 0x27E6; break;
1642 case 0x27E8: *ch = 0x27E9; break;
1643 case 0x27E9: *ch = 0x27E8; break;
1644 case 0x27EA: *ch = 0x27EB; break;
1645 case 0x27EB: *ch = 0x27EA; break;
1647 } else if ((*ch & 0xFF00) == 0x2900) {
1649 case 0x2983: *ch = 0x2984; break;
1650 case 0x2984: *ch = 0x2983; break;
1651 case 0x2985: *ch = 0x2986; break;
1652 case 0x2986: *ch = 0x2985; break;
1653 case 0x2987: *ch = 0x2988; break;
1654 case 0x2988: *ch = 0x2987; break;
1655 case 0x2989: *ch = 0x298A; break;
1656 case 0x298A: *ch = 0x2989; break;
1657 case 0x298B: *ch = 0x298C; break;
1658 case 0x298C: *ch = 0x298B; break;
1659 case 0x298D: *ch = 0x2990; break;
1660 case 0x298E: *ch = 0x298F; break;
1661 case 0x298F: *ch = 0x298E; break;
1662 case 0x2990: *ch = 0x298D; break;
1663 case 0x2991: *ch = 0x2992; break;
1664 case 0x2992: *ch = 0x2991; break;
1665 case 0x2993: *ch = 0x2994; break;
1666 case 0x2994: *ch = 0x2993; break;
1667 case 0x2995: *ch = 0x2996; break;
1668 case 0x2996: *ch = 0x2995; break;
1669 case 0x2997: *ch = 0x2998; break;
1670 case 0x2998: *ch = 0x2997; break;
1671 case 0x29B8: *ch = 0x2298; break;
1672 case 0x29C0: *ch = 0x29C1; break;
1673 case 0x29C1: *ch = 0x29C0; break;
1674 case 0x29C4: *ch = 0x29C5; break;
1675 case 0x29C5: *ch = 0x29C4; break;
1676 case 0x29CF: *ch = 0x29D0; break;
1677 case 0x29D0: *ch = 0x29CF; break;
1678 case 0x29D1: *ch = 0x29D2; break;
1679 case 0x29D2: *ch = 0x29D1; break;
1680 case 0x29D4: *ch = 0x29D5; break;
1681 case 0x29D5: *ch = 0x29D4; break;
1682 case 0x29D8: *ch = 0x29D9; break;
1683 case 0x29D9: *ch = 0x29D8; break;
1684 case 0x29DA: *ch = 0x29DB; break;
1685 case 0x29DB: *ch = 0x29DA; break;
1686 case 0x29F5: *ch = 0x2215; break;
1687 case 0x29F8: *ch = 0x29F9; break;
1688 case 0x29F9: *ch = 0x29F8; break;
1689 case 0x29FC: *ch = 0x29FD; break;
1690 case 0x29FD: *ch = 0x29FC; break;
1692 } else if ((*ch & 0xFF00) == 0x2A00) {
1694 case 0x2A2B: *ch = 0x2A2C; break;
1695 case 0x2A2C: *ch = 0x2A2B; break;
1696 case 0x2A2D: *ch = 0x2A2C; break;
1697 case 0x2A2E: *ch = 0x2A2D; break;
1698 case 0x2A34: *ch = 0x2A35; break;
1699 case 0x2A35: *ch = 0x2A34; break;
1700 case 0x2A3C: *ch = 0x2A3D; break;
1701 case 0x2A3D: *ch = 0x2A3C; break;
1702 case 0x2A64: *ch = 0x2A65; break;
1703 case 0x2A65: *ch = 0x2A64; break;
1704 case 0x2A79: *ch = 0x2A7A; break;
1705 case 0x2A7A: *ch = 0x2A79; break;
1706 case 0x2A7D: *ch = 0x2A7E; break;
1707 case 0x2A7E: *ch = 0x2A7D; break;
1708 case 0x2A7F: *ch = 0x2A80; break;
1709 case 0x2A80: *ch = 0x2A7F; break;
1710 case 0x2A81: *ch = 0x2A82; break;
1711 case 0x2A82: *ch = 0x2A81; break;
1712 case 0x2A83: *ch = 0x2A84; break;
1713 case 0x2A84: *ch = 0x2A83; break;
1714 case 0x2A8B: *ch = 0x2A8C; break;
1715 case 0x2A8C: *ch = 0x2A8B; break;
1716 case 0x2A91: *ch = 0x2A92; break;
1717 case 0x2A92: *ch = 0x2A91; break;
1718 case 0x2A93: *ch = 0x2A94; break;
1719 case 0x2A94: *ch = 0x2A93; break;
1720 case 0x2A95: *ch = 0x2A96; break;
1721 case 0x2A96: *ch = 0x2A95; break;
1722 case 0x2A97: *ch = 0x2A98; break;
1723 case 0x2A98: *ch = 0x2A97; break;
1724 case 0x2A99: *ch = 0x2A9A; break;
1725 case 0x2A9A: *ch = 0x2A99; break;
1726 case 0x2A9B: *ch = 0x2A9C; break;
1727 case 0x2A9C: *ch = 0x2A9B; break;
1728 case 0x2AA1: *ch = 0x2AA2; break;
1729 case 0x2AA2: *ch = 0x2AA1; break;
1730 case 0x2AA6: *ch = 0x2AA7; break;
1731 case 0x2AA7: *ch = 0x2AA6; break;
1732 case 0x2AA8: *ch = 0x2AA9; break;
1733 case 0x2AA9: *ch = 0x2AA8; break;
1734 case 0x2AAA: *ch = 0x2AAB; break;
1735 case 0x2AAB: *ch = 0x2AAA; break;
1736 case 0x2AAC: *ch = 0x2AAD; break;
1737 case 0x2AAD: *ch = 0x2AAC; break;
1738 case 0x2AAF: *ch = 0x2AB0; break;
1739 case 0x2AB0: *ch = 0x2AAF; break;
1740 case 0x2AB3: *ch = 0x2AB4; break;
1741 case 0x2AB4: *ch = 0x2AB3; break;
1742 case 0x2ABB: *ch = 0x2ABC; break;
1743 case 0x2ABC: *ch = 0x2ABB; break;
1744 case 0x2ABD: *ch = 0x2ABE; break;
1745 case 0x2ABE: *ch = 0x2ABD; break;
1746 case 0x2ABF: *ch = 0x2AC0; break;
1747 case 0x2AC0: *ch = 0x2ABF; break;
1748 case 0x2AC1: *ch = 0x2AC2; break;
1749 case 0x2AC2: *ch = 0x2AC1; break;
1750 case 0x2AC3: *ch = 0x2AC4; break;
1751 case 0x2AC4: *ch = 0x2AC3; break;
1752 case 0x2AC5: *ch = 0x2AC6; break;
1753 case 0x2AC6: *ch = 0x2AC5; break;
1754 case 0x2ACD: *ch = 0x2ACE; break;
1755 case 0x2ACE: *ch = 0x2ACD; break;
1756 case 0x2ACF: *ch = 0x2AD0; break;
1757 case 0x2AD0: *ch = 0x2ACF; break;
1758 case 0x2AD1: *ch = 0x2AD2; break;
1759 case 0x2AD2: *ch = 0x2AD1; break;
1760 case 0x2AD3: *ch = 0x2AD4; break;
1761 case 0x2AD4: *ch = 0x2AD3; break;
1762 case 0x2AD5: *ch = 0x2AD6; break;
1763 case 0x2AD6: *ch = 0x2AD5; break;
1764 case 0x2ADE: *ch = 0x22A6; break;
1765 case 0x2AE3: *ch = 0x22A9; break;
1766 case 0x2AE4: *ch = 0x22A8; break;
1767 case 0x2AE5: *ch = 0x22AB; break;
1768 case 0x2AEC: *ch = 0x2AED; break;
1769 case 0x2AED: *ch = 0x2AEC; break;
1770 case 0x2AF7: *ch = 0x2AF8; break;
1771 case 0x2AF8: *ch = 0x2AF7; break;
1772 case 0x2AF9: *ch = 0x2AFA; break;
1773 case 0x2AFA: *ch = 0x2AF9; break;
1775 } else if ((*ch & 0xFF00) == 0x3000) {
1777 case 0x3008: *ch = 0x3009; break;
1778 case 0x3009: *ch = 0x3008; break;
1779 case 0x300A: *ch = 0x300B; break;
1780 case 0x300B: *ch = 0x300A; break;
1781 case 0x300C: *ch = 0x300D; break;
1782 case 0x300D: *ch = 0x300C; break;
1783 case 0x300E: *ch = 0x300F; break;
1784 case 0x300F: *ch = 0x300E; break;
1785 case 0x3010: *ch = 0x3011; break;
1786 case 0x3011: *ch = 0x3010; break;
1787 case 0x3014: *ch = 0x3015; break;
1788 case 0x3015: *ch = 0x3014; break;
1789 case 0x3016: *ch = 0x3017; break;
1790 case 0x3017: *ch = 0x3016; break;
1791 case 0x3018: *ch = 0x3019; break;
1792 case 0x3019: *ch = 0x3018; break;
1793 case 0x301A: *ch = 0x301B; break;
1794 case 0x301B: *ch = 0x301A; break;
1796 } else if ((*ch & 0xFF00) == 0xFF00) {
1798 case 0xFF08: *ch = 0xFF09; break;
1799 case 0xFF09: *ch = 0xFF08; break;
1800 case 0xFF1C: *ch = 0xFF1E; break;
1801 case 0xFF1E: *ch = 0xFF1C; break;
1802 case 0xFF3B: *ch = 0xFF3D; break;
1803 case 0xFF3D: *ch = 0xFF3B; break;
1804 case 0xFF5B: *ch = 0xFF5D; break;
1805 case 0xFF5D: *ch = 0xFF5B; break;
1806 case 0xFF5F: *ch = 0xFF60; break;
1807 case 0xFF60: *ch = 0xFF5F; break;
1808 case 0xFF62: *ch = 0xFF63; break;
1809 case 0xFF63: *ch = 0xFF62; break;