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 "minibidi.h"
  33
  34 #define lenof(x) ( sizeof((x)) / sizeof(*(x)) )
  35
  36 /*
  37  * Flips the text buffer, according to max level, and
  38  * all higher levels
  39  *
  40  * Input:
  41  * from: text buffer, on which to apply flipping
  42  * level: resolved levels buffer
  43  * max: the maximum level found in this line (should be unsigned char)
  44  * count: line size in bidi_char
  45  */
  46 void flipThisRun(bidi_char *from, unsigned char *level, int max, int count)
  47 {
  48     int i, j, rcount, tlevel;
  49     bidi_char temp;
  50
  51     j = i = 0;
  52     while (i<count && j<count) {
  53
  54         /* find the start of the run of level=max */
  55         tlevel = max;
  56         i = j = findIndexOfRun(level, i, count, max);
  57         /* find the end of the run */
  58         while (i<count && tlevel <= level[i]) {
  59             i++;
  60         }
  61         rcount = i-j;
  62         for (; rcount>((i-j)/2); rcount--) {
  63             temp = from[j+rcount-1];
  64             from[j+rcount-1] = from[i-rcount];
  65             from[i-rcount] = temp;
  66         }
  67     }
  68 }
  69
  70 /*
  71  * Finds the index of a run with level equals tlevel
  72  */
  73 int findIndexOfRun(unsigned char* level , int start, int count, int tlevel)
  74 {
  75     int i;
  76     for (i=start; i<count; i++) {
  77         if (tlevel == level[i]) {
  78             return i;
  79         }
  80     }
  81     return count;
  82 }
  83
  84 /*
  85  * Returns character type of ch, by calling RLE table lookup
  86  * function
  87  */
  88 unsigned char getType(wchar_t ch)
  89 {
  90     return getRLE(ch);
  91 }
  92
  93 /*
  94  * The most significant 2 bits of each level are used to store
  95  * Override status of each character
  96  * This function sets the override bits of level according
  97  * to the value in override, and reurns the new byte.
  98  */
  99 unsigned char setOverrideBits(unsigned char level, unsigned char override)
 100 {
 101     if (override == ON)
 102         return level;
 103     else if (override == R)
 104         return level | OISR;
 105     else if (override == L)
 106         return level | OISL;
 107     return level;
 108 }
 109
 110 /*
 111  * Find the most recent run of the same value in `level', and
 112  * return the value _before_ it. Used to process U+202C POP
 113  * DIRECTIONAL FORMATTING.
 114  */
 115 int getPreviousLevel(unsigned char* level, int from)
 116 {
 117     if (from > 0) {
 118         unsigned char current = level[--from];
 119
 120         while (from >= 0 && level[from] == current)
 121             from--;
 122
 123         if (from >= 0)
 124             return level[from];
 125
 126         return -1;
 127     } else
 128         return -1;
 129 }
 130
 131 /*
 132  * Returns the first odd value greater than x
 133  */
 134 unsigned char leastGreaterOdd(unsigned char x)
 135 {
 136     if ((x % 2) == 0)
 137         return x+1;
 138     else
 139         return x+2;
 140 }
 141
 142 /*
 143  * Returns the first even value greater than x
 144  */
 145 unsigned char leastGreaterEven(unsigned char x)
 146 {
 147     if ((x % 2) == 0)
 148         return x+2;
 149     else
 150         return x+1;
 151 }
 152
 153 /*
 154  * Loops over the RLE_table array looking for the
 155  * type of ch
 156  */
 157 unsigned char getRLE(wchar_t ch)
 158 {
 159     int offset, i;
 160
 161     offset = 0;
 162     for (i=0; i<lenof(RLE_table); i++) {
 163         offset += RLE_table[i].f;
 164         if (ch < offset)
 165             return RLE_table[i].d;
 166     }
 167     /* anything beyond the end of the table is unknown */
 168     return ON;
 169 }
 170
 171 /* The Main shaping function, and the only one to be used
 172  * by the outside world.
 173  *
 174  * line: buffer to apply shaping to. this must be passed by doBidi() first
 175  * to: output buffer for the shaped data
 176  * count: number of characters in line
 177  */
 178 int do_shape(bidi_char *line, bidi_char *to, int count)
 179 {
 180     int i, tempShape, ligFlag;
 181
 182     for (ligFlag=i=0; i<count; i++) {
 183         to[i] = line[i];
 184         tempShape = STYPE(line[i].wc);
 185         switch (tempShape) {
 186           case SC:
 187             break;
 188
 189           case SU:
 190             break;
 191
 192           case SR:
 193             tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
 194             if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 195                 to[i].wc = SFINAL((SISOLATED(line[i].wc)));
 196             else
 197                 to[i].wc = SISOLATED(line[i].wc);
 198             break;
 199
 200
 201           case SD:
 202             /* Make Ligatures */
 203             tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
 204             if (line[i].wc == 0x644) {
 205                 if (i > 0) switch (line[i-1].wc) {
 206                   case 0x622:
 207                     ligFlag = 1;
 208                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 209                         to[i].wc = 0xFEF6;
 210                     else
 211                         to[i].wc = 0xFEF5;
 212                     break;
 213                   case 0x623:
 214                     ligFlag = 1;
 215                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 216                         to[i].wc = 0xFEF8;
 217                     else
 218                         to[i].wc = 0xFEF7;
 219                     break;
 220                   case 0x625:
 221                     ligFlag = 1;
 222                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 223                         to[i].wc = 0xFEFA;
 224                     else
 225                         to[i].wc = 0xFEF9;
 226                     break;
 227                   case 0x627:
 228                     ligFlag = 1;
 229                     if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
 230                         to[i].wc = 0xFEFC;
 231                     else
 232                         to[i].wc = 0xFEFB;
 233                     break;
 234                 }
 235                 if (ligFlag) {
 236                     to[i-1].wc = 0x20;
 237                     ligFlag = 0;
 238                     break;
 239                 }
 240             }
 241
 242             if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC)) {
 243                 tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
 244                 if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
 245                     to[i].wc = SMEDIAL((SISOLATED(line[i].wc)));
 246                 else
 247                     to[i].wc = SFINAL((SISOLATED(line[i].wc)));
 248                 break;
 249             }
 250
 251             tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
 252             if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
 253                 to[i].wc = SINITIAL((SISOLATED(line[i].wc)));
 254             else
 255                 to[i].wc = SISOLATED(line[i].wc);
 256             break;
 257
 258
 259         }
 260     }
 261     return 1;
 262 }
 263
 264 /*
 265  * The Main Bidi Function, and the only function that should
 266  * be used by the outside world.
 267  *
 268  * line: a buffer of size count containing text to apply
 269  * the Bidirectional algorithm to.
 270  */
 271
 272 int do_bidi(bidi_char *line, int count)
 273 {
 274     unsigned char* types;
 275     unsigned char* levels;
 276     unsigned char paragraphLevel;
 277     unsigned char currentEmbedding;
 278     unsigned char currentOverride;
 279     unsigned char tempType;
 280     int i, j, imax, yes, bover;
 281
 282     /* Check the presence of R or AL types as optimization */
 283     yes = 0;
 284     for (i=0; i<count; i++) {
 285         if (getType(line[i].wc) == R || getType(line[i].wc) == AL) {
 286             yes = 1;
 287             break;
 288         }
 289     }
 290     if (yes == 0)
 291         return L;
 292
 293     /* Initialize types, levels */
 294     types = malloc(sizeof(unsigned char) * count);
 295     levels = malloc(sizeof(unsigned char) * count);
 296
 297     /* Rule (P1)  NOT IMPLEMENTED
 298      * P1. Split the text into separate paragraphs. A paragraph separator is
 299      * kept with the previous paragraph. Within each paragraph, apply all the
 300      * other rules of this algorithm.
 301      */
 302
 303     /* Rule (P2), (P3)
 304      * P2. In each paragraph, find the first character of type L, AL, or R.
 305      * P3. If a character is found in P2 and it is of type AL or R, then set
 306      * the paragraph embedding level to one; otherwise, set it to zero.
 307      */
 308     paragraphLevel = 0;
 309     for (i=0; i<count ; i++) {
 310         if (getType(line[i].wc) == R || getType(line[i].wc) == AL) {
 311             paragraphLevel = 1;
 312             break;
 313         } else if (getType(line[i].wc) == L)
 314             break;
 315     }
 316
 317     /* Rule (X1)
 318      * X1. Begin by setting the current embedding level to the paragraph
 319      * embedding level. Set the directional override status to neutral.
 320      */
 321     currentEmbedding = paragraphLevel;
 322     currentOverride = ON;
 323
 324     /* Rule (X2), (X3), (X4), (X5), (X6), (X7), (X8)
 325      * X2. With each RLE, compute the least greater odd embedding level.
 326      * X3. With each LRE, compute the least greater even embedding level.
 327      * X4. With each RLO, compute the least greater odd embedding level.
 328      * X5. With each LRO, compute the least greater even embedding level.
 329      * X6. For all types besides RLE, LRE, RLO, LRO, and PDF:
 330      *          a. Set the level of the current character to the current
 331      *              embedding level.
 332      *          b.  Whenever the directional override status is not neutral,
 333      *               reset the current character type to the directional
 334      *               override status.
 335      * X7. With each PDF, determine the matching embedding or override code.
 336      * If there was a valid matching code, restore (pop) the last
 337      * remembered (pushed) embedding level and directional override.
 338      * X8. All explicit directional embeddings and overrides are completely
 339      * terminated at the end of each paragraph. Paragraph separators are not
 340      * included in the embedding. (Useless here) NOT IMPLEMENTED
 341      */
 342     bover = 0;
 343     for (i=0; i<count; i++) {
 344         tempType = getType(line[i].wc);
 345         switch (tempType) {
 346           case RLE:
 347             currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
 348             levels[i] = setOverrideBits(levels[i], currentOverride);
 349             currentOverride = ON;
 350             break;
 351
 352           case LRE:
 353             currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
 354             levels[i] = setOverrideBits(levels[i], currentOverride);
 355             currentOverride = ON;
 356             break;
 357
 358           case RLO:
 359             currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
 360             tempType = currentOverride = R;
 361             bover = 1;
 362             break;
 363
 364           case LRO:
 365             currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
 366             tempType = currentOverride = L;
 367             bover = 1;
 368             break;
 369
 370           case PDF:
 371             {
 372                 int prevlevel = getPreviousLevel(levels, i);
 373
 374                 if (prevlevel == -1) {
 375                     currentEmbedding = paragraphLevel;
 376                     currentOverride = ON;
 377                 } else {
 378                     currentOverride = currentEmbedding & OMASK;
 379                     currentEmbedding = currentEmbedding & ~OMASK;
 380                 }
 381             }
 382             levels[i] = currentEmbedding;
 383             break;
 384
 385             /* Whitespace is treated as neutral for now */
 386           case WS:
 387           case S:
 388             levels[i] = currentEmbedding;
 389             tempType = ON;
 390             if (currentOverride != ON)
 391                 tempType = currentOverride;
 392             break;
 393
 394           default:
 395             levels[i] = currentEmbedding;
 396             if (currentOverride != ON)
 397                 tempType = currentOverride;
 398             break;
 399
 400         }
 401         types[i] = tempType;
 402     }
 403     /* this clears out all overrides, so we can use levels safely... */
 404     /* checks bover first */
 405     if (bover)
 406         for (i=0; i<count; i++)
 407             levels[i] = levels[i] & LMASK;
 408
 409     /* Rule (X9)
 410      * X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
 411      * Here, they're converted to BN.
 412      */
 413     for (i=0; i<count; i++) {
 414         switch (types[i]) {
 415           case RLE:
 416           case LRE:
 417           case RLO:
 418           case LRO:
 419           case PDF:
 420             types[i] = BN;
 421             break;
 422         }
 423     }
 424
 425     /* Rule (W1)
 426      * W1. Examine each non-spacing mark (NSM) in the level run, and change
 427      * the type of the NSM to the type of the previous character. If the NSM
 428      * is at the start of the level run, it will get the type of sor.
 429      */
 430     if (types[0] == NSM)
 431         types[0] = paragraphLevel;
 432
 433     for (i=1; i<count; i++) {
 434         if (types[i] == NSM)
 435             types[i] = types[i-1];
 436         /* Is this a safe assumption?
 437          * I assumed the previous, IS a character.
 438          */
 439     }
 440
 441     /* Rule (W2)
 442      * W2. Search backwards from each instance of a European number until the
 443      * first strong type (R, L, AL, or sor) is found.  If an AL is found,
 444      * change the type of the European number to Arabic number.
 445      */
 446     for (i=0; i<count; i++) {
 447         if (types[i] == EN) {
 448             j=i;
 449             while (j >= 0) {
 450                 if (types[j] == AL) {
 451                     types[i] = AN;
 452                     break;
 453                 } else if (types[j] == R || types[j] == L) {
 454                     break;
 455                 }
 456                 j--;
 457             }
 458         }
 459     }
 460
 461     /* Rule (W3)
 462      * W3. Change all ALs to R.
 463      *
 464      * Optimization: on Rule Xn, we might set a flag on AL type
 465      * to prevent this loop in L R lines only...
 466      */
 467     for (i=0; i<count; i++) {
 468         if (types[i] == AL)
 469             types[i] = R;
 470     }
 471
 472     /* Rule (W4)
 473      * W4. A single European separator between two European numbers changes
 474      * to a European number. A single common separator between two numbers
 475      * of the same type changes to that type.
 476      */
 477     for (i=1; i<(count-1); i++) {
 478         if (types[i] == ES) {
 479             if (types[i-1] == EN && types[i+1] == EN)
 480                 types[i] = EN;
 481         } else if (types[i] == CS) {
 482             if (types[i-1] == EN && types[i+1] == EN)
 483                 types[i] = EN;
 484             else if (types[i-1] == AN && types[i+1] == AN)
 485                 types[i] = AN;
 486         }
 487     }
 488
 489     /* Rule (W5)
 490      * W5. A sequence of European terminators adjacent to European numbers
 491      * changes to all European numbers.
 492      *
 493      * Optimization: lots here... else ifs need rearrangement
 494      */
 495     for (i=0; i<count; i++) {
 496         if (types[i] == ET) {
 497             if (i > 0 && types[i-1] == EN) {
 498                 types[i] = EN;
 499                 continue;
 500             } else if (i < count-1 && types[i+1] == EN) {
 501                 types[i] = EN;
 502                 continue;
 503             } else if (i < count-1 && types[i+1] == ET) {
 504                 j=i;
 505                 while (j <count && types[j] == ET) {
 506                     j++;
 507                 }
 508                 if (types[j] == EN)
 509                     types[i] = EN;
 510             }
 511         }
 512     }
 513
 514     /* Rule (W6)
 515      * W6. Otherwise, separators and terminators change to Other Neutral:
 516      */
 517     for (i=0; i<count; i++) {
 518         switch (types[i]) {
 519           case ES:
 520           case ET:
 521           case CS:
 522             types[i] = ON;
 523             break;
 524         }
 525     }
 526
 527     /* Rule (W7)
 528      * W7. Search backwards from each instance of a European number until
 529      * the first strong type (R, L, or sor) is found. If an L is found,
 530      * then change the type of the European number to L.
 531      */
 532     for (i=0; i<count; i++) {
 533         if (types[i] == EN) {
 534             j=i;
 535             while (j >= 0) {
 536                 if (types[j] == L) {
 537                     types[i] = L;
 538                     break;
 539                 } else if (types[j] == R || types[j] == AL) {
 540                     break;
 541                 }
 542                 j--;
 543             }
 544         }
 545     }
 546
 547     /* Rule (N1)
 548      * N1. A sequence of neutrals takes the direction of the surrounding
 549      * strong text if the text on both sides has the same direction. European
 550      * and Arabic numbers are treated as though they were R.
 551      */
 552     if (count >= 2 && types[0] == ON) {
 553         if ((types[1] == R) || (types[1] == EN) || (types[1] == AN))
 554             types[0] = R;
 555         else if (types[1] == L)
 556             types[0] = L;
 557     }
 558     for (i=1; i<(count-1); i++) {
 559         if (types[i] == ON) {
 560             if (types[i-1] == L) {
 561                 j=i;
 562                 while (j<(count-1) && types[j] == ON) {
 563                     j++;
 564                 }
 565                 if (types[j] == L) {
 566                     while (i<j) {
 567                         types[i] = L;
 568                         i++;
 569                     }
 570                 }
 571
 572             } else if ((types[i-1] == R)  ||
 573                        (types[i-1] == EN) ||
 574                        (types[i-1] == AN)) {
 575                 j=i;
 576                 while (j<(count-1) && types[j] == ON) {
 577                     j++;
 578                 }
 579                 if ((types[j] == R)  ||
 580                     (types[j] == EN) ||
 581                     (types[j] == AN)) {
 582                     while (i<j) {
 583                         types[i] = R;
 584                         i++;
 585                     }
 586                 }
 587             }
 588         }
 589     }
 590     if (count >= 2 && types[count-1] == ON) {
 591         if (types[count-2] == R || types[count-2] == EN || types[count-2] == AN)
 592             types[count-1] = R;
 593         else if (types[count-2] == L)
 594             types[count-1] = L;
 595     }
 596
 597     /* Rule (N2)
 598      * N2. Any remaining neutrals take the embedding direction.
 599      */
 600     for (i=0; i<count; i++) {
 601         if (types[i] == ON) {
 602             if ((levels[i] % 2) == 0)
 603                 types[i] = L;
 604             else
 605                 types[i] = R;
 606         }
 607     }
 608
 609     /* Rule (I1)
 610      * I1. For all characters with an even (left-to-right) embedding
 611      * direction, those of type R go up one level and those of type AN or
 612      * EN go up two levels.
 613      */
 614     for (i=0; i<count; i++) {
 615         if ((levels[i] % 2) == 0) {
 616             if (types[i] == R)
 617                 levels[i] += 1;
 618             else if (types[i] == AN || types[i] == EN)
 619                 levels[i] += 2;
 620         }
 621     }
 622
 623     /* Rule (I2)
 624      * I2. For all characters with an odd (right-to-left) embedding direction,
 625      * those of type L, EN or AN go up one level.
 626      */
 627     for (i=0; i<count; i++) {
 628         if ((levels[i] % 2) == 1) {
 629             if (types[i] == L || types[i] == EN || types[i] == AN)
 630                 levels[i] += 1;
 631         }
 632     }
 633
 634     /* Rule (L1)
 635      * L1. On each line, reset the embedding level of the following characters
 636      * to the paragraph embedding level:
 637      *          (1)segment separators, (2)paragraph separators,
 638      *           (3)any sequence of whitespace characters preceding
 639      *           a segment separator or paragraph separator,
 640      *           (4)and any sequence of white space characters
 641      *           at the end of the line.
 642      * The types of characters used here are the original types, not those
 643      * modified by the previous phase.
 644      */
 645     j=count-1;
 646     while (j>0 && (getType(line[j].wc) == WS)) {
 647         j--;
 648     }
 649     if (j < (count-1)) {
 650         for (j++; j<count; j++)
 651             levels[j] = paragraphLevel;
 652     }
 653     for (i=0; i<count; i++) {
 654         tempType = getType(line[i].wc);
 655         if (tempType == WS) {
 656             j=i;
 657             while (j<count && (getType(line[j].wc) == WS)) {
 658                 j++;
 659             }
 660             if (j==count || getType(line[j].wc) == B ||
 661                 getType(line[j].wc) == S) {
 662                 for (j--; j>=i ; j--) {
 663                     levels[j] = paragraphLevel;
 664                 }
 665             }
 666         } else if (tempType == B || tempType == S) {
 667             levels[i] = paragraphLevel;
 668         }
 669     }
 670
 671     /* Rule (L4) NOT IMPLEMENTED
 672      * L4. A character that possesses the mirrored property as specified by
 673      * Section 4.7, Mirrored, must be depicted by a mirrored glyph if the
 674      * resolved directionality of that character is R.
 675      */
 676     /* Note: this is implemented before L2 for efficiency */
 677     for (i=0; i<count; i++)
 678         if ((levels[i] % 2) == 1)
 679             doMirror(&line[i].wc);
 680
 681     /* Rule (L2)
 682      * L2. From the highest level found in the text to the lowest odd level on
 683      * each line, including intermediate levels not actually present in the
 684      * text, reverse any contiguous sequence of characters that are at that
 685      * level or higher
 686      */
 687     /* we flip the character string and leave the level array */
 688     imax = 0;
 689     i=0;
 690     tempType = levels[0];
 691     while (i < count) {
 692         if (levels[i] > tempType) {
 693             tempType = levels[i];
 694             imax=i;
 695         }
 696         i++;
 697     }
 698     /* maximum level in tempType, its index in imax. */
 699     while (tempType > 0) {     /* loop from highest level to the least odd, */
 700         /* which i assume is 1 */
 701         flipThisRun(line, levels, tempType, count);
 702         tempType--;
 703     }
 704
 705     /* Rule (L3) NOT IMPLEMENTED
 706      * L3. Combining marks applied to a right-to-left base character will at
 707      * this point precede their base character. If the rendering engine
 708      * expects them to follow the base characters in the final display
 709      * process, then the ordering of the marks and the base character must
 710      * be reversed.
 711      */
 712     free(types);
 713     free(levels);
 714     return R;
 715 }
 716
 717
 718 /*
 719  * Bad, Horrible function
 720  * takes a pointer to a character that is checked for
 721  * having a mirror glyph.
 722  */
 723 void doMirror(wchar_t* ch)
 724 {
 725     if ((*ch & 0xFF00) == 0) {
 726         switch (*ch) {
 727           case 0x0028: *ch = 0x0029; break;
 728           case 0x0029: *ch = 0x0028; break;
 729           case 0x003C: *ch = 0x003E; break;
 730           case 0x003E: *ch = 0x003C; break;
 731           case 0x005B: *ch = 0x005D; break;
 732           case 0x005D: *ch = 0x005B; break;
 733           case 0x007B: *ch = 0x007D; break;
 734           case 0x007D: *ch = 0x007B; break;
 735           case 0x00AB: *ch = 0x00BB; break;
 736           case 0x00BB: *ch = 0x00AB; break;
 737         }
 738     } else if ((*ch & 0xFF00) == 0x2000) {
 739         switch (*ch) {
 740           case 0x2039: *ch = 0x203A; break;
 741           case 0x203A: *ch = 0x2039; break;
 742           case 0x2045: *ch = 0x2046; break;
 743           case 0x2046: *ch = 0x2045; break;
 744           case 0x207D: *ch = 0x207E; break;
 745           case 0x207E: *ch = 0x207D; break;
 746           case 0x208D: *ch = 0x208E; break;
 747           case 0x208E: *ch = 0x208D; break;
 748         }
 749     } else if ((*ch & 0xFF00) == 0x2200) {
 750         switch (*ch) {
 751           case 0x2208: *ch = 0x220B; break;
 752           case 0x2209: *ch = 0x220C; break;
 753           case 0x220A: *ch = 0x220D; break;
 754           case 0x220B: *ch = 0x2208; break;
 755           case 0x220C: *ch = 0x2209; break;
 756           case 0x220D: *ch = 0x220A; break;
 757           case 0x2215: *ch = 0x29F5; break;
 758           case 0x223C: *ch = 0x223D; break;
 759           case 0x223D: *ch = 0x223C; break;
 760           case 0x2243: *ch = 0x22CD; break;
 761           case 0x2252: *ch = 0x2253; break;
 762           case 0x2253: *ch = 0x2252; break;
 763           case 0x2254: *ch = 0x2255; break;
 764           case 0x2255: *ch = 0x2254; break;
 765           case 0x2264: *ch = 0x2265; break;
 766           case 0x2265: *ch = 0x2264; break;
 767           case 0x2266: *ch = 0x2267; break;
 768           case 0x2267: *ch = 0x2266; break;
 769           case 0x2268: *ch = 0x2269; break;
 770           case 0x2269: *ch = 0x2268; break;
 771           case 0x226A: *ch = 0x226B; break;
 772           case 0x226B: *ch = 0x226A; break;
 773           case 0x226E: *ch = 0x226F; break;
 774           case 0x226F: *ch = 0x226E; break;
 775           case 0x2270: *ch = 0x2271; break;
 776           case 0x2271: *ch = 0x2270; break;
 777           case 0x2272: *ch = 0x2273; break;
 778           case 0x2273: *ch = 0x2272; break;
 779           case 0x2274: *ch = 0x2275; break;
 780           case 0x2275: *ch = 0x2274; break;
 781           case 0x2276: *ch = 0x2277; break;
 782           case 0x2277: *ch = 0x2276; break;
 783           case 0x2278: *ch = 0x2279; break;
 784           case 0x2279: *ch = 0x2278; break;
 785           case 0x227A: *ch = 0x227B; break;
 786           case 0x227B: *ch = 0x227A; break;
 787           case 0x227C: *ch = 0x227D; break;
 788           case 0x227D: *ch = 0x227C; break;
 789           case 0x227E: *ch = 0x227F; break;
 790           case 0x227F: *ch = 0x227E; break;
 791           case 0x2280: *ch = 0x2281; break;
 792           case 0x2281: *ch = 0x2280; break;
 793           case 0x2282: *ch = 0x2283; break;
 794           case 0x2283: *ch = 0x2282; break;
 795           case 0x2284: *ch = 0x2285; break;
 796           case 0x2285: *ch = 0x2284; break;
 797           case 0x2286: *ch = 0x2287; break;
 798           case 0x2287: *ch = 0x2286; break;
 799           case 0x2288: *ch = 0x2289; break;
 800           case 0x2289: *ch = 0x2288; break;
 801           case 0x228A: *ch = 0x228B; break;
 802           case 0x228B: *ch = 0x228A; break;
 803           case 0x228F: *ch = 0x2290; break;
 804           case 0x2290: *ch = 0x228F; break;
 805           case 0x2291: *ch = 0x2292; break;
 806           case 0x2292: *ch = 0x2291; break;
 807           case 0x2298: *ch = 0x29B8; break;
 808           case 0x22A2: *ch = 0x22A3; break;
 809           case 0x22A3: *ch = 0x22A2; break;
 810           case 0x22A6: *ch = 0x2ADE; break;
 811           case 0x22A8: *ch = 0x2AE4; break;
 812           case 0x22A9: *ch = 0x2AE3; break;
 813           case 0x22AB: *ch = 0x2AE5; break;
 814           case 0x22B0: *ch = 0x22B1; break;
 815           case 0x22B1: *ch = 0x22B0; break;
 816           case 0x22B2: *ch = 0x22B3; break;
 817           case 0x22B3: *ch = 0x22B2; break;
 818           case 0x22B4: *ch = 0x22B5; break;
 819           case 0x22B5: *ch = 0x22B4; break;
 820           case 0x22B6: *ch = 0x22B7; break;
 821           case 0x22B7: *ch = 0x22B6; break;
 822           case 0x22C9: *ch = 0x22CA; break;
 823           case 0x22CA: *ch = 0x22C9; break;
 824           case 0x22CB: *ch = 0x22CC; break;
 825           case 0x22CC: *ch = 0x22CB; break;
 826           case 0x22CD: *ch = 0x2243; break;
 827           case 0x22D0: *ch = 0x22D1; break;
 828           case 0x22D1: *ch = 0x22D0; break;
 829           case 0x22D6: *ch = 0x22D7; break;
 830           case 0x22D7: *ch = 0x22D6; break;
 831           case 0x22D8: *ch = 0x22D9; break;
 832           case 0x22D9: *ch = 0x22D8; break;
 833           case 0x22DA: *ch = 0x22DB; break;
 834           case 0x22DB: *ch = 0x22DA; break;
 835           case 0x22DC: *ch = 0x22DD; break;
 836           case 0x22DD: *ch = 0x22DC; break;
 837           case 0x22DE: *ch = 0x22DF; break;
 838           case 0x22DF: *ch = 0x22DE; break;
 839           case 0x22E0: *ch = 0x22E1; break;
 840           case 0x22E1: *ch = 0x22E0; break;
 841           case 0x22E2: *ch = 0x22E3; break;
 842           case 0x22E3: *ch = 0x22E2; break;
 843           case 0x22E4: *ch = 0x22E5; break;
 844           case 0x22E5: *ch = 0x22E4; break;
 845           case 0x22E6: *ch = 0x22E7; break;
 846           case 0x22E7: *ch = 0x22E6; break;
 847           case 0x22E8: *ch = 0x22E9; break;
 848           case 0x22E9: *ch = 0x22E8; break;
 849           case 0x22EA: *ch = 0x22EB; break;
 850           case 0x22EB: *ch = 0x22EA; break;
 851           case 0x22EC: *ch = 0x22ED; break;
 852           case 0x22ED: *ch = 0x22EC; break;
 853           case 0x22F0: *ch = 0x22F1; break;
 854           case 0x22F1: *ch = 0x22F0; break;
 855           case 0x22F2: *ch = 0x22FA; break;
 856           case 0x22F3: *ch = 0x22FB; break;
 857           case 0x22F4: *ch = 0x22FC; break;
 858           case 0x22F6: *ch = 0x22FD; break;
 859           case 0x22F7: *ch = 0x22FE; break;
 860           case 0x22FA: *ch = 0x22F2; break;
 861           case 0x22FB: *ch = 0x22F3; break;
 862           case 0x22FC: *ch = 0x22F4; break;
 863           case 0x22FD: *ch = 0x22F6; break;
 864           case 0x22FE: *ch = 0x22F7; break;
 865         }
 866     } else if ((*ch & 0xFF00) == 0x2300) {
 867         switch (*ch) {
 868           case 0x2308: *ch = 0x2309; break;
 869           case 0x2309: *ch = 0x2308; break;
 870           case 0x230A: *ch = 0x230B; break;
 871           case 0x230B: *ch = 0x230A; break;
 872           case 0x2329: *ch = 0x232A; break;
 873           case 0x232A: *ch = 0x2329; break;
 874         }
 875     } else if ((*ch & 0xFF00) == 0x2700) {
 876         switch (*ch) {
 877           case 0x2768: *ch = 0x2769; break;
 878           case 0x2769: *ch = 0x2768; break;
 879           case 0x276A: *ch = 0x276B; break;
 880           case 0x276B: *ch = 0x276A; break;
 881           case 0x276C: *ch = 0x276D; break;
 882           case 0x276D: *ch = 0x276C; break;
 883           case 0x276E: *ch = 0x276F; break;
 884           case 0x276F: *ch = 0x276E; break;
 885           case 0x2770: *ch = 0x2771; break;
 886           case 0x2771: *ch = 0x2770; break;
 887           case 0x2772: *ch = 0x2773; break;
 888           case 0x2773: *ch = 0x2772; break;
 889           case 0x2774: *ch = 0x2775; break;
 890           case 0x2775: *ch = 0x2774; break;
 891           case 0x27D5: *ch = 0x27D6; break;
 892           case 0x27D6: *ch = 0x27D5; break;
 893           case 0x27DD: *ch = 0x27DE; break;
 894           case 0x27DE: *ch = 0x27DD; break;
 895           case 0x27E2: *ch = 0x27E3; break;
 896           case 0x27E3: *ch = 0x27E2; break;
 897           case 0x27E4: *ch = 0x27E5; break;
 898           case 0x27E5: *ch = 0x27E4; break;
 899           case 0x27E6: *ch = 0x27E7; break;
 900           case 0x27E7: *ch = 0x27E6; break;
 901           case 0x27E8: *ch = 0x27E9; break;
 902           case 0x27E9: *ch = 0x27E8; break;
 903           case 0x27EA: *ch = 0x27EB; break;
 904           case 0x27EB: *ch = 0x27EA; break;
 905         }
 906     } else if ((*ch & 0xFF00) == 0x2900) {
 907         switch (*ch) {
 908           case 0x2983: *ch = 0x2984; break;
 909           case 0x2984: *ch = 0x2983; break;
 910           case 0x2985: *ch = 0x2986; break;
 911           case 0x2986: *ch = 0x2985; break;
 912           case 0x2987: *ch = 0x2988; break;
 913           case 0x2988: *ch = 0x2987; break;
 914           case 0x2989: *ch = 0x298A; break;
 915           case 0x298A: *ch = 0x2989; break;
 916           case 0x298B: *ch = 0x298C; break;
 917           case 0x298C: *ch = 0x298B; break;
 918           case 0x298D: *ch = 0x2990; break;
 919           case 0x298E: *ch = 0x298F; break;
 920           case 0x298F: *ch = 0x298E; break;
 921           case 0x2990: *ch = 0x298D; break;
 922           case 0x2991: *ch = 0x2992; break;
 923           case 0x2992: *ch = 0x2991; break;
 924           case 0x2993: *ch = 0x2994; break;
 925           case 0x2994: *ch = 0x2993; break;
 926           case 0x2995: *ch = 0x2996; break;
 927           case 0x2996: *ch = 0x2995; break;
 928           case 0x2997: *ch = 0x2998; break;
 929           case 0x2998: *ch = 0x2997; break;
 930           case 0x29B8: *ch = 0x2298; break;
 931           case 0x29C0: *ch = 0x29C1; break;
 932           case 0x29C1: *ch = 0x29C0; break;
 933           case 0x29C4: *ch = 0x29C5; break;
 934           case 0x29C5: *ch = 0x29C4; break;
 935           case 0x29CF: *ch = 0x29D0; break;
 936           case 0x29D0: *ch = 0x29CF; break;
 937           case 0x29D1: *ch = 0x29D2; break;
 938           case 0x29D2: *ch = 0x29D1; break;
 939           case 0x29D4: *ch = 0x29D5; break;
 940           case 0x29D5: *ch = 0x29D4; break;
 941           case 0x29D8: *ch = 0x29D9; break;
 942           case 0x29D9: *ch = 0x29D8; break;
 943           case 0x29DA: *ch = 0x29DB; break;
 944           case 0x29DB: *ch = 0x29DA; break;
 945           case 0x29F5: *ch = 0x2215; break;
 946           case 0x29F8: *ch = 0x29F9; break;
 947           case 0x29F9: *ch = 0x29F8; break;
 948           case 0x29FC: *ch = 0x29FD; break;
 949           case 0x29FD: *ch = 0x29FC; break;
 950         }
 951     } else if ((*ch & 0xFF00) == 0x2A00) {
 952         switch (*ch) {
 953           case 0x2A2B: *ch = 0x2A2C; break;
 954           case 0x2A2C: *ch = 0x2A2B; break;
 955           case 0x2A2D: *ch = 0x2A2C; break;
 956           case 0x2A2E: *ch = 0x2A2D; break;
 957           case 0x2A34: *ch = 0x2A35; break;
 958           case 0x2A35: *ch = 0x2A34; break;
 959           case 0x2A3C: *ch = 0x2A3D; break;
 960           case 0x2A3D: *ch = 0x2A3C; break;
 961           case 0x2A64: *ch = 0x2A65; break;
 962           case 0x2A65: *ch = 0x2A64; break;
 963           case 0x2A79: *ch = 0x2A7A; break;
 964           case 0x2A7A: *ch = 0x2A79; break;
 965           case 0x2A7D: *ch = 0x2A7E; break;
 966           case 0x2A7E: *ch = 0x2A7D; break;
 967           case 0x2A7F: *ch = 0x2A80; break;
 968           case 0x2A80: *ch = 0x2A7F; break;
 969           case 0x2A81: *ch = 0x2A82; break;
 970           case 0x2A82: *ch = 0x2A81; break;
 971           case 0x2A83: *ch = 0x2A84; break;
 972           case 0x2A84: *ch = 0x2A83; break;
 973           case 0x2A8B: *ch = 0x2A8C; break;
 974           case 0x2A8C: *ch = 0x2A8B; break;
 975           case 0x2A91: *ch = 0x2A92; break;
 976           case 0x2A92: *ch = 0x2A91; break;
 977           case 0x2A93: *ch = 0x2A94; break;
 978           case 0x2A94: *ch = 0x2A93; break;
 979           case 0x2A95: *ch = 0x2A96; break;
 980           case 0x2A96: *ch = 0x2A95; break;
 981           case 0x2A97: *ch = 0x2A98; break;
 982           case 0x2A98: *ch = 0x2A97; break;
 983           case 0x2A99: *ch = 0x2A9A; break;
 984           case 0x2A9A: *ch = 0x2A99; break;
 985           case 0x2A9B: *ch = 0x2A9C; break;
 986           case 0x2A9C: *ch = 0x2A9B; break;
 987           case 0x2AA1: *ch = 0x2AA2; break;
 988           case 0x2AA2: *ch = 0x2AA1; break;
 989           case 0x2AA6: *ch = 0x2AA7; break;
 990           case 0x2AA7: *ch = 0x2AA6; break;
 991           case 0x2AA8: *ch = 0x2AA9; break;
 992           case 0x2AA9: *ch = 0x2AA8; break;
 993           case 0x2AAA: *ch = 0x2AAB; break;
 994           case 0x2AAB: *ch = 0x2AAA; break;
 995           case 0x2AAC: *ch = 0x2AAD; break;
 996           case 0x2AAD: *ch = 0x2AAC; break;
 997           case 0x2AAF: *ch = 0x2AB0; break;
 998           case 0x2AB0: *ch = 0x2AAF; break;
 999           case 0x2AB3: *ch = 0x2AB4; break;
1000           case 0x2AB4: *ch = 0x2AB3; break;
1001           case 0x2ABB: *ch = 0x2ABC; break;
1002           case 0x2ABC: *ch = 0x2ABB; break;
1003           case 0x2ABD: *ch = 0x2ABE; break;
1004           case 0x2ABE: *ch = 0x2ABD; break;
1005           case 0x2ABF: *ch = 0x2AC0; break;
1006           case 0x2AC0: *ch = 0x2ABF; break;
1007           case 0x2AC1: *ch = 0x2AC2; break;
1008           case 0x2AC2: *ch = 0x2AC1; break;
1009           case 0x2AC3: *ch = 0x2AC4; break;
1010           case 0x2AC4: *ch = 0x2AC3; break;
1011           case 0x2AC5: *ch = 0x2AC6; break;
1012           case 0x2AC6: *ch = 0x2AC5; break;
1013           case 0x2ACD: *ch = 0x2ACE; break;
1014           case 0x2ACE: *ch = 0x2ACD; break;
1015           case 0x2ACF: *ch = 0x2AD0; break;
1016           case 0x2AD0: *ch = 0x2ACF; break;
1017           case 0x2AD1: *ch = 0x2AD2; break;
1018           case 0x2AD2: *ch = 0x2AD1; break;
1019           case 0x2AD3: *ch = 0x2AD4; break;
1020           case 0x2AD4: *ch = 0x2AD3; break;
1021           case 0x2AD5: *ch = 0x2AD6; break;
1022           case 0x2AD6: *ch = 0x2AD5; break;
1023           case 0x2ADE: *ch = 0x22A6; break;
1024           case 0x2AE3: *ch = 0x22A9; break;
1025           case 0x2AE4: *ch = 0x22A8; break;
1026           case 0x2AE5: *ch = 0x22AB; break;
1027           case 0x2AEC: *ch = 0x2AED; break;
1028           case 0x2AED: *ch = 0x2AEC; break;
1029           case 0x2AF7: *ch = 0x2AF8; break;
1030           case 0x2AF8: *ch = 0x2AF7; break;
1031           case 0x2AF9: *ch = 0x2AFA; break;
1032           case 0x2AFA: *ch = 0x2AF9; break;
1033         }
1034     } else if ((*ch & 0xFF00) == 0x3000) {
1035         switch (*ch) {
1036           case 0x3008: *ch = 0x3009; break;
1037           case 0x3009: *ch = 0x3008; break;
1038           case 0x300A: *ch = 0x300B; break;
1039           case 0x300B: *ch = 0x300A; break;
1040           case 0x300C: *ch = 0x300D; break;
1041           case 0x300D: *ch = 0x300C; break;
1042           case 0x300E: *ch = 0x300F; break;
1043           case 0x300F: *ch = 0x300E; break;
1044           case 0x3010: *ch = 0x3011; break;
1045           case 0x3011: *ch = 0x3010; break;
1046           case 0x3014: *ch = 0x3015; break;
1047           case 0x3015: *ch = 0x3014; break;
1048           case 0x3016: *ch = 0x3017; break;
1049           case 0x3017: *ch = 0x3016; break;
1050           case 0x3018: *ch = 0x3019; break;
1051           case 0x3019: *ch = 0x3018; break;
1052           case 0x301A: *ch = 0x301B; break;
1053           case 0x301B: *ch = 0x301A; break;
1054         }
1055     } else if ((*ch & 0xFF00) == 0xFF00) {
1056         switch (*ch) {
1057           case 0xFF08: *ch = 0xFF09; break;
1058           case 0xFF09: *ch = 0xFF08; break;
1059           case 0xFF1C: *ch = 0xFF1E; break;
1060           case 0xFF1E: *ch = 0xFF1C; break;
1061           case 0xFF3B: *ch = 0xFF3D; break;
1062           case 0xFF3D: *ch = 0xFF3B; break;
1063           case 0xFF5B: *ch = 0xFF5D; break;
1064           case 0xFF5D: *ch = 0xFF5B; break;
1065           case 0xFF5F: *ch = 0xFF60; break;
1066           case 0xFF60: *ch = 0xFF5F; break;
1067           case 0xFF62: *ch = 0xFF63; break;
1068           case 0xFF63: *ch = 0xFF62; break;
1069         }
1070     }
1071 }