minibidi.c

   1 /************************************************************************
   2  * $Id$
   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$
  18  *  $Author$
  19  *  $Revision$
  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 /* Shaping Helpers */
  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)
  48
  49 #define leastGreaterOdd(x) ( ((x)+1) | 1 )
  50 #define leastGreaterEven(x) ( ((x)+2) &~ 1 )
  51
  52 typedef struct bidi_char {
  53     wchar_t origwc, wc;
  54     unsigned short index;
  55 } bidi_char;
  56
  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);
  66
  67 /* character types */
  68 enum {
  69     L,
  70     LRE,
  71     LRO,
  72     R,
  73     AL,
  74     RLE,
  75     RLO,
  76     PDF,
  77     EN,
  78     ES,
  79     ET,
  80     AN,
  81     CS,
  82     NSM,
  83     BN,
  84     B,
  85     S,
  86     WS,
  87     ON,
  88 };
  89
  90 /* Shaping Types */
  91 enum {
  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 */
  95     SU, /* Non-Joining */
  96     SC  /* Join-Causing, like U+0640 (TATWEEL) */
  97 };
  98
  99 typedef struct {
 100     char type;
 101     wchar_t form_b;
 102 } shape_node;
 103
 104 /* Kept near the actual table, for verification. */
 105 #define SHAPE_FIRST 0x621
 106 #define SHAPE_LAST 0x64A
 107
 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},
 136     /* 63B */ {SU, 0x0},
 137     /* 63C */ {SU, 0x0},
 138     /* 63D */ {SU, 0x0},
 139     /* 63E */ {SU, 0x0},
 140     /* 63F */ {SU, 0x0},
 141     /* 640 */ {SC, 0x0},
 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},
 152 };
 153
 154 /*
 155  * Flips the text buffer, according to max level, and
 156  * all higher levels
 157  *
 158  * Input:
 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
 163  */
 164 void flipThisRun(bidi_char *from, unsigned char *level, int max, int count)
 165 {
 166     int i, j, k, tlevel;
 167     bidi_char temp;
 168
 169     j = i = 0;
 170     while (i<count && j<count) {
 171
 172         /* find the start of the run of level=max */
 173         tlevel = max;
 174         i = j = findIndexOfRun(level, i, count, max);
 175         /* find the end of the run */
 176         while (i<count && tlevel <= level[i]) {
 177             i++;
 178         }
 179         for (k = i - 1; k > j; k--, j++) {
 180             temp = from[k];
 181             from[k] = from[j];
 182             from[j] = temp;
 183         }
 184     }
 185 }
 186
 187 /*
 188  * Finds the index of a run with level equals tlevel
 189  */
 190 int findIndexOfRun(unsigned char* level , int start, int count, int tlevel)
 191 {
 192     int i;
 193     for (i=start; i<count; i++) {
 194         if (tlevel == level[i]) {
 195             return i;
 196         }
 197     }
 198     return count;
 199 }
 200
 201 /*
 202  * Returns the bidi character type of ch.
 203  *
 204  * The data table in this function is constructed from the Unicode
 205  * Character Database, downloadable from unicode.org at the URL
 206  *
 207  *     http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
 208  *
 209  * by the following fragment of Perl:
 210
 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;}' \
 219     UnicodeData.txt
 220
 221  */
 222 unsigned char getType(int ch)
 223 {
 224     static const struct {
 225         int first, last, type;
 226     } lookup[] = {
 227         {0x0000, 0x0008, BN},
 228         {0x0009, 0x0009, S},
 229         {0x000a, 0x000a, B},
 230         {0x000b, 0x000b, S},
 231         {0x000c, 0x000c, WS},
 232         {0x000d, 0x000d, B},
 233         {0x000e, 0x001b, BN},
 234         {0x001c, 0x001e, B},
 235         {0x001f, 0x001f, S},
 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},
 244         {0x0041, 0x005a, L},
 245         {0x0061, 0x007a, L},
 246         {0x007f, 0x0084, BN},
 247         {0x0085, 0x0085, B},
 248         {0x0086, 0x009f, BN},
 249         {0x00a0, 0x00a0, CS},
 250         {0x00a2, 0x00a5, ET},
 251         {0x00aa, 0x00aa, L},
 252         {0x00ad, 0x00ad, BN},
 253         {0x00b0, 0x00b1, ET},
 254         {0x00b2, 0x00b3, EN},
 255         {0x00b5, 0x00b5, L},
 256         {0x00b9, 0x00b9, EN},
 257         {0x00ba, 0x00ba, L},
 258         {0x00c0, 0x00d6, L},
 259         {0x00d8, 0x00f6, L},
 260         {0x00f8, 0x0236, L},
 261         {0x0250, 0x02b8, L},
 262         {0x02bb, 0x02c1, L},
 263         {0x02d0, 0x02d1, L},
 264         {0x02e0, 0x02e4, L},
 265         {0x02ee, 0x02ee, L},
 266         {0x0300, 0x0357, NSM},
 267         {0x035d, 0x036f, NSM},
 268         {0x037a, 0x037a, L},
 269         {0x0386, 0x0386, L},
 270         {0x0388, 0x038a, L},
 271         {0x038c, 0x038c, L},
 272         {0x038e, 0x03a1, L},
 273         {0x03a3, 0x03ce, L},
 274         {0x03d0, 0x03f5, L},
 275         {0x03f7, 0x03fb, L},
 276         {0x0400, 0x0482, L},
 277         {0x0483, 0x0486, NSM},
 278         {0x0488, 0x0489, NSM},
 279         {0x048a, 0x04ce, L},
 280         {0x04d0, 0x04f5, L},
 281         {0x04f8, 0x04f9, L},
 282         {0x0500, 0x050f, L},
 283         {0x0531, 0x0556, L},
 284         {0x0559, 0x055f, L},
 285         {0x0561, 0x0587, L},
 286         {0x0589, 0x0589, L},
 287         {0x0591, 0x05a1, NSM},
 288         {0x05a3, 0x05b9, NSM},
 289         {0x05bb, 0x05bd, NSM},
 290         {0x05be, 0x05be, R},
 291         {0x05bf, 0x05bf, NSM},
 292         {0x05c0, 0x05c0, R},
 293         {0x05c1, 0x05c2, NSM},
 294         {0x05c3, 0x05c3, R},
 295         {0x05c4, 0x05c4, NSM},
 296         {0x05d0, 0x05ea, R},
 297         {0x05f0, 0x05f4, R},
 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},
 332         {0x0903, 0x0939, L},
 333         {0x093c, 0x093c, NSM},
 334         {0x093d, 0x0940, L},
 335         {0x0941, 0x0948, NSM},
 336         {0x0949, 0x094c, L},
 337         {0x094d, 0x094d, NSM},
 338         {0x0950, 0x0950, L},
 339         {0x0951, 0x0954, NSM},
 340         {0x0958, 0x0961, L},
 341         {0x0962, 0x0963, NSM},
 342         {0x0964, 0x0970, L},
 343         {0x0981, 0x0981, NSM},
 344         {0x0982, 0x0983, L},
 345         {0x0985, 0x098c, L},
 346         {0x098f, 0x0990, L},
 347         {0x0993, 0x09a8, L},
 348         {0x09aa, 0x09b0, L},
 349         {0x09b2, 0x09b2, L},
 350         {0x09b6, 0x09b9, L},
 351         {0x09bc, 0x09bc, NSM},
 352         {0x09bd, 0x09c0, L},
 353         {0x09c1, 0x09c4, NSM},
 354         {0x09c7, 0x09c8, L},
 355         {0x09cb, 0x09cc, L},
 356         {0x09cd, 0x09cd, NSM},
 357         {0x09d7, 0x09d7, L},
 358         {0x09dc, 0x09dd, L},
 359         {0x09df, 0x09e1, L},
 360         {0x09e2, 0x09e3, NSM},
 361         {0x09e6, 0x09f1, L},
 362         {0x09f2, 0x09f3, ET},
 363         {0x09f4, 0x09fa, L},
 364         {0x0a01, 0x0a02, NSM},
 365         {0x0a03, 0x0a03, L},
 366         {0x0a05, 0x0a0a, L},
 367         {0x0a0f, 0x0a10, L},
 368         {0x0a13, 0x0a28, L},
 369         {0x0a2a, 0x0a30, L},
 370         {0x0a32, 0x0a33, L},
 371         {0x0a35, 0x0a36, L},
 372         {0x0a38, 0x0a39, L},
 373         {0x0a3c, 0x0a3c, NSM},
 374         {0x0a3e, 0x0a40, L},
 375         {0x0a41, 0x0a42, NSM},
 376         {0x0a47, 0x0a48, NSM},
 377         {0x0a4b, 0x0a4d, NSM},
 378         {0x0a59, 0x0a5c, L},
 379         {0x0a5e, 0x0a5e, L},
 380         {0x0a66, 0x0a6f, L},
 381         {0x0a70, 0x0a71, NSM},
 382         {0x0a72, 0x0a74, L},
 383         {0x0a81, 0x0a82, NSM},
 384         {0x0a83, 0x0a83, L},
 385         {0x0a85, 0x0a8d, L},
 386         {0x0a8f, 0x0a91, L},
 387         {0x0a93, 0x0aa8, L},
 388         {0x0aaa, 0x0ab0, L},
 389         {0x0ab2, 0x0ab3, L},
 390         {0x0ab5, 0x0ab9, L},
 391         {0x0abc, 0x0abc, NSM},
 392         {0x0abd, 0x0ac0, L},
 393         {0x0ac1, 0x0ac5, NSM},
 394         {0x0ac7, 0x0ac8, NSM},
 395         {0x0ac9, 0x0ac9, L},
 396         {0x0acb, 0x0acc, L},
 397         {0x0acd, 0x0acd, NSM},
 398         {0x0ad0, 0x0ad0, L},
 399         {0x0ae0, 0x0ae1, L},
 400         {0x0ae2, 0x0ae3, NSM},
 401         {0x0ae6, 0x0aef, L},
 402         {0x0af1, 0x0af1, ET},
 403         {0x0b01, 0x0b01, NSM},
 404         {0x0b02, 0x0b03, L},
 405         {0x0b05, 0x0b0c, L},
 406         {0x0b0f, 0x0b10, L},
 407         {0x0b13, 0x0b28, L},
 408         {0x0b2a, 0x0b30, L},
 409         {0x0b32, 0x0b33, L},
 410         {0x0b35, 0x0b39, L},
 411         {0x0b3c, 0x0b3c, NSM},
 412         {0x0b3d, 0x0b3e, L},
 413         {0x0b3f, 0x0b3f, NSM},
 414         {0x0b40, 0x0b40, L},
 415         {0x0b41, 0x0b43, NSM},
 416         {0x0b47, 0x0b48, L},
 417         {0x0b4b, 0x0b4c, L},
 418         {0x0b4d, 0x0b4d, NSM},
 419         {0x0b56, 0x0b56, NSM},
 420         {0x0b57, 0x0b57, L},
 421         {0x0b5c, 0x0b5d, L},
 422         {0x0b5f, 0x0b61, L},
 423         {0x0b66, 0x0b71, L},
 424         {0x0b82, 0x0b82, NSM},
 425         {0x0b83, 0x0b83, L},
 426         {0x0b85, 0x0b8a, L},
 427         {0x0b8e, 0x0b90, L},
 428         {0x0b92, 0x0b95, L},
 429         {0x0b99, 0x0b9a, L},
 430         {0x0b9c, 0x0b9c, L},
 431         {0x0b9e, 0x0b9f, L},
 432         {0x0ba3, 0x0ba4, L},
 433         {0x0ba8, 0x0baa, L},
 434         {0x0bae, 0x0bb5, L},
 435         {0x0bb7, 0x0bb9, L},
 436         {0x0bbe, 0x0bbf, L},
 437         {0x0bc0, 0x0bc0, NSM},
 438         {0x0bc1, 0x0bc2, L},
 439         {0x0bc6, 0x0bc8, L},
 440         {0x0bca, 0x0bcc, L},
 441         {0x0bcd, 0x0bcd, NSM},
 442         {0x0bd7, 0x0bd7, L},
 443         {0x0be7, 0x0bf2, L},
 444         {0x0bf9, 0x0bf9, ET},
 445         {0x0c01, 0x0c03, L},
 446         {0x0c05, 0x0c0c, L},
 447         {0x0c0e, 0x0c10, L},
 448         {0x0c12, 0x0c28, L},
 449         {0x0c2a, 0x0c33, L},
 450         {0x0c35, 0x0c39, L},
 451         {0x0c3e, 0x0c40, NSM},
 452         {0x0c41, 0x0c44, L},
 453         {0x0c46, 0x0c48, NSM},
 454         {0x0c4a, 0x0c4d, NSM},
 455         {0x0c55, 0x0c56, NSM},
 456         {0x0c60, 0x0c61, L},
 457         {0x0c66, 0x0c6f, L},
 458         {0x0c82, 0x0c83, L},
 459         {0x0c85, 0x0c8c, L},
 460         {0x0c8e, 0x0c90, L},
 461         {0x0c92, 0x0ca8, L},
 462         {0x0caa, 0x0cb3, L},
 463         {0x0cb5, 0x0cb9, L},
 464         {0x0cbc, 0x0cbc, NSM},
 465         {0x0cbd, 0x0cc4, L},
 466         {0x0cc6, 0x0cc8, L},
 467         {0x0cca, 0x0ccb, L},
 468         {0x0ccc, 0x0ccd, NSM},
 469         {0x0cd5, 0x0cd6, L},
 470         {0x0cde, 0x0cde, L},
 471         {0x0ce0, 0x0ce1, L},
 472         {0x0ce6, 0x0cef, L},
 473         {0x0d02, 0x0d03, L},
 474         {0x0d05, 0x0d0c, L},
 475         {0x0d0e, 0x0d10, L},
 476         {0x0d12, 0x0d28, L},
 477         {0x0d2a, 0x0d39, L},
 478         {0x0d3e, 0x0d40, L},
 479         {0x0d41, 0x0d43, NSM},
 480         {0x0d46, 0x0d48, L},
 481         {0x0d4a, 0x0d4c, L},
 482         {0x0d4d, 0x0d4d, NSM},
 483         {0x0d57, 0x0d57, L},
 484         {0x0d60, 0x0d61, L},
 485         {0x0d66, 0x0d6f, L},
 486         {0x0d82, 0x0d83, L},
 487         {0x0d85, 0x0d96, L},
 488         {0x0d9a, 0x0db1, L},
 489         {0x0db3, 0x0dbb, L},
 490         {0x0dbd, 0x0dbd, L},
 491         {0x0dc0, 0x0dc6, L},
 492         {0x0dca, 0x0dca, NSM},
 493         {0x0dcf, 0x0dd1, L},
 494         {0x0dd2, 0x0dd4, NSM},
 495         {0x0dd6, 0x0dd6, NSM},
 496         {0x0dd8, 0x0ddf, L},
 497         {0x0df2, 0x0df4, L},
 498         {0x0e01, 0x0e30, L},
 499         {0x0e31, 0x0e31, NSM},
 500         {0x0e32, 0x0e33, L},
 501         {0x0e34, 0x0e3a, NSM},
 502         {0x0e3f, 0x0e3f, ET},
 503         {0x0e40, 0x0e46, L},
 504         {0x0e47, 0x0e4e, NSM},
 505         {0x0e4f, 0x0e5b, L},
 506         {0x0e81, 0x0e82, L},
 507         {0x0e84, 0x0e84, L},
 508         {0x0e87, 0x0e88, L},
 509         {0x0e8a, 0x0e8a, L},
 510         {0x0e8d, 0x0e8d, L},
 511         {0x0e94, 0x0e97, L},
 512         {0x0e99, 0x0e9f, L},
 513         {0x0ea1, 0x0ea3, L},
 514         {0x0ea5, 0x0ea5, L},
 515         {0x0ea7, 0x0ea7, L},
 516         {0x0eaa, 0x0eab, L},
 517         {0x0ead, 0x0eb0, L},
 518         {0x0eb1, 0x0eb1, NSM},
 519         {0x0eb2, 0x0eb3, L},
 520         {0x0eb4, 0x0eb9, NSM},
 521         {0x0ebb, 0x0ebc, NSM},
 522         {0x0ebd, 0x0ebd, L},
 523         {0x0ec0, 0x0ec4, L},
 524         {0x0ec6, 0x0ec6, L},
 525         {0x0ec8, 0x0ecd, NSM},
 526         {0x0ed0, 0x0ed9, L},
 527         {0x0edc, 0x0edd, L},
 528         {0x0f00, 0x0f17, L},
 529         {0x0f18, 0x0f19, NSM},
 530         {0x0f1a, 0x0f34, L},
 531         {0x0f35, 0x0f35, NSM},
 532         {0x0f36, 0x0f36, L},
 533         {0x0f37, 0x0f37, NSM},
 534         {0x0f38, 0x0f38, L},
 535         {0x0f39, 0x0f39, NSM},
 536         {0x0f3e, 0x0f47, L},
 537         {0x0f49, 0x0f6a, L},
 538         {0x0f71, 0x0f7e, NSM},
 539         {0x0f7f, 0x0f7f, L},
 540         {0x0f80, 0x0f84, NSM},
 541         {0x0f85, 0x0f85, L},
 542         {0x0f86, 0x0f87, NSM},
 543         {0x0f88, 0x0f8b, L},
 544         {0x0f90, 0x0f97, NSM},
 545         {0x0f99, 0x0fbc, NSM},
 546         {0x0fbe, 0x0fc5, L},
 547         {0x0fc6, 0x0fc6, NSM},
 548         {0x0fc7, 0x0fcc, L},
 549         {0x0fcf, 0x0fcf, L},
 550         {0x1000, 0x1021, L},
 551         {0x1023, 0x1027, L},
 552         {0x1029, 0x102a, L},
 553         {0x102c, 0x102c, L},
 554         {0x102d, 0x1030, NSM},
 555         {0x1031, 0x1031, L},
 556         {0x1032, 0x1032, NSM},
 557         {0x1036, 0x1037, NSM},
 558         {0x1038, 0x1038, L},
 559         {0x1039, 0x1039, NSM},
 560         {0x1040, 0x1057, L},
 561         {0x1058, 0x1059, NSM},
 562         {0x10a0, 0x10c5, L},
 563         {0x10d0, 0x10f8, L},
 564         {0x10fb, 0x10fb, L},
 565         {0x1100, 0x1159, L},
 566         {0x115f, 0x11a2, L},
 567         {0x11a8, 0x11f9, L},
 568         {0x1200, 0x1206, L},
 569         {0x1208, 0x1246, L},
 570         {0x1248, 0x1248, L},
 571         {0x124a, 0x124d, L},
 572         {0x1250, 0x1256, L},
 573         {0x1258, 0x1258, L},
 574         {0x125a, 0x125d, L},
 575         {0x1260, 0x1286, L},
 576         {0x1288, 0x1288, L},
 577         {0x128a, 0x128d, L},
 578         {0x1290, 0x12ae, L},
 579         {0x12b0, 0x12b0, L},
 580         {0x12b2, 0x12b5, L},
 581         {0x12b8, 0x12be, L},
 582         {0x12c0, 0x12c0, L},
 583         {0x12c2, 0x12c5, L},
 584         {0x12c8, 0x12ce, L},
 585         {0x12d0, 0x12d6, L},
 586         {0x12d8, 0x12ee, L},
 587         {0x12f0, 0x130e, L},
 588         {0x1310, 0x1310, L},
 589         {0x1312, 0x1315, L},
 590         {0x1318, 0x131e, L},
 591         {0x1320, 0x1346, L},
 592         {0x1348, 0x135a, L},
 593         {0x1361, 0x137c, L},
 594         {0x13a0, 0x13f4, L},
 595         {0x1401, 0x1676, L},
 596         {0x1680, 0x1680, WS},
 597         {0x1681, 0x169a, L},
 598         {0x16a0, 0x16f0, L},
 599         {0x1700, 0x170c, L},
 600         {0x170e, 0x1711, L},
 601         {0x1712, 0x1714, NSM},
 602         {0x1720, 0x1731, L},
 603         {0x1732, 0x1734, NSM},
 604         {0x1735, 0x1736, L},
 605         {0x1740, 0x1751, L},
 606         {0x1752, 0x1753, NSM},
 607         {0x1760, 0x176c, L},
 608         {0x176e, 0x1770, L},
 609         {0x1772, 0x1773, NSM},
 610         {0x1780, 0x17b6, L},
 611         {0x17b7, 0x17bd, NSM},
 612         {0x17be, 0x17c5, L},
 613         {0x17c6, 0x17c6, NSM},
 614         {0x17c7, 0x17c8, L},
 615         {0x17c9, 0x17d3, NSM},
 616         {0x17d4, 0x17da, L},
 617         {0x17db, 0x17db, ET},
 618         {0x17dc, 0x17dc, L},
 619         {0x17dd, 0x17dd, NSM},
 620         {0x17e0, 0x17e9, L},
 621         {0x180b, 0x180d, NSM},
 622         {0x180e, 0x180e, WS},
 623         {0x1810, 0x1819, L},
 624         {0x1820, 0x1877, L},
 625         {0x1880, 0x18a8, L},
 626         {0x18a9, 0x18a9, NSM},
 627         {0x1900, 0x191c, L},
 628         {0x1920, 0x1922, NSM},
 629         {0x1923, 0x1926, L},
 630         {0x1927, 0x192b, NSM},
 631         {0x1930, 0x1931, L},
 632         {0x1932, 0x1932, NSM},
 633         {0x1933, 0x1938, L},
 634         {0x1939, 0x193b, NSM},
 635         {0x1946, 0x196d, L},
 636         {0x1970, 0x1974, L},
 637         {0x1d00, 0x1d6b, L},
 638         {0x1e00, 0x1e9b, L},
 639         {0x1ea0, 0x1ef9, L},
 640         {0x1f00, 0x1f15, L},
 641         {0x1f18, 0x1f1d, L},
 642         {0x1f20, 0x1f45, L},
 643         {0x1f48, 0x1f4d, L},
 644         {0x1f50, 0x1f57, L},
 645         {0x1f59, 0x1f59, L},
 646         {0x1f5b, 0x1f5b, L},
 647         {0x1f5d, 0x1f5d, L},
 648         {0x1f5f, 0x1f7d, L},
 649         {0x1f80, 0x1fb4, L},
 650         {0x1fb6, 0x1fbc, L},
 651         {0x1fbe, 0x1fbe, L},
 652         {0x1fc2, 0x1fc4, L},
 653         {0x1fc6, 0x1fcc, L},
 654         {0x1fd0, 0x1fd3, L},
 655         {0x1fd6, 0x1fdb, L},
 656         {0x1fe0, 0x1fec, L},
 657         {0x1ff2, 0x1ff4, L},
 658         {0x1ff6, 0x1ffc, L},
 659         {0x2000, 0x200a, WS},
 660         {0x200b, 0x200d, BN},
 661         {0x200e, 0x200e, L},
 662         {0x200f, 0x200f, R},
 663         {0x2028, 0x2028, WS},
 664         {0x2029, 0x2029, B},
 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},
 677         {0x2071, 0x2071, L},
 678         {0x2074, 0x2079, EN},
 679         {0x207a, 0x207b, ET},
 680         {0x207f, 0x207f, L},
 681         {0x2080, 0x2089, EN},
 682         {0x208a, 0x208b, ET},
 683         {0x20a0, 0x20b1, ET},
 684         {0x20d0, 0x20ea, NSM},
 685         {0x2102, 0x2102, L},
 686         {0x2107, 0x2107, L},
 687         {0x210a, 0x2113, L},
 688         {0x2115, 0x2115, L},
 689         {0x2119, 0x211d, L},
 690         {0x2124, 0x2124, L},
 691         {0x2126, 0x2126, L},
 692         {0x2128, 0x2128, L},
 693         {0x212a, 0x212d, L},
 694         {0x212e, 0x212e, ET},
 695         {0x212f, 0x2131, L},
 696         {0x2133, 0x2139, L},
 697         {0x213d, 0x213f, L},
 698         {0x2145, 0x2149, L},
 699         {0x2160, 0x2183, L},
 700         {0x2212, 0x2213, ET},
 701         {0x2336, 0x237a, L},
 702         {0x2395, 0x2395, L},
 703         {0x2488, 0x249b, EN},
 704         {0x249c, 0x24e9, L},
 705         {0x2800, 0x28ff, L},
 706         {0x3000, 0x3000, WS},
 707         {0x3005, 0x3007, L},
 708         {0x3021, 0x3029, L},
 709         {0x302a, 0x302f, NSM},
 710         {0x3031, 0x3035, L},
 711         {0x3038, 0x303c, L},
 712         {0x3041, 0x3096, L},
 713         {0x3099, 0x309a, NSM},
 714         {0x309d, 0x309f, L},
 715         {0x30a1, 0x30fa, L},
 716         {0x30fc, 0x30ff, L},
 717         {0x3105, 0x312c, L},
 718         {0x3131, 0x318e, L},
 719         {0x3190, 0x31b7, L},
 720         {0x31f0, 0x321c, L},
 721         {0x3220, 0x3243, L},
 722         {0x3260, 0x327b, L},
 723         {0x327f, 0x32b0, L},
 724         {0x32c0, 0x32cb, L},
 725         {0x32d0, 0x32fe, L},
 726         {0x3300, 0x3376, L},
 727         {0x337b, 0x33dd, L},
 728         {0x33e0, 0x33fe, L},
 729         {0x3400, 0x4db5, L},
 730         {0x4e00, 0x9fa5, L},
 731         {0xa000, 0xa48c, L},
 732         {0xac00, 0xd7a3, L},
 733         {0xd800, 0xfa2d, L},
 734         {0xfa30, 0xfa6a, L},
 735         {0xfb00, 0xfb06, L},
 736         {0xfb13, 0xfb17, L},
 737         {0xfb1d, 0xfb1d, R},
 738         {0xfb1e, 0xfb1e, NSM},
 739         {0xfb1f, 0xfb28, R},
 740         {0xfb29, 0xfb29, ET},
 741         {0xfb2a, 0xfb36, R},
 742         {0xfb38, 0xfb3c, R},
 743         {0xfb3e, 0xfb3e, R},
 744         {0xfb40, 0xfb41, R},
 745         {0xfb43, 0xfb44, R},
 746         {0xfb46, 0xfb4f, R},
 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},
 771         {0xff21, 0xff3a, L},
 772         {0xff41, 0xff5a, L},
 773         {0xff66, 0xffbe, L},
 774         {0xffc2, 0xffc7, L},
 775         {0xffca, 0xffcf, L},
 776         {0xffd2, 0xffd7, L},
 777         {0xffda, 0xffdc, L},
 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},
 844     };
 845
 846     int i, j, k;
 847
 848     i = -1;
 849     j = lenof(lookup);
 850
 851     while (j - i > 2) {
 852         k = (i + j) / 2;
 853         if (ch < lookup[k].first)
 854             j = k;
 855         else if (ch > lookup[k].last)
 856             i = k;
 857         else
 858             return lookup[k].type;
 859     }
 860
 861     /*
 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!).
 868      */
 869     return ON;
 870 }
 871
 872 /*
 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.
 877  */
 878 unsigned char setOverrideBits(unsigned char level, unsigned char override)
 879 {
 880     if (override == ON)
 881         return level;
 882     else if (override == R)
 883         return level | OISR;
 884     else if (override == L)
 885         return level | OISL;
 886     return level;
 887 }
 888
 889 /*
 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.
 893  */
 894 int getPreviousLevel(unsigned char* level, int from)
 895 {
 896     if (from > 0) {
 897         unsigned char current = level[--from];
 898
 899         while (from >= 0 && level[from] == current)
 900             from--;
 901
 902         if (from >= 0)
 903             return level[from];
 904
 905         return -1;
 906     } else
 907         return -1;
 908 }
 909
 910 /* The Main shaping function, and the only one to be used
 911  * by the outside world.
 912  *
 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
 916  */
 917 int do_shape(bidi_char *line, bidi_char *to, int count)
 918 {
 919     int i, tempShape, ligFlag;
 920
 921     for (ligFlag=i=0; i<count; i++) {
 922         to[i] = line[i];
 923         tempShape = STYPE(line[i].wc);
 924         switch (tempShape) {
 925           case SC:
 926             break;
 927
 928           case SU:
 929             break;
 930
 931           case SR:
 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)));
 935             else
 936                 to[i].wc = SISOLATED(line[i].wc);
 937             break;
 938
 939
 940           case SD:
 941             /* Make Ligatures */
 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) {
 945                   case 0x622:
 946                     ligFlag = 1;
 947                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 948                         to[i].wc = 0xFEF6;
 949                     else
 950                         to[i].wc = 0xFEF5;
 951                     break;
 952                   case 0x623:
 953                     ligFlag = 1;
 954                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 955                         to[i].wc = 0xFEF8;
 956                     else
 957                         to[i].wc = 0xFEF7;
 958                     break;
 959                   case 0x625:
 960                     ligFlag = 1;
 961                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 962                         to[i].wc = 0xFEFA;
 963                     else
 964                         to[i].wc = 0xFEF9;
 965                     break;
 966                   case 0x627:
 967                     ligFlag = 1;
 968                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 969                         to[i].wc = 0xFEFC;
 970                     else
 971                         to[i].wc = 0xFEFB;
 972                     break;
 973                 }
 974                 if (ligFlag) {
 975                     to[i-1].wc = 0x20;
 976                     ligFlag = 0;
 977                     break;
 978                 }
 979             }
 980
 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)));
 985                 else
 986                     to[i].wc = SFINAL((SISOLATED(line[i].wc)));
 987                 break;
 988             }
 989
 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)));
 993             else
 994                 to[i].wc = SISOLATED(line[i].wc);
 995             break;
 996
 997
 998         }
 999     }
1000     return 1;
1001 }
1002
1003 /*
1004  * The Main Bidi Function, and the only function that should
1005  * be used by the outside world.
1006  *
1007  * line: a buffer of size count containing text to apply
1008  * the Bidirectional algorithm to.
1009  */
1010
1011 int do_bidi(bidi_char *line, int count)
1012 {
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;
1020
1021     /* Check the presence of R or AL types as optimization */
1022     yes = 0;
1023     for (i=0; i<count; i++) {
1024         int type = getType(line[i].wc);
1025         if (type == R || type == AL) {
1026             yes = 1;
1027             break;
1028         }
1029     }
1030     if (yes == 0)
1031         return L;
1032
1033     /* Initialize types, levels */
1034     types = snewn(count, unsigned char);
1035     levels = snewn(count, unsigned char);
1036
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.
1041      */
1042
1043     /* Rule (P2), (P3)
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.
1047      */
1048     paragraphLevel = 0;
1049     for (i=0; i<count ; i++) {
1050         int type = getType(line[i].wc);
1051         if (type == R || type == AL) {
1052             paragraphLevel = 1;
1053             break;
1054         } else if (type == L)
1055             break;
1056     }
1057
1058     /* Rule (X1)
1059      * X1. Begin by setting the current embedding level to the paragraph
1060      * embedding level. Set the directional override status to neutral.
1061      */
1062     currentEmbedding = paragraphLevel;
1063     currentOverride = ON;
1064
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
1072      *              embedding level.
1073      *          b.  Whenever the directional override status is not neutral,
1074      *               reset the current character type to the directional
1075      *               override status.
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
1082      */
1083     bover = 0;
1084     for (i=0; i<count; i++) {
1085         tempType = getType(line[i].wc);
1086         switch (tempType) {
1087           case RLE:
1088             currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
1089             levels[i] = setOverrideBits(levels[i], currentOverride);
1090             currentOverride = ON;
1091             break;
1092
1093           case LRE:
1094             currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
1095             levels[i] = setOverrideBits(levels[i], currentOverride);
1096             currentOverride = ON;
1097             break;
1098
1099           case RLO:
1100             currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
1101             tempType = currentOverride = R;
1102             bover = 1;
1103             break;
1104
1105           case LRO:
1106             currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
1107             tempType = currentOverride = L;
1108             bover = 1;
1109             break;
1110
1111           case PDF:
1112             {
1113                 int prevlevel = getPreviousLevel(levels, i);
1114
1115                 if (prevlevel == -1) {
1116                     currentEmbedding = paragraphLevel;
1117                     currentOverride = ON;
1118                 } else {
1119                     currentOverride = currentEmbedding & OMASK;
1120                     currentEmbedding = currentEmbedding & ~OMASK;
1121                 }
1122             }
1123             levels[i] = currentEmbedding;
1124             break;
1125
1126             /* Whitespace is treated as neutral for now */
1127           case WS:
1128           case S:
1129             levels[i] = currentEmbedding;
1130             tempType = ON;
1131             if (currentOverride != ON)
1132                 tempType = currentOverride;
1133             break;
1134
1135           default:
1136             levels[i] = currentEmbedding;
1137             if (currentOverride != ON)
1138                 tempType = currentOverride;
1139             break;
1140
1141         }
1142         types[i] = tempType;
1143     }
1144     /* this clears out all overrides, so we can use levels safely... */
1145     /* checks bover first */
1146     if (bover)
1147         for (i=0; i<count; i++)
1148             levels[i] = levels[i] & LMASK;
1149
1150     /* Rule (X9)
1151      * X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
1152      * Here, they're converted to BN.
1153      */
1154     for (i=0; i<count; i++) {
1155         switch (types[i]) {
1156           case RLE:
1157           case LRE:
1158           case RLO:
1159           case LRO:
1160           case PDF:
1161             types[i] = BN;
1162             break;
1163         }
1164     }
1165
1166     /* Rule (W1)
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.
1170      */
1171     if (types[0] == NSM)
1172         types[0] = paragraphLevel;
1173
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.
1179          */
1180     }
1181
1182     /* Rule (W2)
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.
1186      */
1187     for (i=0; i<count; i++) {
1188         if (types[i] == EN) {
1189             j=i;
1190             while (j >= 0) {
1191                 if (types[j] == AL) {
1192                     types[i] = AN;
1193                     break;
1194                 } else if (types[j] == R || types[j] == L) {
1195                     break;
1196                 }
1197                 j--;
1198             }
1199         }
1200     }
1201
1202     /* Rule (W3)
1203      * W3. Change all ALs to R.
1204      *
1205      * Optimization: on Rule Xn, we might set a flag on AL type
1206      * to prevent this loop in L R lines only...
1207      */
1208     for (i=0; i<count; i++) {
1209         if (types[i] == AL)
1210             types[i] = R;
1211     }
1212
1213     /* Rule (W4)
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.
1217      */
1218     for (i=1; i<(count-1); i++) {
1219         if (types[i] == ES) {
1220             if (types[i-1] == EN && types[i+1] == EN)
1221                 types[i] = EN;
1222         } else if (types[i] == CS) {
1223             if (types[i-1] == EN && types[i+1] == EN)
1224                 types[i] = EN;
1225             else if (types[i-1] == AN && types[i+1] == AN)
1226                 types[i] = AN;
1227         }
1228     }
1229
1230     /* Rule (W5)
1231      * W5. A sequence of European terminators adjacent to European numbers
1232      * changes to all European numbers.
1233      *
1234      * Optimization: lots here... else ifs need rearrangement
1235      */
1236     for (i=0; i<count; i++) {
1237         if (types[i] == ET) {
1238             if (i > 0 && types[i-1] == EN) {
1239                 types[i] = EN;
1240                 continue;
1241             } else if (i < count-1 && types[i+1] == EN) {
1242                 types[i] = EN;
1243                 continue;
1244             } else if (i < count-1 && types[i+1] == ET) {
1245                 j=i;
1246                 while (j <count && types[j] == ET) {
1247                     j++;
1248                 }
1249                 if (types[j] == EN)
1250                     types[i] = EN;
1251             }
1252         }
1253     }
1254
1255     /* Rule (W6)
1256      * W6. Otherwise, separators and terminators change to Other Neutral:
1257      */
1258     for (i=0; i<count; i++) {
1259         switch (types[i]) {
1260           case ES:
1261           case ET:
1262           case CS:
1263             types[i] = ON;
1264             break;
1265         }
1266     }
1267
1268     /* Rule (W7)
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.
1272      */
1273     for (i=0; i<count; i++) {
1274         if (types[i] == EN) {
1275             j=i;
1276             while (j >= 0) {
1277                 if (types[j] == L) {
1278                     types[i] = L;
1279                     break;
1280                 } else if (types[j] == R || types[j] == AL) {
1281                     break;
1282                 }
1283                 j--;
1284             }
1285         }
1286     }
1287
1288     /* Rule (N1)
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.
1292      */
1293     if (count >= 2 && types[0] == ON) {
1294         if ((types[1] == R) || (types[1] == EN) || (types[1] == AN))
1295             types[0] = R;
1296         else if (types[1] == L)
1297             types[0] = L;
1298     }
1299     for (i=1; i<(count-1); i++) {
1300         if (types[i] == ON) {
1301             if (types[i-1] == L) {
1302                 j=i;
1303                 while (j<(count-1) && types[j] == ON) {
1304                     j++;
1305                 }
1306                 if (types[j] == L) {
1307                     while (i<j) {
1308                         types[i] = L;
1309                         i++;
1310                     }
1311                 }
1312
1313             } else if ((types[i-1] == R)  ||
1314                        (types[i-1] == EN) ||
1315                        (types[i-1] == AN)) {
1316                 j=i;
1317                 while (j<(count-1) && types[j] == ON) {
1318                     j++;
1319                 }
1320                 if ((types[j] == R)  ||
1321                     (types[j] == EN) ||
1322                     (types[j] == AN)) {
1323                     while (i<j) {
1324                         types[i] = R;
1325                         i++;
1326                     }
1327                 }
1328             }
1329         }
1330     }
1331     if (count >= 2 && types[count-1] == ON) {
1332         if (types[count-2] == R || types[count-2] == EN || types[count-2] == AN)
1333             types[count-1] = R;
1334         else if (types[count-2] == L)
1335             types[count-1] = L;
1336     }
1337
1338     /* Rule (N2)
1339      * N2. Any remaining neutrals take the embedding direction.
1340      */
1341     for (i=0; i<count; i++) {
1342         if (types[i] == ON) {
1343             if ((levels[i] % 2) == 0)
1344                 types[i] = L;
1345             else
1346                 types[i] = R;
1347         }
1348     }
1349
1350     /* Rule (I1)
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.
1354      */
1355     for (i=0; i<count; i++) {
1356         if ((levels[i] % 2) == 0) {
1357             if (types[i] == R)
1358                 levels[i] += 1;
1359             else if (types[i] == AN || types[i] == EN)
1360                 levels[i] += 2;
1361         }
1362     }
1363
1364     /* Rule (I2)
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.
1367      */
1368     for (i=0; i<count; i++) {
1369         if ((levels[i] % 2) == 1) {
1370             if (types[i] == L || types[i] == EN || types[i] == AN)
1371                 levels[i] += 1;
1372         }
1373     }
1374
1375     /* Rule (L1)
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.
1385      */
1386     j=count-1;
1387     while (j>0 && (getType(line[j].wc) == WS)) {
1388         j--;
1389     }
1390     if (j < (count-1)) {
1391         for (j++; j<count; j++)
1392             levels[j] = paragraphLevel;
1393     }
1394     for (i=0; i<count; i++) {
1395         tempType = getType(line[i].wc);
1396         if (tempType == WS) {
1397             j=i;
1398             while (j<count && (getType(line[j].wc) == WS)) {
1399                 j++;
1400             }
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;
1405                 }
1406             }
1407         } else if (tempType == B || tempType == S) {
1408             levels[i] = paragraphLevel;
1409         }
1410     }
1411
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.
1416      */
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);
1421
1422     /* Rule (L2)
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
1426      * level or higher
1427      */
1428     /* we flip the character string and leave the level array */
1429     imax = 0;
1430     i=0;
1431     tempType = levels[0];
1432     while (i < count) {
1433         if (levels[i] > tempType) {
1434             tempType = levels[i];
1435             imax=i;
1436         }
1437         i++;
1438     }
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);
1443         tempType--;
1444     }
1445
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
1451      * be reversed.
1452      */
1453     sfree(types);
1454     sfree(levels);
1455     return R;
1456 }
1457
1458
1459 /*
1460  * Bad, Horrible function
1461  * takes a pointer to a character that is checked for
1462  * having a mirror glyph.
1463  */
1464 void doMirror(wchar_t* ch)
1465 {
1466     if ((*ch & 0xFF00) == 0) {
1467         switch (*ch) {
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;
1478         }
1479     } else if ((*ch & 0xFF00) == 0x2000) {
1480         switch (*ch) {
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;
1489         }
1490     } else if ((*ch & 0xFF00) == 0x2200) {
1491         switch (*ch) {
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;
1606         }
1607     } else if ((*ch & 0xFF00) == 0x2300) {
1608         switch (*ch) {
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;
1615         }
1616     } else if ((*ch & 0xFF00) == 0x2700) {
1617         switch (*ch) {
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;
1646         }
1647     } else if ((*ch & 0xFF00) == 0x2900) {
1648         switch (*ch) {
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;
1691         }
1692     } else if ((*ch & 0xFF00) == 0x2A00) {
1693         switch (*ch) {
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;
1774         }
1775     } else if ((*ch & 0xFF00) == 0x3000) {
1776         switch (*ch) {
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;
1795         }
1796     } else if ((*ch & 0xFF00) == 0xFF00) {
1797         switch (*ch) {
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;
1810         }
1811     }
1812 }