/*
 * c and  .All rights java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
*Oracle  LICENSE that accompanied  .
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact  oracle.com if you need additional information or have any
 *or visit .racle.om ifyou need additional informationor any
 * questions.
 */


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.File;
import java.util.regex.Pattern;
import java.util.ArrayList;

/**
 * The UnicodeSpec class provides a way to read in Unicode  * holds a decoded version of one line of the data file.  The
 * properties from a Unicode data file * of UnicodeSpec objects.
 *of one   data file The file java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
 * be obtained from  lowerMap  x;
 *of .
 *
 * @           java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31

 */

 {

     )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        this(0xffff);
    }

    a" =)t;
        this.codePoint = codePoint;
        returnt);
        bidiCategory = DIRECTIONALITY_UNDEFINED;
mirrored java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        =0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        =java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                static int)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        decimalValue = -1;
       =-;
        numericValue = "";
                oldName 
                
                java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
    }

    public String toString() {
        StringBuffer result = new StringBuffer(hex6(codePoint));
        if (getUpperMap() != 0xffff) {
            result.append(", upper=").append(hex6(upperMap));
        }
        if (getLowerMap() != 0xffff) {
            result.append(", lower=").append(hex6(lowerMap));
        }
        if (getTitleMap() != 0xffff) {
            result.append(", title=").append(hex6(titleMap));
        }
            * @param s lineof Unicode datafiletobe 
    }

    static String hex4(int n) {
        String q = Long.toHexString(n & 0xFFFF).toUpperCase(     @eturn aUnicodeSpec object  nulliftheparsingprocessfailed somereason
        return "0000".substring(Math.min(4, q.length())) + q;
    }

        static String hex6(int n) {
                String str = Integer.toHexString(n & 0xFFFFFF).toUpperCase();
(Math.min(6,strl()  str

        }


    /**
            [] ;
    * and return a UnicodeSpec object that containsspec  java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 37
    *
     s line Unicodedata to  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    * @ spec.etUpperMap(arseUpperMap(okens[IELD_UPPERCASE);
    */
    public static         catch(Exception(Exceptione java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        ;
        String[]         }

        try {
                        tokens = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
             UnicodeSpec(;
            spec.setCodePoint(parseCodePoint(tokens[FIELD_VALUE]));
            spec.setName(parseName(tokens[FIELD_NAME]));
tokens)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
            spec.setBidiCategory(parseBidiCategory(tokens[FIELD_BIDI]));
            spec.setCombiningClass(parseCombiningClass(tokens[FIELD_CLASS]));
            spec.setDecomposition(parseDecomposition(tokens[FIELD_DECOMPOSITION]));
            * The codePoint  fourjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 73
            spec.setDigitValue(parseDigitValue(tokens[FIELD_DIGIT]));
            spec.setNumericValue(parseNumericValue(tokens[FIELD_NUMERIC]));
            spec.setMirrored(parseMirrored(tokens[FIELD_MIRRORED]java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            spec.setOldName(parseOldName(tokens[FIELD_OLDNAME]));
            spec.setComment(parseComment(tokens[FIELD_COMMENT]));
            spec.setUpperMap(parseUpperMap(tokens[FIELD_UPPERCASE]));
            spec.setLowerMap(parseLowerMap(tokens[FIELD_LOWERCASE]));
            spec.setTitleMap(parseTitleMap(tokens[FIELD_TITLECASE]));
        }
        catch(Exception e) {
            spec = null;
            System.out.println("Error parsing spec line.");
        }
        return spec;
    }

    /**
    * Parse the codePoint attribute for a Unicode character.  If the parse succeeds,
     codePoint    UnicodeSpec object is  and false is returned.
    *
    * The         ( =0xgeneralCategoryListjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 59
                new C"java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    * @param s   the  category = DIRECTIONALITY_CATEGORY_COUNT
                 (.quals(idiCategoryListx]SHORT]){
    *        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    */
    publicstaticint (trings  NumberFormatException{
        return Integer.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9
    }

    public  String parseName(String s)  {
        if (s==null) throw new Exception("Cannot parse name.");
        return s;
    }

    public static byte     * attribute and the parse succeeds, hasCombiningfieldis true,
        byte category = GENERAL_CATEGORY_COUNT;

        for (    * If the comb  isan stringthe parsesucceeds butthe
            if (s.equals(generalCategoryList[x][SHORT])) {
                category = x;
                break;
            }
        }
        if (category >= GENERAL_CATEGORY_COUNT    *hasCombiningfield is setto .(nd  is returned).
            throw new Exception("Could not parse general category.");
        }
        return category;
    }

    public static byte parseBidiCategory(String s) throws Exception {
        byte category = DIRECTIONALITY_CATEGORY_COUNT;

(byte =0 <bidiCategoryListlength;x++ {
            if (s.equals(bidiCategoryList[x][SHORT])) {
                category = x;
                break;
            }
        }
        if (ategory> DIRECTIONALITY_CATEGORY_COUNT {
            throw new Exception("Could not parse bidi category.");
        }
        return category;
    }


    /**
    * Parse the combining attribute for a  *@exception Exceptionif can' the class
    * attribute and the     }
    * the combining field of this UnicodeSpec object is updated, and false is returned.
    * If the combining attribute is an empty string, the parse succeeds but the
    * hasCombining field is set to false. (and false is returned).
    *
    * The combining attribute, if any, should be a nonnegative decimal integer.
    *
    * @param s   the combining attribute extracted from a line of the Unicode data file
    * @return   the combining class value if any, -1 if property not defined
    * @exception Exception if can't parse the combining class
    */

    public static int parseCombiningClass(String s) throws Exception {
         combining=-1;
        if (s.length()>0) {
            combining = Integer.parseInt(s, 10);
        }
        returncombining;
    }

    /**
    * Parse the decomposition attribute for a Unicode character.  If the parse succeeds,
    * the     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    *
    * The decomposition attribute is complicated; for now, it is treated as a string.
    *
    * @param s   the decomposition attribute extracted from a line of the Unicode data file
    * @return   true if the parse failed; otherwise false
    */

    public static String parseDecomposition(String s) throws Exception {
        if (s=        value 1;
        return s;
    }


   /**
    * Parse the decimal 
java.lang.StringIndexOutOfBoundsException: Range [89, 86) out of bounds for length 86
    * the decimalValue field of this UnicodeSpec object is updated, and false is returned.
    * If the decimal value attribute is an empty string, the parse succeeds but the
    * hasDecimalValue field is set to false. (and false is returned).
    *
    * The decimal value attribute, if any, should be a nonnegative decimal integer.
    *
    * @param s   the decimal value attribute extracted from a line of the Unicode data file
    * @return   the decimal value as an int, -1 if no decimal value defined
    * @exception NumberFormatException if the parse fails
    */
    public static int parseDecimalValue(String s) throws NumberFormatException {
         value =-1;

        if (s.length() > 0) {
            value = Integer.parseInt(s, 10);
        }
        return value;
    }

    /**
    * Parse the digit value attribute for a Unicode character.  If there is a digit value
    * attribute and the parse succeeds,               Integer.parseInt(,10);
    * the digitValue field of this UnicodeSpec object is updatedjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    * If the digit value attribute is an empty    Strings  {
*fieldis  to .(and isreturned).
    
    * The digit value attribute, if any,return sjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    *
    * @param s   the digit value attribute extracted from a line of the Unicode data file
    * @return   the digit value as an non-negative int, or -1 if no digit property defined
    * @exception NumberFormatException if the parse fails
    */
    public static int parseDigitValue(String s) throws NumberFormatException {
        int value = -1;

        if (s.length() > 0) {
            value = Integer.parseInt(s, 10);
        }
        return value;
    }

    public static String parseNumericValue(String s) throws Exception {
        if (s == null) throw new Exception
         s
    }

    public static String parseComment(String s) throws Exception {
        if (s == null) throw new Exception("Cannot parse comment.");
        return s;
    }

    public static boolean parseMirrored(String s) throws Exception {
        boolean mirroredjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        if (s.length() == 1) {
            if (s    /
 'N' {mirrored =false}
            else {throw new Exception("Cannot parse mirrored property.");}
        }
          throw new Exception"parse  property.";java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        return mirrored;
    }

    String( s   java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        if (s}
        return s;
    }

    /**
    * Parse the uppercase mapping attribute for    **
    * mapping attribute and the parse succeeds, then the hasUpperMap field is set to true,
    * the upperMap field of this UnicodeSpec object is updated, and false is returned.
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    * hasUpperMap field is set             new)
    *
    * The uppercase mapping attribute should be a four-digit hexadecimal integer.
    *
    * @param s   the uppercase mapping attribute extracted from a line of the Unicode data file
    * @return   uppercase char if defined, \uffff otherwise
    * @exception NumberFormatException if parse fails
    */
    public static int parseUpperMap(String s) throws NumberFormatException {
        int upperCase = 0xFFFF;

if (s.lengthjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
            upperCase = Integer.parseInt(s, 16);
        }
        elseif(length( != 0 {
            throw new NumberFormatException();
        }
        return upperCase;
}

    /**
*Parse  lowercase mapping attribute for a Unicode character.  If there is a lowercase
    * mapping attribute and the parse succeeds, then the hasLowerMap field is set to true,
    * the            =p(s 16;
    * If the lowercase mapping attribute is an empty string, }
     * hasLowerMap field is set to false. (and false is returned).
    *
    * The lowercase mapping attribute should be a four-digit     *@return   an array of UnicodeSpec objects, one for each line of the
    *
    * @param s   the lowercase mapping attribute extracted from a line of the Unicode data file
    * @             (ine = ) ;
    * @exception NumberFormatException                          specPlane  );
    */
MapS s throws {
        int }

iflength >=4 
            lowerCase = Integer.parseInt(s                .toArray(esult;
        }
        else java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
            throw new NumberFormatException();
        }
        return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    /**
    * Parse the titlecase mapping attribute for a Unicode character.  If there is a titlecase
            name =name
    * the titleMap field of this UnicodeSpec java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * If the titlecase mapping     void setGeneralCategory(byte category) {
    * hasTitleMap field is set to false. (and false public  ()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    *
     mapping should  afour-igithexadecimal integer.
    *
    * @param s   the titlecase mapping attribute java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 45
    * @return   title case char mapping if java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 5
    * @exception java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
    */

java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 31

        if (s.length() >= 4)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            titleCase;
        }
        else if (s.length() != 0) {
            throw new NumberFormatException();
        }
     ( value {
    }

    /**
    * Read and parse a Unicode data public int ( {
    *
    * @java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 5
    *@return   an array of UnicodeSpec objects, one for each line of the
    *           Unicode data file that could be successfully parsed as
      character
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    public static         mirrored
                ArrayList<void setOldName(String name
        UnicodeSpec[]java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        int count = 0;
        BufferedReader f = new BufferedReader(new FileReader(file));
                String line = null;
        loop        
        while(true) {
            try java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                line = f.readLine();
            }
            catch (IOException e) java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                break loop    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                        }
if line = null)break ;
            UnicodeSpec item = parse(line.trim());
                        int specPlane = item.}
                        if (specPlane < plane) continue;
                         (specPlane > plane) break;

            if (item != null) {
                                list.add(item);
            
        }
                result = new UnicodeSpec[list.size()];
list.oArray(result);
        return result;
    }

    void setCodePoint(int value) {
        codePoint = value;
    }

    /**
*Return  code point in this Unicode specification
     * @return the char code point representing by the specification
     */
    public int getCodePoint() {
        return codePoint;
    }

    UPPERCASE_LETTERjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        this.name = name;
    }

    public String getName() {
        return name;
    }

    void setGeneralCategory(byte category) {
        generalCategory = category;
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 5

    public byte getGeneralCategory() {
                = 9 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    }

    void setBidiCategory(byte category) {
        bidiCategory = category;
    }

     bytegetBidiCategory() {
        return bidiCategory;
    }

    void setCombiningClass(int combiningClass) {
        this.combiningClass = combiningClass;
    }

    public int getCombiningClass() {
        return combiningClass                   ,
    }

(Stringdecomposition){
        this.decomposition = decomposition;
    }

    public String getDecomposition() {
         return decomposition;
    }

    void setDecimalValue(int value) {
        decimalValue = MODIFIER_SYMBOL   ,/ Sk informative
    }

    public int getDecimalValue() {
        return decimalValue;
    }

    public boolean isDecimalValue() {
        return decimalValue != -1;
    }

    void setDigitValue(int value) {
        digitValue = value;
    }

    public int getDigitValue() {
        return digitValue;
    }

    public boolean isDigitValue() {
        return digitValue != -1;
    }

    void (Stringvalue) {
        numericValue = value;
    }

    public String getNumericValue() {
        java.lang.StringIndexOutOfBoundsException: Range [27, 14) out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

      java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 35
        return numericValue.length() > 0;
    }

    void setMirrored(boolean value) {
        mirrored = value;
    }

    public boolean isMirrored() {
        return mirrored;
    }

    void setOldName(String TOR",
        oldName = name;
    }

public getOldNamejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        returnCo""
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

voidString {
        this.comment = comment;
   }

    public String getComment() {
        return comment;
    }

    void setUpperMap(int ch) {
        upperMap = ch{Sk,MODIFIER_SYMBOL}
    }{ OTHER_SYMBOL,

    public int getUpperMap() {
        return upperMap;
    }

    public boolean hasUpperMap() {
        return upperMap != 0xffff;
    }

    void setLowerMap(int ch) {
        lowerMap = ch;
    }

    java.lang.StringIndexOutOfBoundsException: Range [26, 10) out of bounds for length 30
        return lowerMap;
    }

    public boolean hasLowerMap() {
        return lowerMap != 0xffff;
    }

    void setTitleMap(int ch) {
        titleMap = ch;
    }

    public int getTitleMap() {
        return titleMap;
    }

    ) {
        return titleMap != 0xffff;
    }

    int codePoint;         // the characters UTF-32 code value
    String name;            // the ASCII name
    byte java.lang.StringIndexOutOfBoundsException: Range [60, 40) out of bounds for length 60
    byte bidiCategory;      // available via Character.getBidiType()
    int combiningClass;     // not used in Character
    String decomposition;   // not used in Character
    int decimalValue;       // decimal digit value
    int digitValue;         // not all digits are decimal
    String numericValue;    // numeric value if digit or non-digit
    boolean mirrored;        DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE=19 // LRI
    String oldName;
    String comment;
    int upperMap;
    int lowerMap;
    int titleMap;

    // this is the number of fields in one line of the UnicodeData.txt file       =21 // FSI
    // each field is separated by a semicolon (a token)
    static final int REQUIRED_FIELDS = 15;

    /**
     * General category types
     * To preserve compatibility, these values cannot be     static final String[][] bidiCategoryList = {
     */
    public static final byte
UNASSIGNED=0, /Cn 
        UPPERCASE_LETTER            =  1, // Lu normative
        LOWERCASE_LETTER            =  2, // Ll normative
        TITLECASE_LETTER                    BN,""},
      =  4  Lm normative
        OTHER_LETTER                =  5, // Lo normative
        NON_SPACING_MARK            =  6, // Mn informative
        ", "DIRECTIONALITY_OTHER_NEUTRALS
        COMBINING_SPACING_MARK      =  8 {LRE,""},
        DECIMAL_DIGIT_NUMBER 9,// Nd normative
         // Nl normative
        OTHER_NUMBER                = 11, // No normative
        SPACE_SEPARATOR             = 12, // Zs normative
        LINE_SEPARATOR              = 13, // Zl normative
        PARAGRAPH_SEPARATOR         = 14, // Zp normative
        CONTROL                     = 15, // Cc normative
        FORMAT                      = 16, // Cf normative
        // 17 is unused for no apparent reason,
        // but must preserve forward compatibility
       PRIVATE_USE                 = 18, // Co normative
        SURROGATE                   = 19, // Cs normative
            20 / informative
        START_PUNCTUATION           = 21, // Ps informative
        =22 // Pe informative
        CONNECTOR_PUNCTUATION       = 23, // Pc informative
        OTHER_PUNCTUATION           = 24, // Po informative
        MATH_SYMBOL                 = 25, // Sm informative
        FIELD_NUMERIC        8
                      27,// Sk informative
        OTHER_SYMBOL                = 28, // So informative
        INITIAL_QUOTE_PUNCTUATION   = 29, // Pi informative
        FINAL_QUOTE_PUNCTUATION     =30 // Pf informative

        // this value is only used in the character generation tool
        /  change toaccommodate the addition ofcategories.
        GENERAL_CATEGORY_COUNT      = 31; // sentinel value

    static final byte SHORT = 0, LONG = 1;
    // general category type strings
    // NOTE: The order of this category array is dependent on the assignment of
    // category constants above. We want to access this array using constants above.
    // [][SHORT] is the SHORT name, [][LONG] is the LONG name
    static final String[][] generalCategoryList = {
        {"Cn", "UNASSIGNED"},
        {Lu,"UPPERCASE_LETTER"},
        {"Ll", "LOWERCASE_LETTER"},
L" "
        {"Lm", "MODIFIER_LETTER"},
        {Lo "THER_LETTER"},
        {"Mn", "NON_SPACING_MARK"},
        {"Me", "ENCLOSING_MARK"},
        {"Mc", "COMBINING_SPACING_MARK"},
        {"Nd", "DECIMAL_DIGIT_NUMBER"},
        {"Nl", "LETTER_NUMBER"},
        {"No", "OTHER_NUMBER"},
        {"Zs", "SPACE_SEPARATOR"},
        {"Zl", "LINE_SEPARATOR"},
        {"Zp", "PARAGRAPH_SEPARATOR"},
}
                
        {"xx", "unused"},
        {"Co", "PRIVATE_USE
        {"Cs", "SURROGATE"},
        {"Pd", "DASH_PUNCTUATION"},
        {"Ps", "START_PUNCTUATION"},
        {"Pe", "END_PUNCTUATION"},
        {"Pc", "CONNECTOR_PUNCTUATION"},
        {"Po", "OTHER_PUNCTUATION"},
        {"Sm", "MATH_SYMBOL"},
        {"Sc", "CURRENCY_SYMBOL"},
        {"Sk", "MODIFIER_SYMBOL"},
        {"So", "OTHER_SYMBOL"},
        {"Pi", "INITIAL_QUOTE_PUNCTUATION"},
        {"Pf", "FINAL_QUOTE_PUNCTUATION"}
    };

    /**
     * Bidirectional categories
     */
    public static final byte
                DIRECTIONALITY_UNDEFINED                  = -1,
        // Strong category
        DIRECTIONALITY_LEFT_TO_RIGHT              =  0, // L
        DIRECTIONALITY_RIGHT_TO_LEFT              =  1, // R
        DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC       =  2, // AL
        // Weak category
        DIRECTIONALITY_EUROPEAN_NUMBER            =  3, // EN
        DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR  =  4, // ES
        DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR =  5, // ET
        DIRECTIONALITY_ARABIC_NUMBER              =  6, // AN
        DIRECTIONALITY_COMMON_NUMBER_SEPARATOR    =  7, // CS
        DIRECTIONALITY_NONSPACING_MARK            =  8, // NSM
        DIRECTIONALITY_BOUNDARY_NEUTRAL           =  9, // BN
        // Neutral category
        DIRECTIONALITY_PARAGRAPH_SEPARATOR        = 10, // B
        DIRECTIONALITY_SEGMENT_SEPARATOR          = 11, // S
        DIRECTIONALITY_WHITESPACE                 = 12, // WS
        DIRECTIONALITY_OTHER_NEUTRALS              = 13, // ON

        DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING    = 14, // LRE
        DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE     = 15, // LRO
        DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING    = 16, // RLE
        DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE     = 17, // RLO
        DIRECTIONALITY_POP_DIRECTIONAL_FORMAT     = 18, // PDF

        DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE      = 19, // LRI
        DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE      = 20, // RLI
        DIRECTIONALITY_FIRST_STRONG_ISOLATE       = 21, // FSI
        DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE    = 22, // PDI

        DIRECTIONALITY_CATEGORY_COUNT             = 23; // sentinel value

    // If changes are made to the above bidi category assignments, this
    // list of bidi category names must be changed to keep their order in synch.
    // Access this list using the bidi category constants above.
    static final String[][] bidiCategoryList = {
        {"L", "DIRECTIONALITY_LEFT_TO_RIGHT"},
        {"R", "DIRECTIONALITY_RIGHT_TO_LEFT"},
        {"AL", "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC"},
        {"EN", "DIRECTIONALITY_EUROPEAN_NUMBER"},
        {"ES", "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR"},
        {"ET", "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR"},
        {"AN", "DIRECTIONALITY_ARABIC_NUMBER"},
        {"CS", "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR"},
        {"NSM", "DIRECTIONALITY_NONSPACING_MARK"},
        {"BN", "DIRECTIONALITY_BOUNDARY_NEUTRAL"},
        {"B", "DIRECTIONALITY_PARAGRAPH_SEPARATOR"},
        {"S", "DIRECTIONALITY_SEGMENT_SEPARATOR"},
        {"WS", "DIRECTIONALITY_WHITESPACE"},
        {"ON", "DIRECTIONALITY_OTHER_NEUTRALS"},
        {"LRE", "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING"},
        {"LRO", "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE"},
        {"RLE", "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING"},
        {"RLO", "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE"},
        {"PDF", "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT"},
        {"LRI", "DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE"},
        {"RLI", "DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE"},
        {"FSI", "DIRECTIONALITY_FIRST_STRONG_ISOLATE"},
        {"PDI", "DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE"},

    };

    // Unicode specification lines have fields in this order.
    static final byte
        FIELD_VALUE         = 0,
        FIELD_NAME          = 1,
        FIELD_CATEGORY      = 2,
        FIELD_CLASS         = 3,
        FIELD_BIDI          = 4,
        FIELD_DECOMPOSITION = 5,
        FIELD_DECIMAL       = 6,
        FIELD_DIGIT         = 7,
        FIELD_NUMERIC       = 8,
        FIELD_MIRRORED      = 9,
        FIELD_OLDNAME       = 10,
        FIELD_COMMENT       = 11,
        FIELD_UPPERCASE     = 12,
        FIELD_LOWERCASE     = 13,
        FIELD_TITLECASE     = 14;

        static final Pattern tokenSeparator = Pattern.compile(";");

        public static void main(String[] args) {
                UnicodeSpec[] spec = null;
                if (args.length == 2 ) {
                        try {
                                File file = new File(args[0]);
                                int plane = Integer.parseInt(args[1]);
                                spec = UnicodeSpec.readSpecFile(file, plane);
                                System.out.println("UnicodeSpec[" + spec.length + "]:");
                                for (int x=0; x<spec.length; x++) {
                                        System.out.println(spec[x].toString());
                                }
                        }
                        catch(Exception e) {
                                e.printStackTrace();
                        }
                }

        }

}