path: root/src/java/org/apache/fop/util/CharUtilities.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id$ */

package org.apache.fop.util;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

// CSOFF: AvoidNestedBlocksCheck
// CSOFF: InnerAssignmentCheck
// CSOFF: WhitespaceAfterCheck
// CSOFF: SimplifyBooleanReturnCheck

/**
 * This class provides utilities to distinguish various kinds of Unicode
 * whitespace and to get character widths in a given FontState.
 */
public class CharUtilities {

    /**
     * Character code used to signal a character boundary in
     * inline content, such as an inline with borders and padding
     * or a nested block object.
     */
    public static final char CODE_EOT = 0;

    /**
     * Character class: Unicode white space
     */
    public static final int UCWHITESPACE = 0;
    /**
     * Character class: Line feed
     */
    public static final int LINEFEED = 1;
    /**
     * Character class: Boundary between text runs
     */
    public static final int EOT = 2;
    /**
     * Character class: non-whitespace
     */
    public static final int NONWHITESPACE = 3;
    /**
     * Character class: XML whitespace
     */
    public static final int XMLWHITESPACE = 4;


    /** null char */
    public static final char NULL_CHAR = '\u0000';
    /** linefeed character */
    public static final char LINEFEED_CHAR = '\n';
    /** carriage return */
    public static final char CARRIAGE_RETURN = '\r';
    /** normal tab */
    public static final char TAB = '\t';
    /** normal space */
    public static final char SPACE = '\u0020';
    /** non-breaking space */
    public static final char NBSPACE = '\u00A0';
    /** next line control character */
    public static final char NEXT_LINE = '\u0085';
    /** zero-width space */
    public static final char ZERO_WIDTH_SPACE = '\u200B';
    /** word joiner */
    public static final char WORD_JOINER = '\u2060';
    /** zero-width joiner */
    public static final char ZERO_WIDTH_JOINER = '\u200D';
    /** left-to-right mark */
    public static final char LRM = '\u200E';
    /** right-to-left mark */
    public static final char RLM = '\u202F';
    /** left-to-right embedding */
    public static final char LRE = '\u202A';
    /** right-to-left embedding */
    public static final char RLE = '\u202B';
    /** pop directional formatting */
    public static final char PDF = '\u202C';
    /** left-to-right override */
    public static final char LRO = '\u202D';
    /** right-to-left override */
    public static final char RLO = '\u202E';
    /** zero-width no-break space (= byte order mark) */
    public static final char ZERO_WIDTH_NOBREAK_SPACE = '\uFEFF';
    /** soft hyphen */
    public static final char SOFT_HYPHEN = '\u00AD';
    /** line-separator */
    public static final char LINE_SEPARATOR = '\u2028';
    /** paragraph-separator */
    public static final char PARAGRAPH_SEPARATOR = '\u2029';
    /** missing ideograph */
    public static final char MISSING_IDEOGRAPH = '\u25A1';
    /** Ideogreaphic space */
    public static final char IDEOGRAPHIC_SPACE = '\u3000';
    /** Object replacement character */
    public static final char OBJECT_REPLACEMENT_CHARACTER = '\uFFFC';
    /** Unicode value indicating the the character is "not a character". */
    public static final char NOT_A_CHARACTER = '\uFFFF';

    /**
      * A static (class) parameter indicating whether V2 indic shaping
      * rules apply or not, with default being <code>true</code>.
      */
    private static final boolean useV2Indic = true; // CSOK: ConstantNameCheck

    /**
     * Utility class: Constructor prevents instantiating when subclassed.
     */
    protected CharUtilities() {
        throw new UnsupportedOperationException();
    }

    /**
     * Return the appropriate CharClass constant for the type
     * of the passed character.
     * @param c character to inspect
     * @return the determined character class
     */
    public static int classOf ( int c ) {
        switch (c) {
            case CODE_EOT:
                return EOT;
            case LINEFEED_CHAR:
                return LINEFEED;
            case SPACE:
            case CARRIAGE_RETURN:
            case TAB:
                return XMLWHITESPACE;
            default:
                return isAnySpace(c) ? UCWHITESPACE : NONWHITESPACE;
        }
    }


    /**
     * Helper method to determine if the character is a
     * space with normal behavior. Normal behavior means that
     * it's not non-breaking.
     * @param c character to inspect
     * @return True if the character is a normal space
     */
    public static boolean isBreakableSpace ( int c ) {
        return (c == SPACE || isFixedWidthSpace(c));
    }

    /**
     * Method to determine if the character is a zero-width space.
     * @param c the character to check
     * @return true if the character is a zero-width space
     */
    public static boolean isZeroWidthSpace ( int c ) {
        return c == ZERO_WIDTH_SPACE           // 200Bh
            || c == WORD_JOINER                // 2060h
            || c == ZERO_WIDTH_NOBREAK_SPACE;  // FEFFh (also used as BOM)
    }

    /**
     * Method to determine if the character is a (breakable) fixed-width space.
     * @param c the character to check
     * @return true if the character has a fixed-width
     */
    public static boolean isFixedWidthSpace ( int c ) {
        return (c >= '\u2000' && c <= '\u200B')
                || c == '\u3000';
//      c == '\u2000'                   // en quad
//      c == '\u2001'                   // em quad
//      c == '\u2002'                   // en space
//      c == '\u2003'                   // em space
//      c == '\u2004'                   // three-per-em space
//      c == '\u2005'                   // four-per-em space
//      c == '\u2006'                   // six-per-em space
//      c == '\u2007'                   // figure space
//      c == '\u2008'                   // punctuation space
//      c == '\u2009'                   // thin space
//      c == '\u200A'                   // hair space
//      c == '\u200B'                   // zero width space
//      c == '\u3000'                   // ideographic space
    }

    /**
     * Method to determine if the character is a nonbreaking
     * space.
     * @param c character to check
     * @return True if the character is a nbsp
     */
    public static boolean isNonBreakableSpace ( int c ) {
        return
            (c == NBSPACE       // no-break space
            || c == '\u202F'    // narrow no-break space
            || c == '\u3000'    // ideographic space
            || c == WORD_JOINER // word joiner
            || c == ZERO_WIDTH_NOBREAK_SPACE);  // zero width no-break space
    }

    /**
     * Method to determine if the character is an adjustable
     * space.
     * @param c character to check
     * @return True if the character is adjustable
     */
    public static boolean isAdjustableSpace ( int c ) {
        //TODO: are there other kinds of adjustable spaces?
        return
            (c == '\u0020'    // normal space
            || c == NBSPACE); // no-break space
    }

    /**
     * Determines if the character represents any kind of space.
     * @param c character to check
     * @return True if the character represents any kind of space
     */
    public static boolean isAnySpace ( int c ) {
        return (isBreakableSpace(c) || isNonBreakableSpace(c));
    }

    /**
     * Indicates whether a character is classified as "Alphabetic" by the Unicode standard.
     * @param c the character
     * @return true if the character is "Alphabetic"
     */
    public static boolean isAlphabetic ( int c ) {
        //http://www.unicode.org/Public/UNIDATA/UCD.html#Alphabetic
        //Generated from: Other_Alphabetic + Lu + Ll + Lt + Lm + Lo + Nl
        int generalCategory = Character.getType((char)c);
        switch (generalCategory) {
            case Character.UPPERCASE_LETTER: //Lu
            case Character.LOWERCASE_LETTER: //Ll
            case Character.TITLECASE_LETTER: //Lt
            case Character.MODIFIER_LETTER: //Lm
            case Character.OTHER_LETTER: //Lo
            case Character.LETTER_NUMBER: //Nl
                return true;
            default:
                //TODO if (ch in Other_Alphabetic) return true; (Probably need ICU4J for that)
                //Other_Alphabetic contains mostly more exotic characters
                return false;
        }
    }

    /**
     * Indicates whether the given character is an explicit break-character
     * @param c    the character to check
     * @return  true if the character represents an explicit break
     */
    public static boolean isExplicitBreak ( int c ) {
        return (c == LINEFEED_CHAR
            || c == CARRIAGE_RETURN
            || c == NEXT_LINE
            || c == LINE_SEPARATOR
            || c == PARAGRAPH_SEPARATOR);
    }


    //
    // The following script codes are based on ISO 15924. Codes less than 1000 are
    // official assignments from 15924; those equal to or greater than 1000 are FOP
    // implementation specific.
    // 
    // CSOFF: LineLengthCheck
    /** hebrew script constant */
    public static final int SCRIPT_HEBREW                               = 125;  // 'hebr'
    /** mongolian script constant */
    public static final int SCRIPT_MONGOLIAN                            = 145;  // 'mong'
    /** arabic script constant */
    public static final int SCRIPT_ARABIC                               = 160;  // 'arab'
    /** greek script constant */
    public static final int SCRIPT_GREEK                                = 200;  // 'grek'
    /** latin script constant */
    public static final int SCRIPT_LATIN                                = 215;  // 'latn'
    /** cyrillic script constant */
    public static final int SCRIPT_CYRILLIC                             = 220;  // 'cyrl'
    /** georgian script constant */
    public static final int SCRIPT_GEORGIAN                             = 240;  // 'geor'
    /** bopomofo script constant */
    public static final int SCRIPT_BOPOMOFO                             = 285;  // 'bopo'
    /** hangul script constant */
    public static final int SCRIPT_HANGUL                               = 286;  // 'hang'
    /** gurmukhi script constant */
    public static final int SCRIPT_GURMUKHI                             = 310;  // 'guru'
    /** gurmukhi 2 script constant */
    public static final int SCRIPT_GURMUKHI_2                           = 1310; // 'gur2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** devanagari script constant */
    public static final int SCRIPT_DEVANAGARI                           = 315;  // 'deva'
    /** devanagari 2 script constant */
    public static final int SCRIPT_DEVANAGARI_2                         = 1315; // 'dev2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** gujarati script constant */
    public static final int SCRIPT_GUJARATI                             = 320;  // 'gujr'
    /** gujarati 2 script constant */
    public static final int SCRIPT_GUJARATI_2                           = 1320; // 'gjr2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** bengali script constant */
    public static final int SCRIPT_BENGALI                              = 326;  // 'beng'
    /** bengali 2 script constant */
    public static final int SCRIPT_BENGALI_2                            = 1326; // 'bng2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** oriya script constant */
    public static final int SCRIPT_ORIYA                                = 327;  // 'orya'
    /** oriya 2 script constant */
    public static final int SCRIPT_ORIYA_2                              = 1327; // 'ory2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** tibetan script constant */
    public static final int SCRIPT_TIBETAN                              = 330;  // 'tibt'
    /** telugu script constant */
    public static final int SCRIPT_TELUGU                               = 340;  // 'telu'
    /** telugu 2 script constant */
    public static final int SCRIPT_TELUGU_2                             = 1340; // 'tel2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** kannada script constant */
    public static final int SCRIPT_KANNADA                              = 345;  // 'knda'
    /** kannada 2 script constant */
    public static final int SCRIPT_KANNADA_2                            = 1345; // 'knd2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** tamil script constant */
    public static final int SCRIPT_TAMIL                                = 346;  // 'taml'
    /** tamil 2 script constant */
    public static final int SCRIPT_TAMIL_2                              = 1346; // 'tml2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** malayalam script constant */
    public static final int SCRIPT_MALAYALAM                            = 347;  // 'mlym'
    /** malayalam 2 script constant */
    public static final int SCRIPT_MALAYALAM_2                          = 1347; // 'mlm2'       -- MSFT (pseudo) script tag for variant shaping semantics
    /** sinhalese script constant */
    public static final int SCRIPT_SINHALESE                            = 348;  // 'sinh'
    /** burmese script constant */
    public static final int SCRIPT_BURMESE                              = 350;  // 'mymr'
    /** thai script constant */
    public static final int SCRIPT_THAI                                 = 352;  // 'thai'
    /** khmer script constant */
    public static final int SCRIPT_KHMER                                = 355;  // 'khmr'
    /** lao script constant */
    public static final int SCRIPT_LAO                                  = 356;  // 'laoo'
    /** hiragana script constant */
    public static final int SCRIPT_HIRAGANA                             = 410;  // 'hira'
    /** ethiopic script constant */
    public static final int SCRIPT_ETHIOPIC                             = 430;  // 'ethi'
    /** han script constant */
    public static final int SCRIPT_HAN                                  = 500;  // 'hani'
    /** katakana script constant */
    public static final int SCRIPT_KATAKANA                             = 410;  // 'kana'
    /** math script constant */
    public static final int SCRIPT_MATH                                 = 995;  // 'zmth'
    /** symbol script constant */
    public static final int SCRIPT_SYMBOL                               = 996;  // 'zsym'
    /** undetermined script constant */
    public static final int SCRIPT_UNDETERMINED                         = 998;  // 'zyyy'
    /** uncoded script constant */
    public static final int SCRIPT_UNCODED                              = 999;  // 'zzzz'
    // CSON: LineLengthCheck

    /**
     * Determine if character c is punctuation.
     * @param c a character represented as a unicode scalar value
     * @return true if character is punctuation
     */
    public static boolean isPunctuation ( int c ) {
        if ( ( c >= 0x0021 ) && ( c <= 0x002F ) ) {             // basic latin punctuation
            return true;
        } else if ( ( c >= 0x003A ) && ( c <= 0x0040 ) ) {      // basic latin punctuation
            return true;
        } else if ( ( c >= 0x005F ) && ( c <= 0x0060 ) ) {      // basic latin punctuation
            return true;
        } else if ( ( c >= 0x007E ) && ( c <= 0x007E ) ) {      // basic latin punctuation
            return true;
        } else if ( ( c >= 0x007E ) && ( c <= 0x007E ) ) {      // basic latin punctuation
            return true;
        } else if ( ( c >= 0x00A1 ) && ( c <= 0x00BF ) ) {      // latin supplement punctuation
            return true;
        } else if ( ( c >= 0x00D7 ) && ( c <= 0x00D7 ) ) {      // latin supplement punctuation
            return true;
        } else if ( ( c >= 0x00F7 ) && ( c <= 0x00F7 ) ) {      // latin supplement punctuation
            return true;
        } else if ( ( c >= 0x2000 ) && ( c <= 0x206F ) ) {      // general punctuation
            return true;
        } else {                                                // [TBD] - not complete
            return false;
        }
    }

    /**
     * Determine if character c is a digit.
     * @param c a character represented as a unicode scalar value
     * @return true if character is a digit
     */
    public static boolean isDigit ( int c ) {
        if ( ( c >= 0x0030 ) && ( c <= 0x0039 ) ) {             // basic latin digits
            return true;
        } else {                                                // [TBD] - not complete
            return false;
        }
    }

    /**
     * Determine if character c belong to the hebrew script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to hebrew script
     */
    public static boolean isHebrew ( int c ) {
        if ( ( c >= 0x0590 ) && ( c <= 0x05FF ) ) {             // hebrew block
            return true;
        } else if ( ( c >= 0xFB00 ) && ( c <= 0xFB4F ) ) {      // hebrew presentation forms block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the mongolian script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to mongolian script
     */
    public static boolean isMongolian ( int c ) {
        if ( ( c >= 0x1800 ) && ( c <= 0x18AF ) ) {             // mongolian block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the arabic script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to arabic script
     */
    public static boolean isArabic ( int c ) {
        if ( ( c >= 0x0600 ) && ( c <= 0x06FF ) ) {             // arabic block
            return true;
        } else if ( ( c >= 0x0750 ) && ( c <= 0x077F ) ) {      // arabic supplement block
            return true;
        } else if ( ( c >= 0xFB50 ) && ( c <= 0xFDFF ) ) {      // arabic presentation forms a block
            return true;
        } else if ( ( c >= 0xFE70 ) && ( c <= 0xFEFF ) ) {      // arabic presentation forms b block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the greek script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to greek script
     */
    public static boolean isGreek ( int c ) {
        if ( ( c >= 0x0370 ) && ( c <= 0x03FF ) ) {             // greek (and coptic) block
            return true;
        } else if ( ( c >= 0x1F00 ) && ( c <= 0x1FFF ) ) {      // greek extended block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the latin script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to latin script
     */
    public static boolean isLatin ( int c ) {
        if ( ( c >= 0x0041 ) && ( c <= 0x005A ) ) {             // basic latin upper case
            return true;
        } else if ( ( c >= 0x0061 ) && ( c <= 0x007A ) ) {      // basic latin lower case
            return true;
        } else if ( ( c >= 0x00C0 ) && ( c <= 0x00D6 ) ) {      // latin supplement upper case
            return true;
        } else if ( ( c >= 0x00D8 ) && ( c <= 0x00DF ) ) {      // latin supplement upper case
            return true;
        } else if ( ( c >= 0x00E0 ) && ( c <= 0x00F6 ) ) {      // latin supplement lower case
            return true;
        } else if ( ( c >= 0x00F8 ) && ( c <= 0x00FF ) ) {      // latin supplement lower case
            return true;
        } else if ( ( c >= 0x0100 ) && ( c <= 0x017F ) ) {      // latin extended a
            return true;
        } else if ( ( c >= 0x0180 ) && ( c <= 0x024F ) ) {      // latin extended b
            return true;
        } else if ( ( c >= 0x1E00 ) && ( c <= 0x1EFF ) ) {      // latin extended additional
            return true;
        } else if ( ( c >= 0x2C60 ) && ( c <= 0x2C7F ) ) {      // latin extended c
            return true;
        } else if ( ( c >= 0xA720 ) && ( c <= 0xA7FF ) ) {      // latin extended d
            return true;
        } else if ( ( c >= 0xFB00 ) && ( c <= 0xFB0F ) ) {      // latin ligatures
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the cyrillic script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to cyrillic script
     */
    public static boolean isCyrillic ( int c ) {
        if ( ( c >= 0x0400 ) && ( c <= 0x04FF ) ) {             // cyrillic block
            return true;
        } else if ( ( c >= 0x0500 ) && ( c <= 0x052F ) ) {      // cyrillic supplement block
            return true;
        } else if ( ( c >= 0x2DE0 ) && ( c <= 0x2DFF ) ) {      // cyrillic extended-a block
            return true;
        } else if ( ( c >= 0xA640 ) && ( c <= 0xA69F ) ) {      // cyrillic extended-b block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the georgian script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to georgian script
     */
    public static boolean isGeorgian ( int c ) {
        if ( ( c >= 0x10A0 ) && ( c <= 0x10FF ) ) {             // georgian block
            return true;
        } else if ( ( c >= 0x2D00 ) && ( c <= 0x2D2F ) ) {      // georgian supplement block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the hangul script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to hangul script
     */
    public static boolean isHangul ( int c ) {
        if ( ( c >= 0x1100 ) && ( c <= 0x11FF ) ) {             // hangul jamo
            return true;
        } else if ( ( c >= 0x3130 ) && ( c <= 0x318F ) ) {      // hangul compatibility jamo
            return true;
        } else if ( ( c >= 0xA960 ) && ( c <= 0xA97F ) ) {      // hangul jamo extended a
            return true;
        } else if ( ( c >= 0xAC00 ) && ( c <= 0xD7A3 ) ) {      // hangul syllables
            return true;
        } else if ( ( c >= 0xD7B0 ) && ( c <= 0xD7FF ) ) {      // hangul jamo extended a
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the gurmukhi script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to gurmukhi script
     */
    public static boolean isGurmukhi ( int c ) {
        if ( ( c >= 0x0A00 ) && ( c <= 0x0A7F ) ) {             // gurmukhi block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the devanagari script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to devanagari script
     */
    public static boolean isDevanagari ( int c ) {
        if ( ( c >= 0x0900 ) && ( c <= 0x097F ) ) {             // devangari block
            return true;
        } else if ( ( c >= 0xA8E0 ) && ( c <= 0xA8FF ) ) {      // devangari extended block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the gujarati script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to gujarati script
     */
    public static boolean isGujarati ( int c ) {
        if ( ( c >= 0x0A80 ) && ( c <= 0x0AFF ) ) {             // gujarati block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the bengali script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to bengali script
     */
    public static boolean isBengali ( int c ) {
        if ( ( c >= 0x0980 ) && ( c <= 0x09FF ) ) {             // bengali block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the oriya script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to oriya script
     */
    public static boolean isOriya ( int c ) {
        if ( ( c >= 0x0B00 ) && ( c <= 0x0B7F ) ) {             // oriya block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the tibetan script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to tibetan script
     */
    public static boolean isTibetan ( int c ) {
        if ( ( c >= 0x0F00 ) && ( c <= 0x0FFF ) ) {             // tibetan block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the telugu script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to telugu script
     */
    public static boolean isTelugu ( int c ) {
        if ( ( c >= 0x0C00 ) && ( c <= 0x0C7F ) ) {             // telugu block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the kannada script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to kannada script
     */
    public static boolean isKannada ( int c ) {
        if ( ( c >= 0x0C00 ) && ( c <= 0x0C7F ) ) {             // kannada block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the tamil script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to tamil script
     */
    public static boolean isTamil ( int c ) {
        if ( ( c >= 0x0B80 ) && ( c <= 0x0BFF ) ) {             // tamil block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the malayalam script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to malayalam script
     */
    public static boolean isMalayalam ( int c ) {
        if ( ( c >= 0x0D00 ) && ( c <= 0x0D7F ) ) {             // malayalam block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the sinhalese script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to sinhalese script
     */
    public static boolean isSinhalese ( int c ) {
        if ( ( c >= 0x0D80 ) && ( c <= 0x0DFF ) ) {             // sinhala block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the burmese script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to burmese script
     */
    public static boolean isBurmese ( int c ) {
        if ( ( c >= 0x1000 ) && ( c <= 0x109F ) ) {             // burmese (myanmar) block
            return true;
        } else if ( ( c >= 0xAA60 ) && ( c <= 0xAA7F ) ) {      // burmese (myanmar) extended block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the thai script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to thai script
     */
    public static boolean isThai ( int c ) {
        if ( ( c >= 0x0E00 ) && ( c <= 0x0E7F ) ) {             // thai block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the khmer script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to khmer script
     */
    public static boolean isKhmer ( int c ) {
        if ( ( c >= 0x1780 ) && ( c <= 0x17FF ) ) {             // khmer block
            return true;
        } else if ( ( c >= 0x19E0 ) && ( c <= 0x19FF ) ) {      // khmer symbols block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the lao script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to lao script
     */
    public static boolean isLao ( int c ) {
        if ( ( c >= 0x0E80 ) && ( c <= 0x0EFF ) ) {             // lao block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the ethiopic (amharic) script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to ethiopic (amharic) script
     */
    public static boolean isEthiopic ( int c ) {
        if ( ( c >= 0x1200 ) && ( c <= 0x137F ) ) {             // ethiopic block
            return true;
        } else if ( ( c >= 0x1380 ) && ( c <= 0x139F ) ) {      // ethoipic supplement block
            return true;
        } else if ( ( c >= 0x2D80 ) && ( c <= 0x2DDF ) ) {      // ethoipic extended block
            return true;
        } else if ( ( c >= 0xAB00 ) && ( c <= 0xAB2F ) ) {      // ethoipic extended-a block
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the han (unified cjk) script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to han (unified cjk) script
     */
    public static boolean isHan ( int c ) {
        if ( ( c >= 0x3400 ) && ( c <= 0x4DBF ) ) {             
            return true; // cjk unified ideographs extension a
        } else if ( ( c >= 0x4E00 ) && ( c <= 0x9FFF ) ) {      
            return true; // cjk unified ideographs
        } else if ( ( c >= 0xF900 ) && ( c <= 0xFAFF ) ) {      
            return true; // cjk compatibility ideographs
        } else if ( ( c >= 0x20000 ) && ( c <= 0x2A6DF ) ) {    
            return true; // cjk unified ideographs extension b
        } else if ( ( c >= 0x2A700 ) && ( c <= 0x2B73F ) ) {    
            return true; // cjk unified ideographs extension c
        } else if ( ( c >= 0x2F800 ) && ( c <= 0x2FA1F ) ) {    
            return true; // cjk compatibility ideographs supplement
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the bopomofo script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to bopomofo script
     */
    public static boolean isBopomofo ( int c ) {
        if ( ( c >= 0x3100 ) && ( c <= 0x312F ) ) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the hiragana script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to hiragana script
     */
    public static boolean isHiragana ( int c ) {
        if ( ( c >= 0x3040 ) && ( c <= 0x309F ) ) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Determine if character c belong to the katakana script.
     * @param c a character represented as a unicode scalar value
     * @return true if character belongs to katakana script
     */
    public static boolean isKatakana ( int c ) {
        if ( ( c >= 0x30A0 ) && ( c <= 0x30FF ) ) {
            return true;
        } else if ( ( c >= 0x31F0 ) && ( c <= 0x31FF ) ) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Obtain ISO15924 numeric script code of character. If script is not or cannot be determined,
     * then the script code 998 ('zyyy') is returned.
     * @param c the character to obtain script
     * @return an ISO15924 script code
     */
    public static int scriptOf ( int c ) { // [TBD] - needs optimization!!!
        if ( isAnySpace ( c ) ) {
            return SCRIPT_UNDETERMINED;
        } else if ( isPunctuation ( c ) ) {
            return SCRIPT_UNDETERMINED;
        } else if ( isDigit ( c ) ) {
            return SCRIPT_UNDETERMINED;
        } else if ( isLatin ( c ) ) {
            return SCRIPT_LATIN;
        } else if ( isCyrillic ( c ) ) {
            return SCRIPT_CYRILLIC;
        } else if ( isGreek ( c ) ) {
            return SCRIPT_GREEK;
        } else if ( isHan ( c ) ) {
            return SCRIPT_HAN;
        } else if ( isBopomofo ( c ) ) {
            return SCRIPT_BOPOMOFO;
        } else if ( isKatakana ( c ) ) {
            return SCRIPT_KATAKANA;
        } else if ( isHiragana ( c ) ) {
            return SCRIPT_HIRAGANA;
        } else if ( isHangul ( c ) ) {
            return SCRIPT_HANGUL;
        } else if ( isArabic ( c ) ) {
            return SCRIPT_ARABIC;
        } else if ( isHebrew ( c ) ) {
            return SCRIPT_HEBREW;
        } else if ( isMongolian ( c ) ) {
            return SCRIPT_MONGOLIAN;
        } else if ( isGeorgian ( c ) ) {
            return SCRIPT_GEORGIAN;
        } else if ( isGurmukhi ( c ) ) {
            return useV2IndicRules ( SCRIPT_GURMUKHI );
        } else if ( isDevanagari ( c ) ) {
            return useV2IndicRules ( SCRIPT_DEVANAGARI );
        } else if ( isGujarati ( c ) ) {
            return useV2IndicRules ( SCRIPT_GUJARATI );
        } else if ( isBengali ( c ) ) {
            return useV2IndicRules ( SCRIPT_BENGALI );
        } else if ( isOriya ( c ) ) {
            return useV2IndicRules ( SCRIPT_ORIYA );
        } else if ( isTibetan ( c ) ) {
            return SCRIPT_TIBETAN;
        } else if ( isTelugu ( c ) ) {
            return useV2IndicRules ( SCRIPT_TELUGU );
        } else if ( isKannada ( c ) ) {
            return useV2IndicRules ( SCRIPT_KANNADA );
        } else if ( isTamil ( c ) ) {
            return useV2IndicRules ( SCRIPT_TAMIL );
        } else if ( isMalayalam ( c ) ) {
            return useV2IndicRules ( SCRIPT_MALAYALAM );
        } else if ( isSinhalese ( c ) ) {
            return SCRIPT_SINHALESE;
        } else if ( isBurmese ( c ) ) {
            return SCRIPT_BURMESE;
        } else if ( isThai ( c ) ) {
            return SCRIPT_THAI;
        } else if ( isKhmer ( c ) ) {
            return SCRIPT_KHMER;
        } else if ( isLao ( c ) ) {
            return SCRIPT_LAO;
        } else if ( isEthiopic ( c ) ) {
            return SCRIPT_ETHIOPIC;
        } else {
            return SCRIPT_UNDETERMINED;
        }
    }

    /**
     * Obtain the V2 indic script code corresponding to V1 indic script code SC if
     * and only iff V2 indic rules apply; otherwise return SC.
     * @param sc a V1 indic script code
     * @return either SC or the V2 flavor of SC if V2 indic rules apply
     */
    public static int useV2IndicRules ( int sc ) {
        if ( useV2Indic ) {
            return ( sc < 1000 ) ? ( sc + 1000 ) : sc;
        } else {
            return sc;
        }
    }

    /**
     * Obtain the  script codes of each character in a character sequence. If script
     * is not or cannot be determined for some character, then the script code 998
     * ('zyyy') is returned.
     * @param cs the character sequence
     * @return a (possibly empty) array of script codes
     */
    public static int[] scriptsOf ( CharSequence cs ) {
        Set s = new HashSet();
        for ( int i = 0, n = cs.length(); i < n; i++ ) {
            s.add ( Integer.valueOf ( scriptOf ( cs.charAt ( i ) ) ) );
        }
        int[] sa = new int [ s.size() ];
        int ns = 0;
        for ( Iterator it = s.iterator(); it.hasNext();) {
            sa [ ns++ ] = ( (Integer) it.next() ) .intValue();
        }
        Arrays.sort ( sa );
        return sa;
    }

    /**
     * Determine the dominant script of a character sequence.
     * @param cs the character sequence
     * @return the dominant script or SCRIPT_UNDETERMINED
     */
    public static int dominantScript ( CharSequence cs ) {
        Map m = new HashMap();
        for ( int i = 0, n = cs.length(); i < n; i++ ) {
            int c = cs.charAt ( i );
            int s = scriptOf ( c );
            Integer k = Integer.valueOf ( s );
            Integer v = (Integer) m.get ( k );
            if ( v != null ) {
                m.put ( k, Integer.valueOf ( v.intValue() + 1 ) );
            } else {
                m.put ( k, Integer.valueOf ( 0 ) );
            }
        }
        int sMax = -1;
        int cMax = -1;
        for ( Iterator it = m.entrySet().iterator(); it.hasNext();) {
            Map.Entry e = (Map.Entry) it.next();
            Integer k = (Integer) e.getKey();
            int s = k.intValue();
            switch ( s ) {
            case SCRIPT_UNDETERMINED:
            case SCRIPT_UNCODED:
                break;
            default:
                {
                    Integer v = (Integer) e.getValue();
                    assert v != null;
                    int c = v.intValue();
                    if ( c > cMax ) {
                        cMax = c; sMax = s;
                    }
                    break;
                }
            }
        }
        if ( sMax < 0 ) {
            sMax = SCRIPT_UNDETERMINED;
        }
        return sMax;
    }

    /**
     * Determine if script tag denotes an 'Indic' script, where a
     * script is an 'Indic' script if it is intended to be processed by
     * the generic 'Indic' Script Processor.
     * @param script a script tag
     * @return true if script tag is a designated 'Indic' script
     */
    public static boolean isIndicScript ( String script ) {
        switch ( scriptCodeFromTag ( script ) ) {
        case SCRIPT_BENGALI:
        case SCRIPT_BENGALI_2:
        case SCRIPT_BURMESE:
        case SCRIPT_DEVANAGARI:
        case SCRIPT_DEVANAGARI_2:
        case SCRIPT_GUJARATI:
        case SCRIPT_GUJARATI_2:
        case SCRIPT_GURMUKHI:
        case SCRIPT_GURMUKHI_2:
        case SCRIPT_KANNADA:
        case SCRIPT_KANNADA_2:
        case SCRIPT_MALAYALAM:
        case SCRIPT_MALAYALAM_2:
        case SCRIPT_ORIYA:
        case SCRIPT_ORIYA_2:
        case SCRIPT_TAMIL:
        case SCRIPT_TAMIL_2:
        case SCRIPT_TELUGU:
        case SCRIPT_TELUGU_2:
            return true;
        default:
            return false;
        }
    }

    /**
     * Determine the script tag associated with an internal script code.
     * @param code the script code
     * @return a  script tag
     */
    public static String scriptTagFromCode ( int code ) {
        Map<Integer,String> m = getScriptTagsMap();
        if ( m != null ) {
            String tag;
            if ( ( tag = m.get ( Integer.valueOf ( code ) ) ) != null ) {
                return tag;
            } else {
                return "";
            }
        } else {
            return "";
        }
    }

    /**
     * Determine the internal script code associated with a script tag.
     * @param tag the script tag
     * @return a script code
     */
    public static int scriptCodeFromTag ( String tag ) {
        Map<String,Integer> m = getScriptCodeMap();
        if ( m != null ) {
            Integer c;
            if ( ( c = m.get ( tag ) ) != null ) {
                return (int) c;
            } else {
                return SCRIPT_UNDETERMINED;
            }
        } else {
            return SCRIPT_UNDETERMINED;
        }
    }

    /**
     * Convert a single unicode scalar value to an XML numeric character
     * reference. If in the BMP, four digits are used, otherwise 6 digits are used.
     * @param c a unicode scalar value
     * @return a string representing a numeric character reference
     */
    public static String charToNCRef ( int c ) {
        StringBuffer sb = new StringBuffer();
        for ( int i = 0, nDigits = ( c > 0xFFFF ) ? 6 : 4; i < nDigits; i++, c >>= 4 ) {
            int d = c & 0xF;
            char hd;
            if ( d < 10 ) {
                hd = (char) ( (int) '0' + d );
            } else {
                hd = (char) ( (int) 'A' + ( d - 10 ) );
            }
            sb.append ( hd );
        }
        return "&#x" + sb.reverse() + ";";
    }

    /**
     * Convert a string to a sequence of ASCII or XML numeric character references.
     * @param s a java string (encoded in UTF-16)
     * @return a string representing a sequence of numeric character reference or
     * ASCII characters
     */
    public static String toNCRefs ( String s ) {
        StringBuffer sb = new StringBuffer();
        if ( s != null ) {
            for ( int i = 0; i < s.length(); i++ ) {
                char c = s.charAt(i);
                if ( ( c >= 32 ) && ( c < 127 ) ) {
                    if ( c == '<' ) {
                        sb.append ( "&lt;" );
                    } else if ( c == '>' ) {
                        sb.append ( "&gt;" );
                    } else if ( c == '&' ) {
                        sb.append ( "&amp;" );
                    } else {
                        sb.append ( c );
                    }
                } else {
                    sb.append ( charToNCRef ( c ) );
                }
            }
        }
        return sb.toString();
    }

    /**
     * Pad a string S on left out to width W using padding character PAD.
     * @param s string to pad
     * @param width width of field to add padding
     * @param pad character to use for padding
     * @return padded string
     */
    public static String padLeft ( String s, int width, char pad ) {
        StringBuffer sb = new StringBuffer();
        for ( int i = s.length(); i < width; i++ ) {
            sb.append(pad);
        }
        sb.append ( s );
        return sb.toString();
    }

    /**
     * Format character for debugging output, which it is prefixed with "0x", padded left with '0'
     * and either 4 or 6 hex characters in width according to whether it is in the BMP or not.
     * @param c character code
     * @return formatted character string
     */
    public static String format ( int c ) {
        if ( c < 1114112 ) {
            return "0x" + padLeft ( Integer.toString ( c, 16 ), ( c < 65536 ) ? 4 : 6, '0' );
        } else {
            return "!NOT A CHARACTER!";
        }
    }

    private static Map<Integer,String> scriptTagsMap = null;
    private static Map<String,Integer> scriptCodeMap = null;

    private static void putScriptTag ( Map tm, Map cm, int code, String tag ) {
        assert tag != null;
        assert tag.length() != 0;
        assert code >= 0;
        assert code <  2000;
        tm.put ( Integer.valueOf ( code ), tag );
        cm.put ( tag, Integer.valueOf ( code ) );
    }

    private static void makeScriptMaps() {
        HashMap<Integer,String> tm = new HashMap<Integer,String>();
        HashMap<String,Integer> cm = new HashMap<String,Integer>();
        putScriptTag ( tm, cm, SCRIPT_HEBREW, "hebr" );
        putScriptTag ( tm, cm, SCRIPT_MONGOLIAN, "mong" );
        putScriptTag ( tm, cm, SCRIPT_ARABIC, "arab" );
        putScriptTag ( tm, cm, SCRIPT_GREEK, "grek" );
        putScriptTag ( tm, cm, SCRIPT_LATIN, "latn" );
        putScriptTag ( tm, cm, SCRIPT_CYRILLIC, "cyrl" );
        putScriptTag ( tm, cm, SCRIPT_GEORGIAN, "geor" );
        putScriptTag ( tm, cm, SCRIPT_BOPOMOFO, "bopo" );
        putScriptTag ( tm, cm, SCRIPT_HANGUL, "hang" );
        putScriptTag ( tm, cm, SCRIPT_GURMUKHI, "guru" );
        putScriptTag ( tm, cm, SCRIPT_GURMUKHI_2, "gur2" );
        putScriptTag ( tm, cm, SCRIPT_DEVANAGARI, "deva" );
        putScriptTag ( tm, cm, SCRIPT_DEVANAGARI_2, "dev2" );
        putScriptTag ( tm, cm, SCRIPT_GUJARATI, "gujr" );
        putScriptTag ( tm, cm, SCRIPT_GUJARATI_2, "gjr2" );
        putScriptTag ( tm, cm, SCRIPT_BENGALI, "beng" );
        putScriptTag ( tm, cm, SCRIPT_BENGALI_2, "bng2" );
        putScriptTag ( tm, cm, SCRIPT_ORIYA, "orya" );
        putScriptTag ( tm, cm, SCRIPT_ORIYA_2, "ory2" );
        putScriptTag ( tm, cm, SCRIPT_TIBETAN, "tibt" );
        putScriptTag ( tm, cm, SCRIPT_TELUGU, "telu" );
        putScriptTag ( tm, cm, SCRIPT_TELUGU_2, "tel2" );
        putScriptTag ( tm, cm, SCRIPT_KANNADA, "knda" );
        putScriptTag ( tm, cm, SCRIPT_KANNADA_2, "knd2" );
        putScriptTag ( tm, cm, SCRIPT_TAMIL, "taml" );
        putScriptTag ( tm, cm, SCRIPT_TAMIL_2, "tml2" );
        putScriptTag ( tm, cm, SCRIPT_MALAYALAM, "mlym" );
        putScriptTag ( tm, cm, SCRIPT_MALAYALAM_2, "mlm2" );
        putScriptTag ( tm, cm, SCRIPT_SINHALESE, "sinh" );
        putScriptTag ( tm, cm, SCRIPT_BURMESE, "mymr" );
        putScriptTag ( tm, cm, SCRIPT_THAI, "thai" );
        putScriptTag ( tm, cm, SCRIPT_KHMER, "khmr" );
        putScriptTag ( tm, cm, SCRIPT_LAO, "laoo" );
        putScriptTag ( tm, cm, SCRIPT_HIRAGANA, "hira" );
        putScriptTag ( tm, cm, SCRIPT_ETHIOPIC, "ethi" );
        putScriptTag ( tm, cm, SCRIPT_HAN, "hani" );
        putScriptTag ( tm, cm, SCRIPT_KATAKANA, "kana" );
        putScriptTag ( tm, cm, SCRIPT_MATH, "zmth" );
        putScriptTag ( tm, cm, SCRIPT_SYMBOL, "zsym" );
        putScriptTag ( tm, cm, SCRIPT_UNDETERMINED, "zyyy" );
        putScriptTag ( tm, cm, SCRIPT_UNCODED, "zzzz" );
        scriptTagsMap = tm;
        scriptCodeMap = cm;
    }

    private static Map<Integer,String> getScriptTagsMap() {
        if ( scriptTagsMap == null ) {
            makeScriptMaps();
        }
        return scriptTagsMap;
    }

    private static Map<String,Integer> getScriptCodeMap() {
        if ( scriptCodeMap == null ) {
            makeScriptMaps();
        }
        return scriptCodeMap;
    }

    /**
     * Mirror characters that are designated as having the bidi mirrorred property.
     * @param s a string whose characters are to be mirrored
     * @return the resulting string
     */
    public static String mirror ( String s ) {
        StringBuffer sb = new StringBuffer ( s );
        for ( int i = 0, n = sb.length(); i < n; i++ ) {
            sb.setCharAt ( i, (char) mirror ( sb.charAt ( i ) ) );
        }
        return sb.toString();
    }

    private static int[] mirroredCharacters = {
        0x0028,
        0x0029,
        0x003C,
        0x003E,
        0x005B,
        0x005D,
        0x007B,
        0x007D,
        0x00AB,
        0x00BB,
        0x0F3A,
        0x0F3B,
        0x0F3C,
        0x0F3D,
        0x169B,
        0x169C,
        0x2039,
        0x203A,
        0x2045,
        0x2046,
        0x207D,
        0x207E,
        0x208D,
        0x208E,
        0x2208,
        0x2209,
        0x220A,
        0x220B,
        0x220C,
        0x220D,
        0x2215,
        0x223C,
        0x223D,
        0x2243,
        0x2252,
        0x2253,
        0x2254,
        0x2255,
        0x2264,
        0x2265,
        0x2266,
        0x2267,
        0x2268,
        0x2269,
        0x226A,
        0x226B,
        0x226E,
        0x226F,
        0x2270,
        0x2271,
        0x2272,
        0x2273,
        0x2274,
        0x2275,
        0x2276,
        0x2277,
        0x2278,
        0x2279,
        0x227A,
        0x227B,
        0x227C,
        0x227D,
        0x227E,
        0x227F,
        0x2280,
        0x2281,
        0x2282,
        0x2283,
        0x2284,
        0x2285,
        0x2286,
        0x2287,
        0x2288,
        0x2289,
        0x228A,
        0x228B,
        0x228F,
        0x2290,
        0x2291,
        0x2292,
        0x2298,
        0x22A2,
        0x22A3,
        0x22A6,
        0x22A8,
        0x22A9,
        0x22AB,
        0x22B0,
        0x22B1,
        0x22B2,
        0x22B3,
        0x22B4,
        0x22B5,
        0x22B6,
        0x22B7,
        0x22C9,
        0x22CA,
        0x22CB,
        0x22CC,
        0x22CD,
        0x22D0,
        0x22D1,
        0x22D6,
        0x22D7,
        0x22D8,
        0x22D9,
        0x22DA,
        0x22DB,
        0x22DC,
        0x22DD,
        0x22DE,
        0x22DF,
        0x22E0,
        0x22E1,
        0x22E2,
        0x22E3,
        0x22E4,
        0x22E5,
        0x22E6,
        0x22E7,
        0x22E8,
        0x22E9,
        0x22EA,
        0x22EB,
        0x22EC,
        0x22ED,
        0x22F0,
        0x22F1,
        0x22F2,
        0x22F3,
        0x22F4,
        0x22F6,
        0x22F7,
        0x22FA,
        0x22FB,
        0x22FC,
        0x22FD,
        0x22FE,
        0x2308,
        0x2309,
        0x230A,
        0x230B,
        0x2329,
        0x232A,
        0x2768,
        0x2769,
        0x276A,
        0x276B,
        0x276C,
        0x276D,
        0x276E,
        0x276F,
        0x2770,
        0x2771,
        0x2772,
        0x2773,
        0x2774,
        0x2775,
        0x27C3,
        0x27C4,
        0x27C5,
        0x27C6,
        0x27C8,
        0x27C9,
        0x27D5,
        0x27D6,
        0x27DD,
        0x27DE,
        0x27E2,
        0x27E3,
        0x27E4,
        0x27E5,
        0x27E6,
        0x27E7,
        0x27E8,
        0x27E9,
        0x27EA,
        0x27EB,
        0x27EC,
        0x27ED,
        0x27EE,
        0x27EF,
        0x2983,
        0x2984,
        0x2985,
        0x2986,
        0x2987,
        0x2988,
        0x2989,
        0x298A,
        0x298B,
        0x298C,
        0x298D,
        0x298E,
        0x298F,
        0x2990,
        0x2991,
        0x2992,
        0x2993,
        0x2994,
        0x2995,
        0x2996,
        0x2997,
        0x2998,
        0x29B8,
        0x29C0,
        0x29C1,
        0x29C4,
        0x29C5,
        0x29CF,
        0x29D0,
        0x29D1,
        0x29D2,
        0x29D4,
        0x29D5,
        0x29D8,
        0x29D9,
        0x29DA,
        0x29DB,
        0x29F5,
        0x29F8,
        0x29F9,
        0x29FC,
        0x29FD,
        0x2A2B,
        0x2A2C,
        0x2A2D,
        0x2A2E,
        0x2A34,
        0x2A35,
        0x2A3C,
        0x2A3D,
        0x2A64,
        0x2A65,
        0x2A79,
        0x2A7A,
        0x2A7D,
        0x2A7E,
        0x2A7F,
        0x2A80,
        0x2A81,
        0x2A82,
        0x2A83,
        0x2A84,
        0x2A8B,
        0x2A8C,
        0x2A91,
        0x2A92,
        0x2A93,
        0x2A94,
        0x2A95,
        0x2A96,
        0x2A97,
        0x2A98,
        0x2A99,
        0x2A9A,
        0x2A9B,
        0x2A9C,
        0x2AA1,
        0x2AA2,
        0x2AA6,
        0x2AA7,
        0x2AA8,
        0x2AA9,
        0x2AAA,
        0x2AAB,
        0x2AAC,
        0x2AAD,
        0x2AAF,
        0x2AB0,
        0x2AB3,
        0x2AB4,
        0x2AC3,
        0x2AC4,
        0x2AC5,
        0x2AC6,
        0x2ACD,
        0x2ACE,
        0x2ACF,
        0x2AD0,
        0x2AD1,
        0x2AD2,
        0x2AD3,
        0x2AD4,
        0x2AD5,
        0x2AD6,
        0x2ADE,
        0x2AE3,
        0x2E02,
        0x2E03,
        0x2E04,
        0x2E05,
        0x2E09,
        0x2E0A,
        0x2E0C,
        0x2E0D,
        0x2E1C,
        0x2E1D,
        0x2E20,
        0x2E21,
        0x2E22,
        0x2E23,
        0x2E24,
        0x2E25,
        0x2E26,
        0x300E,
        0x300F,
        0x3010,
        0x3011,
        0x3014,
        0x3015,
        0x3016,
        0x3017,
        0x3018,
        0x3019,
        0x301A,
        0x301B,
        0xFE59,
        0xFE5A,
        0xFF3B,
        0xFF3D,
        0xFF5B,
        0xFF5D,
        0xFF5F,
        0xFF60,
        0xFF62,
        0xFF63
    };

    private static int[] mirroredCharactersMapping = {
        0x0029,
        0x0028,
        0x003E,
        0x003C,
        0x005D,
        0x005B,
        0x007D,
        0x007B,
        0x00BB,
        0x00AB,
        0x0F3B,
        0x0F3A,
        0x0F3D,
        0x0F3C,
        0x169C,
        0x169B,
        0x203A,
        0x2039,
        0x2046,
        0x2045,
        0x207E,
        0x207D,
        0x208E,
        0x208D,
        0x220B,
        0x220C,
        0x220D,
        0x2208,
        0x2209,
        0x220A,
        0x29F5,
        0x223D,
        0x223C,
        0x22CD,
        0x2253,
        0x2252,
        0x2255,
        0x2254,
        0x2265,
        0x2264,
        0x2267,
        0x2266,
        0x2269,
        0x2268,
        0x226B,
        0x226A,
        0x226F,
        0x226E,
        0x2271,
        0x2270,
        0x2273,
        0x2272,
        0x2275,
        0x2274,
        0x2277,
        0x2276,
        0x2279,
        0x2278,
        0x227B,
        0x227A,
        0x227D,
        0x227C,
        0x227F,
        0x227E,
        0x2281,
        0x2280,
        0x2283,
        0x2282,
        0x2285,
        0x2284,
        0x2287,
        0x2286,
        0x2289,
        0x2288,
        0x228B,
        0x228A,
        0x2290,
        0x228F,
        0x2292,
        0x2291,
        0x29B8,
        0x22A3,
        0x22A2,
        0x2ADE,
        0x2AE4,
        0x2AE3,
        0x2AE5,
        0x22B1,
        0x22B0,
        0x22B3,
        0x22B2,
        0x22B5,
        0x22B4,
        0x22B7,
        0x22B6,
        0x22CA,
        0x22C9,
        0x22CC,
        0x22CB,
        0x2243,
        0x22D1,
        0x22D0,
        0x22D7,
        0x22D6,
        0x22D9,
        0x22D8,
        0x22DB,
        0x22DA,
        0x22DD,
        0x22DC,
        0x22DF,
        0x22DE,
        0x22E1,
        0x22E0,
        0x22E3,
        0x22E2,
        0x22E5,
        0x22E4,
        0x22E7,
        0x22E6,
        0x22E9,
        0x22E8,
        0x22EB,
        0x22EA,
        0x22ED,
        0x22EC,
        0x22F1,
        0x22F0,
        0x22FA,
        0x22FB,
        0x22FC,
        0x22FD,
        0x22FE,
        0x22F2,
        0x22F3,
        0x22F4,
        0x22F6,
        0x22F7,
        0x2309,
        0x2308,
        0x230B,
        0x230A,
        0x232A,
        0x2329,
        0x2769,
        0x2768,
        0x276B,
        0x276A,
        0x276D,
        0x276C,
        0x276F,
        0x276E,
        0x2771,
        0x2770,
        0x2773,
        0x2772,
        0x2775,
        0x2774,
        0x27C4,
        0x27C3,
        0x27C6,
        0x27C5,
        0x27C9,
        0x27C8,
        0x27D6,
        0x27D5,
        0x27DE,
        0x27DD,
        0x27E3,
        0x27E2,
        0x27E5,
        0x27E4,
        0x27E7,
        0x27E6,
        0x27E9,
        0x27E8,
        0x27EB,
        0x27EA,
        0x27ED,
        0x27EC,
        0x27EF,
        0x27EE,
        0x2984,
        0x2983,
        0x2986,
        0x2985,
        0x2988,
        0x2987,
        0x298A,
        0x2989,
        0x298C,
        0x298B,
        0x2990,
        0x298F,
        0x298E,
        0x298D,
        0x2992,
        0x2991,
        0x2994,
        0x2993,
        0x2996,
        0x2995,
        0x2998,
        0x2997,
        0x2298,
        0x29C1,
        0x29C0,
        0x29C5,
        0x29C4,
        0x29D0,
        0x29CF,
        0x29D2,
        0x29D1,
        0x29D5,
        0x29D4,
        0x29D9,
        0x29D8,
        0x29DB,
        0x29DA,
        0x2215,
        0x29F9,
        0x29F8,
        0x29FD,
        0x29FC,
        0x2A2C,
        0x2A2B,
        0x2A2E,
        0x2A2D,
        0x2A35,
        0x2A34,
        0x2A3D,
        0x2A3C,
        0x2A65,
        0x2A64,
        0x2A7A,
        0x2A79,
        0x2A7E,
        0x2A7D,
        0x2A80,
        0x2A7F,
        0x2A82,
        0x2A81,
        0x2A84,
        0x2A83,
        0x2A8C,
        0x2A8B,
        0x2A92,
        0x2A91,
        0x2A94,
        0x2A93,
        0x2A96,
        0x2A95,
        0x2A98,
        0x2A97,
        0x2A9A,
        0x2A99,
        0x2A9C,
        0x2A9B,
        0x2AA2,
        0x2AA1,
        0x2AA7,
        0x2AA6,
        0x2AA9,
        0x2AA8,
        0x2AAB,
        0x2AAA,
        0x2AAD,
        0x2AAC,
        0x2AB0,
        0x2AAF,
        0x2AB4,
        0x2AB3,
        0x2AC4,
        0x2AC3,
        0x2AC6,
        0x2AC5,
        0x2ACE,
        0x2ACD,
        0x2AD0,
        0x2ACF,
        0x2AD2,
        0x2AD1,
        0x2AD4,
        0x2AD3,
        0x2AD6,
        0x2AD5,
        0x22A6,
        0x22A9,
        0x2E03,
        0x2E02,
        0x2E05,
        0x2E04,
        0x2E0A,
        0x2E09,
        0x2E0D,
        0x2E0C,
        0x2E1D,
        0x2E1C,
        0x2E21,
        0x2E20,
        0x2E23,
        0x2E22,
        0x2E25,
        0x2E24,
        0x2E27,
        0x300F,
        0x300E,
        0x3011,
        0x3010,
        0x3015,
        0x3014,
        0x3017,
        0x3016,
        0x3019,
        0x3018,
        0x301B,
        0x301A,
        0xFE5A,
        0xFE59,
        0xFF3D,
        0xFF3B,
        0xFF5D,
        0xFF5B,
        0xFF60,
        0xFF5F,
        0xFF63,
        0xFF62
    };

    private static int mirror ( int c ) {
        int i = Arrays.binarySearch ( mirroredCharacters, c );
        if ( i < 0 ) {
            return c;
        } else {
            return mirroredCharactersMapping [ i ];
        }
    }

    /**
     * Determine if two character sequences contain the same characters.
     * @param cs1 first character sequence
     * @param cs2 second character sequence
     * @return true if both sequences have same length and same character sequence
     */
    public static boolean isSameSequence ( CharSequence cs1, CharSequence cs2 ) {
        assert cs1 != null;
        assert cs2 != null;
        if ( cs1.length() != cs2.length() ) {
            return false;
        } else {
            for ( int i = 0, n = cs1.length(); i < n; i++ ) {
                if ( cs1.charAt(i) != cs2.charAt(i) ) {
                    return false;
                }
            }
            return true;
        }
    }

    /**
     * Convert Java string (UTF-16) to a Unicode scalar array (UTF-32).
     * Note that if there are any non-BMP encoded characters present in the
     * input, then the number of entries in the output array will be less
     * than the number of elements in the input string. Any 
     * @param s input string
     * @param substitution value to substitute for ill-formed surrogate
     * @param errorOnSubstitution throw runtime exception (IllegalArgumentException) in
     * case this argument is true and a substitution would be attempted
     * @return output scalar array
     * @throws IllegalArgumentException if substitution required and errorOnSubstitution
     *   is not false
     */
    public static Integer[] toUTF32 ( String s, int substitution, boolean errorOnSubstitution )
        throws IllegalArgumentException {
        int n;
        if ( ( n = s.length() ) == 0 ) {
            return new Integer[0];
        } else {
            Integer[] sa = new Integer [ n ];
            int k = 0;
            for ( int i = 0; i < n; i++ ) {
                int c = (int) s.charAt(i);
                if ( ( c >= 0xD800 ) && ( c < 0xE000 ) ) {
                    int s1 = c;
                    int s2 = ( ( i + 1 ) < n ) ? (int) s.charAt ( i + 1 ) : 0;
                    if ( s1 < 0xDC00 ) {
                        if ( ( s2 >= 0xDC00 ) && ( s2 < 0xE000 ) ) {
                            c = ( ( s1 - 0xD800 ) << 10 ) + ( s2 - 0xDC00 ) + 65536;
                            i++;
                        } else {
                            if ( errorOnSubstitution ) {
                                throw new IllegalArgumentException
                                    ( "isolated high (leading) surrogate" );
                            } else {
                                c = substitution;
                            }
                        }
                    } else {
                        if ( errorOnSubstitution ) {
                            throw new IllegalArgumentException
                                ( "isolated low (trailing) surrogate" );
                        } else {
                            c = substitution;
                        }
                    }
                }
                sa[k++] = c;
            }
            if ( k == n ) {
                return sa;
            } else {
                Integer[] na = new Integer [ k ];
                System.arraycopy ( sa, 0, na, 0, k );
                return na;
            }
        }
    }

    /**
     * Convert a Unicode scalar array (UTF-32) a Java string (UTF-16).
     * @param sa input scalar array
     * @return output (UTF-16) string
     * @throws IllegalArgumentException if an input scalar value is illegal,
     *   e.g., a surrogate or out of range
     */
    public static String fromUTF32 ( Integer[] sa ) throws IllegalArgumentException {
        StringBuffer sb = new StringBuffer();
        for ( int s : sa ) {
            if ( s < 65535 ) {
                if ( ( s < 0xD800 ) || ( s > 0xDFFF ) ) {
                    sb.append ( (char) s );
                } else {
                    String ncr = charToNCRef(s);
                    throw new IllegalArgumentException
                        ( "illegal scalar value 0x" + ncr.substring(2,ncr.length() - 1)
                          + "; cannot be UTF-16 surrogate" );
                }
            } else if ( s < 1114112 ) {
                int s1 = ( ( ( s - 65536 ) >> 10 ) & 0x3FF ) + 0xD800;
                int s2 = ( ( ( s - 65536 ) >>  0 ) & 0x3FF ) + 0xDC00;
                sb.append ( (char) s1 );
                sb.append ( (char) s2 );
            } else {
                String ncr = charToNCRef(s);
                throw new IllegalArgumentException
                    ( "illegal scalar value 0x" + ncr.substring(2,ncr.length() - 1)
                      + "; out of range for UTF-16"  );
            }
        }
        return sb.toString();
    }
}