Reformat minibidi.[ch] in line with my coding conventions. It was

[u/mdw/putty] / minibidi.c

/************************************************************************
 * $Id$
 *
 * ------------
 * Description:
 * ------------
 * This is an implemention of Unicode's Bidirectional Algorithm
 * (known as UAX #9).
 *
 *   http://www.unicode.org/reports/tr9/
 *
 * Author: Ahmad Khalifa
 *
 * -----------------
 * Revision Details:    (Updated by Revision Control System)
 * -----------------
 *  $Date$
 *  $Author$
 *  $Revision$
 *
 * (www.arabeyes.org - under MIT license)
 *
 ************************************************************************/

/*
 * TODO:
 * =====
 * - Explicit marks need to be handled (they are not 100% now)
 * - Ligatures
 */

#include "minibidi.h"

#define lenof(x) ( sizeof((x)) / sizeof(*(x)) )

/*
 * Flips the text buffer, according to max level, and
 * all higher levels
 *
 * Input:
 * from: text buffer, on which to apply flipping
 * level: resolved levels buffer
 * max: the maximum level found in this line (should be unsigned char)
 * count: line size in bidi_char
 */
void flipThisRun(bidi_char *from, unsigned char *level, int max, int count)
{
    int i, j, rcount, tlevel;
    bidi_char temp;

    j = i = 0;
    while (i<count && j<count) {

        /* find the start of the run of level=max */
        tlevel = max;
        i = j = findIndexOfRun(level, i, count, max);
        /* find the end of the run */
        while (i<count && tlevel <= level[i]) {
            i++;
        }
        rcount = i-j;
        for (; rcount>((i-j)/2); rcount--) {
            temp = from[j+rcount-1];
            from[j+rcount-1] = from[i-rcount];
            from[i-rcount] = temp;
        }
    }
}

/*
 * Finds the index of a run with level equals tlevel
 */
int findIndexOfRun(unsigned char* level , int start, int count, int tlevel)
{
    int i;
    for (i=start; i<count; i++) {
        if (tlevel == level[i]) {
            return i;
        }
    }
    return count;
}

/*
 * Returns character type of ch, by calling RLE table lookup
 * function
 */
unsigned char getType(wchar_t ch)
{
    return getRLE(ch);
}

/*
 * The most significant 2 bits of each level are used to store
 * Override status of each character
 * This function sets the override bits of level according
 * to the value in override, and reurns the new byte.
 */
unsigned char setOverrideBits(unsigned char level, unsigned char override)
{
    if (override == ON)
        return level;
    else if (override == R)
        return level | OISR;
    else if (override == L)
        return level | OISL;
    return level;
}

/*
 * Find the most recent run of the same value in `level', and
 * return the value _before_ it. Used to process U+202C POP
 * DIRECTIONAL FORMATTING.
 */
int getPreviousLevel(unsigned char* level, int from)
{
    if (from > 0) {
        unsigned char current = level[--from];

        while (from >= 0 && level[from] == current)
            from--;

        if (from >= 0)
            return level[from];

        return -1;
    } else
        return -1;
}

/*
 * Returns the first odd value greater than x
 */
unsigned char leastGreaterOdd(unsigned char x)
{
    if ((x % 2) == 0)
        return x+1;
    else
        return x+2;
}

/*
 * Returns the first even value greater than x
 */
unsigned char leastGreaterEven(unsigned char x)
{
    if ((x % 2) == 0)
        return x+2;
    else
        return x+1;
}

/*
 * Loops over the RLE_table array looking for the
 * type of ch
 */
unsigned char getRLE(wchar_t ch)
{
    int offset, i;

    offset = 0;
    for (i=0; i<lenof(RLE_table); i++) {
        offset += RLE_table[i].f;
        if (ch < offset)
            return RLE_table[i].d;
    }
    /* anything beyond the end of the table is unknown */
    return ON;
}

/* The Main shaping function, and the only one to be used
 * by the outside world.
 *
 * line: buffer to apply shaping to. this must be passed by doBidi() first
 * to: output buffer for the shaped data
 * count: number of characters in line
 */
int do_shape(bidi_char *line, bidi_char *to, int count)
{
    int i, tempShape, ligFlag;

    for (ligFlag=i=0; i<count; i++) {
        to[i] = line[i];
        tempShape = STYPE(line[i].wc);
        switch (tempShape) {
          case SC:
            break;

          case SU:
            break;

          case SR:
            tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
            if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
                to[i].wc = SFINAL((SISOLATED(line[i].wc)));
            else
                to[i].wc = SISOLATED(line[i].wc);
            break;


          case SD:
            /* Make Ligatures */
            tempShape = (i+1 < count ? STYPE(line[i+1].wc) : SU);
            if (line[i].wc == 0x644) {
                if (i > 0) switch (line[i-1].wc) {
                  case 0x622:
                    ligFlag = 1;
                    if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
                        to[i].wc = 0xFEF6;
                    else
                        to[i].wc = 0xFEF5;
                    break;
                  case 0x623:
                    ligFlag = 1;
                    if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
                        to[i].wc = 0xFEF8;
                    else
                        to[i].wc = 0xFEF7;
                    break;
                  case 0x625:
                    ligFlag = 1;
                    if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
                        to[i].wc = 0xFEFA;
                    else
                        to[i].wc = 0xFEF9;
                    break;
                  case 0x627:
                    ligFlag = 1;
                    if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC))
                        to[i].wc = 0xFEFC;
                    else
                        to[i].wc = 0xFEFB;
                    break;
                }
                if (ligFlag) {
                    to[i-1].wc = 0x20;
                    ligFlag = 0;
                    break;
                }
            }

            if ((tempShape == SL) || (tempShape == SD) || (tempShape == SC)) {
                tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
                if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
                    to[i].wc = SMEDIAL((SISOLATED(line[i].wc)));
                else
                    to[i].wc = SFINAL((SISOLATED(line[i].wc)));
                break;
            }

            tempShape = (i > 0 ? STYPE(line[i-1].wc) : SU);
            if ((tempShape == SR) || (tempShape == SD) || (tempShape == SC))
                to[i].wc = SINITIAL((SISOLATED(line[i].wc)));
            else
                to[i].wc = SISOLATED(line[i].wc);
            break;


        }
    }
    return 1;
}

/*
 * The Main Bidi Function, and the only function that should
 * be used by the outside world.
 *
 * line: a buffer of size count containing text to apply
 * the Bidirectional algorithm to.
 */

int do_bidi(bidi_char *line, int count)
{
    unsigned char* types;
    unsigned char* levels;
    unsigned char paragraphLevel;
    unsigned char currentEmbedding;
    unsigned char currentOverride;
    unsigned char tempType;
    int i, j, imax, yes, bover;

    /* Check the presence of R or AL types as optimization */
    yes = 0;
    for (i=0; i<count; i++) {
        if (getType(line[i].wc) == R || getType(line[i].wc) == AL) {
            yes = 1;
            break;
        }
    }
    if (yes == 0)
        return L;

    /* Initialize types, levels */
    types = malloc(sizeof(unsigned char) * count);
    levels = malloc(sizeof(unsigned char) * count);

    /* Rule (P1)  NOT IMPLEMENTED
     * P1. Split the text into separate paragraphs. A paragraph separator is
     * kept with the previous paragraph. Within each paragraph, apply all the
     * other rules of this algorithm.
     */

    /* Rule (P2), (P3)
     * P2. In each paragraph, find the first character of type L, AL, or R.
     * P3. If a character is found in P2 and it is of type AL or R, then set
     * the paragraph embedding level to one; otherwise, set it to zero.
     */
    paragraphLevel = 0;
    for (i=0; i<count ; i++) {
        if (getType(line[i].wc) == R || getType(line[i].wc) == AL) {
            paragraphLevel = 1;
            break;
        } else if (getType(line[i].wc) == L)
            break;
    }

    /* Rule (X1)
     * X1. Begin by setting the current embedding level to the paragraph
     * embedding level. Set the directional override status to neutral.
     */
    currentEmbedding = paragraphLevel;
    currentOverride = ON;

    /* Rule (X2), (X3), (X4), (X5), (X6), (X7), (X8)
     * X2. With each RLE, compute the least greater odd embedding level.
     * X3. With each LRE, compute the least greater even embedding level.
     * X4. With each RLO, compute the least greater odd embedding level.
     * X5. With each LRO, compute the least greater even embedding level.
     * X6. For all types besides RLE, LRE, RLO, LRO, and PDF:
     *          a. Set the level of the current character to the current
     *              embedding level.
     *          b.  Whenever the directional override status is not neutral,
     *               reset the current character type to the directional
     *               override status.
     * X7. With each PDF, determine the matching embedding or override code.
     * If there was a valid matching code, restore (pop) the last
     * remembered (pushed) embedding level and directional override.
     * X8. All explicit directional embeddings and overrides are completely
     * terminated at the end of each paragraph. Paragraph separators are not
     * included in the embedding. (Useless here) NOT IMPLEMENTED
     */
    bover = 0;
    for (i=0; i<count; i++) {
        tempType = getType(line[i].wc);
        switch (tempType) {
          case RLE:
            currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
            levels[i] = setOverrideBits(levels[i], currentOverride);
            currentOverride = ON;
            break;

          case LRE:
            currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
            levels[i] = setOverrideBits(levels[i], currentOverride);
            currentOverride = ON;
            break;

          case RLO:
            currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
            tempType = currentOverride = R;
            bover = 1;
            break;

          case LRO:
            currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
            tempType = currentOverride = L;
            bover = 1;
            break;

          case PDF:
            {
                int prevlevel = getPreviousLevel(levels, i);

                if (prevlevel == -1) {
                    currentEmbedding = paragraphLevel;
                    currentOverride = ON;
                } else {
                    currentOverride = currentEmbedding & OMASK;
                    currentEmbedding = currentEmbedding & ~OMASK;
                }
            }
            levels[i] = currentEmbedding;
            break;

            /* Whitespace is treated as neutral for now */
          case WS:
          case S:
            levels[i] = currentEmbedding;
            tempType = ON;
            if (currentOverride != ON)
                tempType = currentOverride;
            break;

          default:
            levels[i] = currentEmbedding;
            if (currentOverride != ON)
                tempType = currentOverride;
            break;

        }
        types[i] = tempType;
    }
    /* this clears out all overrides, so we can use levels safely... */
    /* checks bover first */
    if (bover)
        for (i=0; i<count; i++)
            levels[i] = levels[i] & LMASK;

    /* Rule (X9)
     * X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
     * Here, they're converted to BN.
     */
    for (i=0; i<count; i++) {
        switch (types[i]) {
          case RLE:
          case LRE:
          case RLO:
          case LRO:
          case PDF:
            types[i] = BN;
            break;
        }
    }

    /* Rule (W1)
     * W1. Examine each non-spacing mark (NSM) in the level run, and change
     * the type of the NSM to the type of the previous character. If the NSM
     * is at the start of the level run, it will get the type of sor.
     */
    if (types[0] == NSM)
        types[0] = paragraphLevel;

    for (i=1; i<count; i++) {
        if (types[i] == NSM)
            types[i] = types[i-1];
        /* Is this a safe assumption?
         * I assumed the previous, IS a character.
         */
    }

    /* Rule (W2)
     * W2. Search backwards from each instance of a European number until the
     * first strong type (R, L, AL, or sor) is found.  If an AL is found,
     * change the type of the European number to Arabic number.
     */
    for (i=0; i<count; i++) {
        if (types[i] == EN) {
            j=i;
            while (j >= 0) {
                if (types[j] == AL) {
                    types[i] = AN;
                    break;
                } else if (types[j] == R || types[j] == L) {
                    break;
                }
                j--;
            }
        }
    }

    /* Rule (W3)
     * W3. Change all ALs to R.
     *
     * Optimization: on Rule Xn, we might set a flag on AL type
     * to prevent this loop in L R lines only...
     */
    for (i=0; i<count; i++) {
        if (types[i] == AL)
            types[i] = R;
    }

    /* Rule (W4)
     * W4. A single European separator between two European numbers changes
     * to a European number. A single common separator between two numbers
     * of the same type changes to that type.
     */
    for (i=1; i<(count-1); i++) {
        if (types[i] == ES) {
            if (types[i-1] == EN && types[i+1] == EN)
                types[i] = EN;
        } else if (types[i] == CS) {
            if (types[i-1] == EN && types[i+1] == EN)
                types[i] = EN;
            else if (types[i-1] == AN && types[i+1] == AN)
                types[i] = AN;
        }
    }

    /* Rule (W5)
     * W5. A sequence of European terminators adjacent to European numbers
     * changes to all European numbers.
     *
     * Optimization: lots here... else ifs need rearrangement
     */
    for (i=0; i<count; i++) {
        if (types[i] == ET) {
            if (i > 0 && types[i-1] == EN) {
                types[i] = EN;
                continue;
            } else if (i < count-1 && types[i+1] == EN) {
                types[i] = EN;
                continue;
            } else if (i < count-1 && types[i+1] == ET) {
                j=i;
                while (j <count && types[j] == ET) {
                    j++;
                }
                if (types[j] == EN)
                    types[i] = EN;
            }
        }
    }

    /* Rule (W6)
     * W6. Otherwise, separators and terminators change to Other Neutral:
     */
    for (i=0; i<count; i++) {
        switch (types[i]) {
          case ES:
          case ET:
          case CS:
            types[i] = ON;
            break;
        }
    }

    /* Rule (W7)
     * W7. Search backwards from each instance of a European number until
     * the first strong type (R, L, or sor) is found. If an L is found,
     * then change the type of the European number to L.
     */
    for (i=0; i<count; i++) {
        if (types[i] == EN) {
            j=i;
            while (j >= 0) {
                if (types[j] == L) {
                    types[i] = L;
                    break;
                } else if (types[j] == R || types[j] == AL) {
                    break;
                }
                j--;
            }
        }
    }

    /* Rule (N1)
     * N1. A sequence of neutrals takes the direction of the surrounding
     * strong text if the text on both sides has the same direction. European
     * and Arabic numbers are treated as though they were R.
     */
    if (count >= 2 && types[0] == ON) {
        if ((types[1] == R) || (types[1] == EN) || (types[1] == AN))
            types[0] = R;
        else if (types[1] == L)
            types[0] = L;
    }
    for (i=1; i<(count-1); i++) {
        if (types[i] == ON) {
            if (types[i-1] == L) {
                j=i;
                while (j<(count-1) && types[j] == ON) {
                    j++;
                }
                if (types[j] == L) {
                    while (i<j) {
                        types[i] = L;
                        i++;
                    }
                }

            } else if ((types[i-1] == R)  ||
                       (types[i-1] == EN) ||
                       (types[i-1] == AN)) {
                j=i;
                while (j<(count-1) && types[j] == ON) {
                    j++;
                }
                if ((types[j] == R)  ||
                    (types[j] == EN) ||
                    (types[j] == AN)) {
                    while (i<j) {
                        types[i] = R;
                        i++;
                    }
                }
            }
        }
    }
    if (count >= 2 && types[count-1] == ON) {
        if (types[count-2] == R || types[count-2] == EN || types[count-2] == AN)
            types[count-1] = R;
        else if (types[count-2] == L)
            types[count-1] = L;
    }

    /* Rule (N2)
     * N2. Any remaining neutrals take the embedding direction.
     */
    for (i=0; i<count; i++) {
        if (types[i] == ON) {
            if ((levels[i] % 2) == 0)
                types[i] = L;
            else
                types[i] = R;
        }
    }

    /* Rule (I1)
     * I1. For all characters with an even (left-to-right) embedding
     * direction, those of type R go up one level and those of type AN or
     * EN go up two levels.
     */
    for (i=0; i<count; i++) {
        if ((levels[i] % 2) == 0) {
            if (types[i] == R)
                levels[i] += 1;
            else if (types[i] == AN || types[i] == EN)
                levels[i] += 2;
        }
    }

    /* Rule (I2)
     * I2. For all characters with an odd (right-to-left) embedding direction,
     * those of type L, EN or AN go up one level.
     */
    for (i=0; i<count; i++) {
        if ((levels[i] % 2) == 1) {
            if (types[i] == L || types[i] == EN || types[i] == AN)
                levels[i] += 1;
        }
    }

    /* Rule (L1)
     * L1. On each line, reset the embedding level of the following characters
     * to the paragraph embedding level:
     *          (1)segment separators, (2)paragraph separators,
     *           (3)any sequence of whitespace characters preceding
     *           a segment separator or paragraph separator,
     *           (4)and any sequence of white space characters
     *           at the end of the line.
     * The types of characters used here are the original types, not those
     * modified by the previous phase.
     */
    j=count-1;
    while (j>0 && (getType(line[j].wc) == WS)) {
        j--;
    }
    if (j < (count-1)) {
        for (j++; j<count; j++)
            levels[j] = paragraphLevel;
    }
    for (i=0; i<count; i++) {
        tempType = getType(line[i].wc);
        if (tempType == WS) {
            j=i;
            while (j<count && (getType(line[j].wc) == WS)) {
                j++;
            }
            if (j==count || getType(line[j].wc) == B ||
                getType(line[j].wc) == S) {
                for (j--; j>=i ; j--) {
                    levels[j] = paragraphLevel;
                }
            }
        } else if (tempType == B || tempType == S) {
            levels[i] = paragraphLevel;
        }
    }

    /* Rule (L4) NOT IMPLEMENTED
     * L4. A character that possesses the mirrored property as specified by
     * Section 4.7, Mirrored, must be depicted by a mirrored glyph if the
     * resolved directionality of that character is R.
     */
    /* Note: this is implemented before L2 for efficiency */
    for (i=0; i<count; i++)
        if ((levels[i] % 2) == 1)
            doMirror(&line[i].wc);

    /* Rule (L2)
     * L2. From the highest level found in the text to the lowest odd level on
     * each line, including intermediate levels not actually present in the
     * text, reverse any contiguous sequence of characters that are at that
     * level or higher
     */
    /* we flip the character string and leave the level array */
    imax = 0;
    i=0;
    tempType = levels[0];
    while (i < count) {
        if (levels[i] > tempType) {
            tempType = levels[i];
            imax=i;
        }
        i++;
    }
    /* maximum level in tempType, its index in imax. */
    while (tempType > 0) {     /* loop from highest level to the least odd, */
        /* which i assume is 1 */
        flipThisRun(line, levels, tempType, count);
        tempType--;
    }

    /* Rule (L3) NOT IMPLEMENTED
     * L3. Combining marks applied to a right-to-left base character will at
     * this point precede their base character. If the rendering engine
     * expects them to follow the base characters in the final display
     * process, then the ordering of the marks and the base character must
     * be reversed.
     */
    free(types);
    free(levels);
    return R;
}


/*
 * Bad, Horrible function
 * takes a pointer to a character that is checked for
 * having a mirror glyph.
 */
void doMirror(wchar_t* ch)
{
    if ((*ch & 0xFF00) == 0) {
        switch (*ch) {
          case 0x0028: *ch = 0x0029; break;
          case 0x0029: *ch = 0x0028; break;
          case 0x003C: *ch = 0x003E; break;
          case 0x003E: *ch = 0x003C; break;
          case 0x005B: *ch = 0x005D; break;
          case 0x005D: *ch = 0x005B; break;
          case 0x007B: *ch = 0x007D; break;
          case 0x007D: *ch = 0x007B; break;
          case 0x00AB: *ch = 0x00BB; break;
          case 0x00BB: *ch = 0x00AB; break;
        }
    } else if ((*ch & 0xFF00) == 0x2000) {
        switch (*ch) {
          case 0x2039: *ch = 0x203A; break;
          case 0x203A: *ch = 0x2039; break;
          case 0x2045: *ch = 0x2046; break;
          case 0x2046: *ch = 0x2045; break;
          case 0x207D: *ch = 0x207E; break;
          case 0x207E: *ch = 0x207D; break;
          case 0x208D: *ch = 0x208E; break;
          case 0x208E: *ch = 0x208D; break;
        }
    } else if ((*ch & 0xFF00) == 0x2200) {
        switch (*ch) {
          case 0x2208: *ch = 0x220B; break;
          case 0x2209: *ch = 0x220C; break;
          case 0x220A: *ch = 0x220D; break;
          case 0x220B: *ch = 0x2208; break;
          case 0x220C: *ch = 0x2209; break;
          case 0x220D: *ch = 0x220A; break;
          case 0x2215: *ch = 0x29F5; break;
          case 0x223C: *ch = 0x223D; break;
          case 0x223D: *ch = 0x223C; break;
          case 0x2243: *ch = 0x22CD; break;
          case 0x2252: *ch = 0x2253; break;
          case 0x2253: *ch = 0x2252; break;
          case 0x2254: *ch = 0x2255; break;
          case 0x2255: *ch = 0x2254; break;
          case 0x2264: *ch = 0x2265; break;
          case 0x2265: *ch = 0x2264; break;
          case 0x2266: *ch = 0x2267; break;
          case 0x2267: *ch = 0x2266; break;
          case 0x2268: *ch = 0x2269; break;
          case 0x2269: *ch = 0x2268; break;
          case 0x226A: *ch = 0x226B; break;
          case 0x226B: *ch = 0x226A; break;
          case 0x226E: *ch = 0x226F; break;
          case 0x226F: *ch = 0x226E; break;
          case 0x2270: *ch = 0x2271; break;
          case 0x2271: *ch = 0x2270; break;
          case 0x2272: *ch = 0x2273; break;
          case 0x2273: *ch = 0x2272; break;
          case 0x2274: *ch = 0x2275; break;
          case 0x2275: *ch = 0x2274; break;
          case 0x2276: *ch = 0x2277; break;
          case 0x2277: *ch = 0x2276; break;
          case 0x2278: *ch = 0x2279; break;
          case 0x2279: *ch = 0x2278; break;
          case 0x227A: *ch = 0x227B; break;
          case 0x227B: *ch = 0x227A; break;
          case 0x227C: *ch = 0x227D; break;
          case 0x227D: *ch = 0x227C; break;
          case 0x227E: *ch = 0x227F; break;
          case 0x227F: *ch = 0x227E; break;
          case 0x2280: *ch = 0x2281; break;
          case 0x2281: *ch = 0x2280; break;
          case 0x2282: *ch = 0x2283; break;
          case 0x2283: *ch = 0x2282; break;
          case 0x2284: *ch = 0x2285; break;
          case 0x2285: *ch = 0x2284; break;
          case 0x2286: *ch = 0x2287; break;
          case 0x2287: *ch = 0x2286; break;
          case 0x2288: *ch = 0x2289; break;
          case 0x2289: *ch = 0x2288; break;
          case 0x228A: *ch = 0x228B; break;
          case 0x228B: *ch = 0x228A; break;
          case 0x228F: *ch = 0x2290; break;
          case 0x2290: *ch = 0x228F; break;
          case 0x2291: *ch = 0x2292; break;
          case 0x2292: *ch = 0x2291; break;
          case 0x2298: *ch = 0x29B8; break;
          case 0x22A2: *ch = 0x22A3; break;
          case 0x22A3: *ch = 0x22A2; break;
          case 0x22A6: *ch = 0x2ADE; break;
          case 0x22A8: *ch = 0x2AE4; break;
          case 0x22A9: *ch = 0x2AE3; break;
          case 0x22AB: *ch = 0x2AE5; break;
          case 0x22B0: *ch = 0x22B1; break;
          case 0x22B1: *ch = 0x22B0; break;
          case 0x22B2: *ch = 0x22B3; break;
          case 0x22B3: *ch = 0x22B2; break;
          case 0x22B4: *ch = 0x22B5; break;
          case 0x22B5: *ch = 0x22B4; break;
          case 0x22B6: *ch = 0x22B7; break;
          case 0x22B7: *ch = 0x22B6; break;
          case 0x22C9: *ch = 0x22CA; break;
          case 0x22CA: *ch = 0x22C9; break;
          case 0x22CB: *ch = 0x22CC; break;
          case 0x22CC: *ch = 0x22CB; break;
          case 0x22CD: *ch = 0x2243; break;
          case 0x22D0: *ch = 0x22D1; break;
          case 0x22D1: *ch = 0x22D0; break;
          case 0x22D6: *ch = 0x22D7; break;
          case 0x22D7: *ch = 0x22D6; break;
          case 0x22D8: *ch = 0x22D9; break;
          case 0x22D9: *ch = 0x22D8; break;
          case 0x22DA: *ch = 0x22DB; break;
          case 0x22DB: *ch = 0x22DA; break;
          case 0x22DC: *ch = 0x22DD; break;
          case 0x22DD: *ch = 0x22DC; break;
          case 0x22DE: *ch = 0x22DF; break;
          case 0x22DF: *ch = 0x22DE; break;
          case 0x22E0: *ch = 0x22E1; break;
          case 0x22E1: *ch = 0x22E0; break;
          case 0x22E2: *ch = 0x22E3; break;
          case 0x22E3: *ch = 0x22E2; break;
          case 0x22E4: *ch = 0x22E5; break;
          case 0x22E5: *ch = 0x22E4; break;
          case 0x22E6: *ch = 0x22E7; break;
          case 0x22E7: *ch = 0x22E6; break;
          case 0x22E8: *ch = 0x22E9; break;
          case 0x22E9: *ch = 0x22E8; break;
          case 0x22EA: *ch = 0x22EB; break;
          case 0x22EB: *ch = 0x22EA; break;
          case 0x22EC: *ch = 0x22ED; break;
          case 0x22ED: *ch = 0x22EC; break;
          case 0x22F0: *ch = 0x22F1; break;
          case 0x22F1: *ch = 0x22F0; break;
          case 0x22F2: *ch = 0x22FA; break;
          case 0x22F3: *ch = 0x22FB; break;
          case 0x22F4: *ch = 0x22FC; break;
          case 0x22F6: *ch = 0x22FD; break;
          case 0x22F7: *ch = 0x22FE; break;
          case 0x22FA: *ch = 0x22F2; break;
          case 0x22FB: *ch = 0x22F3; break;
          case 0x22FC: *ch = 0x22F4; break;
          case 0x22FD: *ch = 0x22F6; break;
          case 0x22FE: *ch = 0x22F7; break;
        }
    } else if ((*ch & 0xFF00) == 0x2300) {
        switch (*ch) {
          case 0x2308: *ch = 0x2309; break;
          case 0x2309: *ch = 0x2308; break;
          case 0x230A: *ch = 0x230B; break;
          case 0x230B: *ch = 0x230A; break;
          case 0x2329: *ch = 0x232A; break;
          case 0x232A: *ch = 0x2329; break;
        }
    } else if ((*ch & 0xFF00) == 0x2700) {
        switch (*ch) {
          case 0x2768: *ch = 0x2769; break;
          case 0x2769: *ch = 0x2768; break;
          case 0x276A: *ch = 0x276B; break;
          case 0x276B: *ch = 0x276A; break;
          case 0x276C: *ch = 0x276D; break;
          case 0x276D: *ch = 0x276C; break;
          case 0x276E: *ch = 0x276F; break;
          case 0x276F: *ch = 0x276E; break;
          case 0x2770: *ch = 0x2771; break;
          case 0x2771: *ch = 0x2770; break;
          case 0x2772: *ch = 0x2773; break;
          case 0x2773: *ch = 0x2772; break;
          case 0x2774: *ch = 0x2775; break;
          case 0x2775: *ch = 0x2774; break;
          case 0x27D5: *ch = 0x27D6; break;
          case 0x27D6: *ch = 0x27D5; break;
          case 0x27DD: *ch = 0x27DE; break;
          case 0x27DE: *ch = 0x27DD; break;
          case 0x27E2: *ch = 0x27E3; break;
          case 0x27E3: *ch = 0x27E2; break;
          case 0x27E4: *ch = 0x27E5; break;
          case 0x27E5: *ch = 0x27E4; break;
          case 0x27E6: *ch = 0x27E7; break;
          case 0x27E7: *ch = 0x27E6; break;
          case 0x27E8: *ch = 0x27E9; break;
          case 0x27E9: *ch = 0x27E8; break;
          case 0x27EA: *ch = 0x27EB; break;
          case 0x27EB: *ch = 0x27EA; break;
        }
    } else if ((*ch & 0xFF00) == 0x2900) {
        switch (*ch) {
          case 0x2983: *ch = 0x2984; break;
          case 0x2984: *ch = 0x2983; break;
          case 0x2985: *ch = 0x2986; break;
          case 0x2986: *ch = 0x2985; break;
          case 0x2987: *ch = 0x2988; break;
          case 0x2988: *ch = 0x2987; break;
          case 0x2989: *ch = 0x298A; break;
          case 0x298A: *ch = 0x2989; break;
          case 0x298B: *ch = 0x298C; break;
          case 0x298C: *ch = 0x298B; break;
          case 0x298D: *ch = 0x2990; break;
          case 0x298E: *ch = 0x298F; break;
          case 0x298F: *ch = 0x298E; break;
          case 0x2990: *ch = 0x298D; break;
          case 0x2991: *ch = 0x2992; break;
          case 0x2992: *ch = 0x2991; break;
          case 0x2993: *ch = 0x2994; break;
          case 0x2994: *ch = 0x2993; break;
          case 0x2995: *ch = 0x2996; break;
          case 0x2996: *ch = 0x2995; break;
          case 0x2997: *ch = 0x2998; break;
          case 0x2998: *ch = 0x2997; break;
          case 0x29B8: *ch = 0x2298; break;
          case 0x29C0: *ch = 0x29C1; break;
          case 0x29C1: *ch = 0x29C0; break;
          case 0x29C4: *ch = 0x29C5; break;
          case 0x29C5: *ch = 0x29C4; break;
          case 0x29CF: *ch = 0x29D0; break;
          case 0x29D0: *ch = 0x29CF; break;
          case 0x29D1: *ch = 0x29D2; break;
          case 0x29D2: *ch = 0x29D1; break;
          case 0x29D4: *ch = 0x29D5; break;
          case 0x29D5: *ch = 0x29D4; break;
          case 0x29D8: *ch = 0x29D9; break;
          case 0x29D9: *ch = 0x29D8; break;
          case 0x29DA: *ch = 0x29DB; break;
          case 0x29DB: *ch = 0x29DA; break;
          case 0x29F5: *ch = 0x2215; break;
          case 0x29F8: *ch = 0x29F9; break;
          case 0x29F9: *ch = 0x29F8; break;
          case 0x29FC: *ch = 0x29FD; break;
          case 0x29FD: *ch = 0x29FC; break;
        }
    } else if ((*ch & 0xFF00) == 0x2A00) {
        switch (*ch) {
          case 0x2A2B: *ch = 0x2A2C; break;
          case 0x2A2C: *ch = 0x2A2B; break;
          case 0x2A2D: *ch = 0x2A2C; break;
          case 0x2A2E: *ch = 0x2A2D; break;
          case 0x2A34: *ch = 0x2A35; break;
          case 0x2A35: *ch = 0x2A34; break;
          case 0x2A3C: *ch = 0x2A3D; break;
          case 0x2A3D: *ch = 0x2A3C; break;
          case 0x2A64: *ch = 0x2A65; break;
          case 0x2A65: *ch = 0x2A64; break;
          case 0x2A79: *ch = 0x2A7A; break;
          case 0x2A7A: *ch = 0x2A79; break;
          case 0x2A7D: *ch = 0x2A7E; break;
          case 0x2A7E: *ch = 0x2A7D; break;
          case 0x2A7F: *ch = 0x2A80; break;
          case 0x2A80: *ch = 0x2A7F; break;
          case 0x2A81: *ch = 0x2A82; break;
          case 0x2A82: *ch = 0x2A81; break;
          case 0x2A83: *ch = 0x2A84; break;
          case 0x2A84: *ch = 0x2A83; break;
          case 0x2A8B: *ch = 0x2A8C; break;
          case 0x2A8C: *ch = 0x2A8B; break;
          case 0x2A91: *ch = 0x2A92; break;
          case 0x2A92: *ch = 0x2A91; break;
          case 0x2A93: *ch = 0x2A94; break;
          case 0x2A94: *ch = 0x2A93; break;
          case 0x2A95: *ch = 0x2A96; break;
          case 0x2A96: *ch = 0x2A95; break;
          case 0x2A97: *ch = 0x2A98; break;
          case 0x2A98: *ch = 0x2A97; break;
          case 0x2A99: *ch = 0x2A9A; break;
          case 0x2A9A: *ch = 0x2A99; break;
          case 0x2A9B: *ch = 0x2A9C; break;
          case 0x2A9C: *ch = 0x2A9B; break;
          case 0x2AA1: *ch = 0x2AA2; break;
          case 0x2AA2: *ch = 0x2AA1; break;
          case 0x2AA6: *ch = 0x2AA7; break;
          case 0x2AA7: *ch = 0x2AA6; break;
          case 0x2AA8: *ch = 0x2AA9; break;
          case 0x2AA9: *ch = 0x2AA8; break;
          case 0x2AAA: *ch = 0x2AAB; break;
          case 0x2AAB: *ch = 0x2AAA; break;
          case 0x2AAC: *ch = 0x2AAD; break;
          case 0x2AAD: *ch = 0x2AAC; break;
          case 0x2AAF: *ch = 0x2AB0; break;
          case 0x2AB0: *ch = 0x2AAF; break;
          case 0x2AB3: *ch = 0x2AB4; break;
          case 0x2AB4: *ch = 0x2AB3; break;
          case 0x2ABB: *ch = 0x2ABC; break;
          case 0x2ABC: *ch = 0x2ABB; break;
          case 0x2ABD: *ch = 0x2ABE; break;
          case 0x2ABE: *ch = 0x2ABD; break;
          case 0x2ABF: *ch = 0x2AC0; break;
          case 0x2AC0: *ch = 0x2ABF; break;
          case 0x2AC1: *ch = 0x2AC2; break;
          case 0x2AC2: *ch = 0x2AC1; break;
          case 0x2AC3: *ch = 0x2AC4; break;
          case 0x2AC4: *ch = 0x2AC3; break;
          case 0x2AC5: *ch = 0x2AC6; break;
          case 0x2AC6: *ch = 0x2AC5; break;
          case 0x2ACD: *ch = 0x2ACE; break;
          case 0x2ACE: *ch = 0x2ACD; break;
          case 0x2ACF: *ch = 0x2AD0; break;
          case 0x2AD0: *ch = 0x2ACF; break;
          case 0x2AD1: *ch = 0x2AD2; break;
          case 0x2AD2: *ch = 0x2AD1; break;
          case 0x2AD3: *ch = 0x2AD4; break;
          case 0x2AD4: *ch = 0x2AD3; break;
          case 0x2AD5: *ch = 0x2AD6; break;
          case 0x2AD6: *ch = 0x2AD5; break;
          case 0x2ADE: *ch = 0x22A6; break;
          case 0x2AE3: *ch = 0x22A9; break;
          case 0x2AE4: *ch = 0x22A8; break;
          case 0x2AE5: *ch = 0x22AB; break;
          case 0x2AEC: *ch = 0x2AED; break;
          case 0x2AED: *ch = 0x2AEC; break;
          case 0x2AF7: *ch = 0x2AF8; break;
          case 0x2AF8: *ch = 0x2AF7; break;
          case 0x2AF9: *ch = 0x2AFA; break;
          case 0x2AFA: *ch = 0x2AF9; break;
        }
    } else if ((*ch & 0xFF00) == 0x3000) {
        switch (*ch) {
          case 0x3008: *ch = 0x3009; break;
          case 0x3009: *ch = 0x3008; break;
          case 0x300A: *ch = 0x300B; break;
          case 0x300B: *ch = 0x300A; break;
          case 0x300C: *ch = 0x300D; break;
          case 0x300D: *ch = 0x300C; break;
          case 0x300E: *ch = 0x300F; break;
          case 0x300F: *ch = 0x300E; break;
          case 0x3010: *ch = 0x3011; break;
          case 0x3011: *ch = 0x3010; break;
          case 0x3014: *ch = 0x3015; break;
          case 0x3015: *ch = 0x3014; break;
          case 0x3016: *ch = 0x3017; break;
          case 0x3017: *ch = 0x3016; break;
          case 0x3018: *ch = 0x3019; break;
          case 0x3019: *ch = 0x3018; break;
          case 0x301A: *ch = 0x301B; break;
          case 0x301B: *ch = 0x301A; break;
        }
    } else if ((*ch & 0xFF00) == 0xFF00) {
        switch (*ch) {
          case 0xFF08: *ch = 0xFF09; break;
          case 0xFF09: *ch = 0xFF08; break;
          case 0xFF1C: *ch = 0xFF1E; break;
          case 0xFF1E: *ch = 0xFF1C; break;
          case 0xFF3B: *ch = 0xFF3D; break;
          case 0xFF3D: *ch = 0xFF3B; break;
          case 0xFF5B: *ch = 0xFF5D; break;
          case 0xFF5D: *ch = 0xFF5B; break;
          case 0xFF5F: *ch = 0xFF60; break;
          case 0xFF60: *ch = 0xFF5F; break;
          case 0xFF62: *ch = 0xFF63; break;
          case 0xFF63: *ch = 0xFF62; break;
        }
    }
}