/**
*******************************************************************************
* Copyright (C) 1996-2001, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
* $Source: 
*     /usr/cvs/icu4j/icu4j/src/com/ibm/icu/text/UCharacterName.java $ 
* $Date: 2002/03/15 22:48:07 $ 
* $Revision: 1.15 $
*
*******************************************************************************
*/
package com.ibm.icu.lang;

import java.util.Locale;
import java.io.InputStream;
import java.io.DataInputStream;
import java.io.BufferedInputStream;
import java.io.IOException;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.text.UTF16;

/**
* Internal class to manage character names.
* Since data in <a href=UCharacterNameDB.html>UCharacterNameDB</a> is stored
* in an array of char, by default indexes used in this class is refering to 
* a 2 byte count, unless otherwise stated. Cases where the index is refering 
* to a byte count, the index is halved and depending on whether the index is 
* even or odd, the MSB or LSB of the result char at the halved index is 
* returned. For indexes to an array of int, the index is multiplied by 2, 
* result char at the multiplied index and its following char is returned as an 
* int.
* <a href=UCharacter.html>UCharacter</a> acts as a public facade for this class
* Note : 0 - 0x1F are control characters without names in Unicode 3.0
* Information on parsing of the binary data is located at
* <a href=oss.software.ibm.com/icu4j/icu4jhtml/com/ibm/icu/text/readme.html>
* ReadMe</a>
* @author Syn Wee Quek
* @since nov0700
*/

final class UCharacterName
{
    // public methods ----------------------------------------------------
    
    /**
    * toString method for printing
    */
    public String toString()
    {
        StringBuffer result = new StringBuffer("names content \n");
        /*result.append(super.toString());
        result.append('\n');
        result.append("token string offset ");
        result.append(m_tokenstringoffset_);
        result.append("\n");
        result.append("group offset ");
        result.append(m_groupsoffset_);
        result.append("\n");
        result.append("group string offset ");
        result.append(m_groupstringoffset_);
        result.append("\n");
        result.append("alg names offset ");
        result.append(m_algnamesoffset_);
        result.append("\n");
        */
        return result.toString();
    } 
    
    // package protected inner class -------------------------------------
    
    /**
    * Algorithmic name class
    */
    static final class AlgorithmName
    {
        // protected data members ----------------------------------------
        
        /**
        * Constant type value of the different AlgorithmName
        */
        protected static final int TYPE_0_ = 0;
        protected static final int TYPE_1_ = 1;
        
        // protected constructors ----------------------------------------
        
        /**
        * Constructor
        */
        protected AlgorithmName()
        {
        }
        
        // protected methods ---------------------------------------------
        
        /**
        * Sets the information for accessing the algorithmic names
        * @param rangestart starting code point that lies within this name group
        * @param rangeend end code point that lies within this name group
        * @param type algorithm type. There's 2 kinds of algorithmic type. First 
        *        which uses code point as part of its name and the other uses 
        *        variant postfix strings
        * @param variant algorithmic variant
        * @return true if values are valid
        */ 
        protected boolean setInfo(int rangestart, int rangeend, byte type,
                                byte variant)
        {
            if (rangestart >= UCharacter.MIN_VALUE && rangestart <= rangeend 
                && rangeend <= UCharacter.MAX_VALUE && 
                (type == TYPE_0_ || type == TYPE_1_)) {
                m_rangestart_ = rangestart;
                m_rangeend_ = rangeend;
                m_type_ = type;
                m_variant_ = variant;
                return true;
            }
            return false;
        }
        
        /**
        * Sets the factor data
        * @param array of factor
        * @return true if factors are valid
        */
        protected boolean setFactor(char factor[])
        {
            if (factor.length == m_variant_) {
                m_factor_ = factor;
                return true;
            }
            return false;
        }
        
        /**
        * Sets the name prefix
        * @param prefix
        * @return true if prefix is set
        */
        protected boolean setPrefix(String prefix)
        {
            if (prefix != null && prefix.length() > 0) {
                m_prefix_ = prefix;
                return true;
            }
            return false;
        }
        
        /**
        * Sets the variant factorized name data 
        * @param string variant factorized name data
        * @return true if values are set
        */
        protected boolean setFactorString(byte string[])
        {
            // factor and variant string can be empty for things like 
            // hanggul code points
            m_factorstring_ = string;
            return true;
        }
      
        /**
        * Checks if code point lies in Algorithm object at index
        * @param ch code point 
        */
        protected boolean contains(int ch)
        {
            return m_rangestart_ <= ch && ch <= m_rangeend_;
        }
        
        /**
        * Appends algorithm name of code point into StringBuffer.
        * Note this method does not check for validity of code point in Algorithm,
        * result is undefined if code point does not belong in Algorithm.
        * @param ch code point
        * @param str StringBuffer to append to
        */
        protected void appendName(int ch, StringBuffer str)
        {
            str.append(m_prefix_);
            switch (m_type_) 
            {
                case TYPE_0_: 
                    // prefix followed by hex digits indicating variants
                    Utility.hex(ch, m_variant_, str);
                    break;
                case TYPE_1_: 
                    // prefix followed by factorized-elements
                    int offset = ch - m_rangestart_;
                    int indexes[] = new int[m_variant_];
                    int factor;
                      
                    // write elements according to the factors
                    // the factorized elements are determined by modulo 
                    // arithmetic
                    for (int i = m_variant_ - 1; i > 0; i --) 
                    {
                        factor = m_factor_[i] & 0x00FF;
                        indexes[i] = offset % factor;
                        offset /= factor;
                    }
                      
                    // we don't need to calculate the last modulus because 
                    // start <= code <= end guarantees here that 
                    // code <= factors[0]
                    indexes[0] = offset;

                    // joining up the factorized strings 
                    String s[] = getFactorString(indexes);
                    if (s != null && s.length > 0)
                    {
                        int size = s.length;
                        for (int i = 0; i < size; i ++)
                        str.append(s[i]);
                    }
                    break;
            }
        }
        
        /**
        * Gets the character for the argument algorithmic name
        * @return the algorithmic char or -1 otherwise.
        */
        protected int getAlgorithmChar(String name)
        {
            int prefixlen = m_prefix_.length();
            if (name.length() < prefixlen || 
                !m_prefix_.equals(name.substring(0, prefixlen))) {
                return -1;
            }
                
            switch (m_type_) 
            {
                case TYPE_0_ : 
                try
                {
                    int result = Integer.parseInt(name.substring(prefixlen), 
                                                  16);
                    // does it fit into the range?
                    if (m_rangestart_ <= result && result <= m_rangeend_) {
                        return result;
                    }
                }
                catch (NumberFormatException e)
                {
                    return -1;
                }
                break;
                case TYPE_1_ : 
                    // repetitative suffix name comparison done here
                    // offset is the character code - start
                    for (int ch = m_rangestart_; ch <= m_rangeend_; ch ++)
                    {
                        int offset = ch - m_rangestart_;
                        int indexes[] = new int[m_variant_];
                        int factor;
                  
                        // write elements according to the factors
                        // the factorized elements are determined by modulo 
                        // arithmetic
                        for (int i = m_variant_ - 1; i > 0; i --) 
                        {
                            factor = m_factor_[i] & 0x00FF;
                            indexes[i] = offset % factor;
                            offset /= factor;
                        }
                        
                        // we don't need to calculate the last modulus 
                        // because start <= code <= end guarantees here that 
                        // code <= factors[0]
                        indexes[0] = offset;

                        // joining up the factorized strings 
                        if (compareFactorString(indexes, name, prefixlen)) {
                            return ch;
                        }
                    }
            }

            return -1;
        }
        
        // private data members ------------------------------------------
        
        /**
        * Algorithmic data information
        */
        private int m_rangestart_;
        private int m_rangeend_;
        private byte m_type_;
        private byte m_variant_;
        private char m_factor_[];
        private String m_prefix_;
        private byte m_factorstring_[];
        
        // private methods -----------------------------------------------
                
        /**
        * Gets the indexth string in each of the argument factor block
        * @param index array with each index corresponding to each factor block
        * @return array of indexth factor string in factor block
        */
        private String[] getFactorString(int index[])
        {
            int size = m_factor_.length;
            if (index == null || index.length != size) {
                return null;
            }
                
            String result[] = new String[size];
            StringBuffer str = new StringBuffer();
            int count = 0;
            int factor;
            size --;
            for (int i = 0; i <= size; i ++) {
                factor = m_factor_[i];
                count = UCharacterUtil.skipNullTermByteSubString(
                                          m_factorstring_, count, index[i]);
                count = UCharacterUtil.getNullTermByteSubString(
                                          str, m_factorstring_, count);
                if (i != size) {
                    count = UCharacterUtil.skipNullTermByteSubString(
                                                   m_factorstring_, count, 
                                                   factor - index[i] - 1);
                }
                result[i] = str.toString();
                str.delete(0, str.length());
            }
            return result;
        }
        
        /**
        * Compares the indexth string in each of the argument factor block with
        * the argument string
        * @param index array with each index corresponding to each factor block
        * @param str string to compare with
        * @param offset of str to start comparison
        * @return true if string matches
        */
        private boolean compareFactorString(int index[], String str, 
                                            int offset)
        {
            int size = m_factor_.length;
            if (index == null || index.length != size)
                return false;
                
            int count = 0;
            int strcount = offset;
            int factor;
            size --;
            for (int i = 0; i <= size; i ++)
            {
                factor = m_factor_[i];
                count = UCharacterUtil.skipNullTermByteSubString(
                                          m_factorstring_, count, index[i]);
                strcount = UCharacterUtil.compareNullTermByteSubString(str, 
                                          m_factorstring_, strcount, count);
                if (strcount < 0) {
                    return false;
                }
                  
                if (i != size) {
                    count = UCharacterUtil.skipNullTermByteSubString(
                                  m_factorstring_, count, factor - index[i]);
                }
            }
            if (strcount != str.length()) {
                return false;
            }
            return true;
        }
    }
    
    // protected data members --------------------------------------------
    
    /**
     * Maximum number of groups
     */
    protected int m_groupcount_ = 0;
    /**
     * Size of each groups
     */
    protected int m_groupsize_ = 0;
    /**
    * Number of lines per group 
    * 1 << GROUP_SHIFT_
    */
    protected static final int LINES_PER_GROUP_ = 1 << 5;
    
    // protected constructor ---------------------------------------------
    
    /**
    * <p>Protected constructor for use in UCharacter.</p>
    * @exception IOException thrown when data reading fails
    */
    protected UCharacterName() throws IOException
    {
        InputStream i = getClass().getResourceAsStream(NAME_FILE_NAME_);
        BufferedInputStream b = new BufferedInputStream(i, 
                                                        NAME_BUFFER_SIZE_);
        UCharacterNameReader reader = new UCharacterNameReader(b);
        reader.read(this);
        i.close();
    }
      
    // protected methods -------------------------------------------------
     
    /**
    * Retrieve the name of a Unicode code point.
    * Depending on <code>choice</code>, the character name written into the 
    * buffer is the "modern" name or the name that was defined in Unicode 
    * version 1.0.
    * The name contains only "invariant" characters
    * like A-Z, 0-9, space, and '-'.
    *
    * @param ch the code point for which to get the name.
    * @param choice Selector for which name to get.
    * @return if code point is above 0x1fff, null is returned
    */
    protected String getName(int ch, int choice)
    {
        if (ch < UCharacter.MIN_VALUE || ch > UCharacter.MAX_VALUE || 
            choice >= UCharacterNameChoice.U_CHAR_NAME_CHOICE_COUNT) {
            return null;
        }
        
        String result = null;
        
        result = getAlgName(ch, choice);
          
        // getting normal character name
        if (result == null || result.length() == 0) {
        	if (choice == UCharacterNameChoice.U_EXTENDED_CHAR_NAME) {	  
                result = getExtendedName(ch);	
            } else {
                result = getGroupName(ch, choice);
            }
        }
          
        return result;
    }
      
    /**
    * Find a character by its name and return its code point value
    * @param character name
    * @param choice selector to indicate if argument name is a Unicode 1.0 
    *        or the most current version 
    * @return code point
    */
    protected int getCharFromName(int choice, String name)
    {
        // checks for illegal arguments
        if (choice >= UCharacterNameChoice.U_CHAR_NAME_CHOICE_COUNT || 
            name == null || name.length() == 0) {
            return -1;
        }
        
        // try extended names first  
        int result = getExtendedChar(name.toLowerCase(), choice);
        if (result >= -1) {
            return result;
        }
        
        String upperCaseName = name.toUpperCase();
        // try algorithmic names first, if fails then try group names
        // int result = getAlgorithmChar(choice, uppercasename);
        
        if (choice != UCharacterNameChoice.U_UNICODE_10_CHAR_NAME) {
        	int count = 0;
        	if (m_algorithm_ != null) {
        	    count = m_algorithm_.length;
        	}
        	for (count --; count >= 0; count --) {
         	    result = m_algorithm_[count].getAlgorithmChar(upperCaseName); 
          	    if (result >= 0) {
           	        return result;
            	}
        	}
        }
            
        if (choice == UCharacterNameChoice.U_EXTENDED_CHAR_NAME) {
	        result = getGroupChar(upperCaseName, 
	                              UCharacterNameChoice.U_UNICODE_CHAR_NAME);
        	if (result == -1) {
	            result = getGroupChar(upperCaseName, 
	                              UCharacterNameChoice.U_UNICODE_10_CHAR_NAME);
        	}
        }
        else {
        	result = getGroupChar(upperCaseName, choice);
        }
    	return result;
    }
    
    /**
    * Sets the token data
    * @param token array of tokens
    * @param tokenstring array of string values of the tokens
    * @return false if there is a data error
    */
    protected boolean setToken(char token[], byte tokenstring[])
    {
        if (token != null && tokenstring != null && token.length > 0 &&
            tokenstring.length > 0) {
            m_tokentable_ = token;
            m_tokenstring_ = tokenstring;
            return true;
        }
        return false; 
    }
        
    /**
    * Set the algorithm name information array
    * @param algorithm information array
    * @return true if the group string offset has been set correctly
    */
    protected boolean setAlgorithm(AlgorithmName alg[])
    {
        if (alg != null && alg.length != 0) {
            m_algorithm_ = alg;
            return true;
        }
        return false;
    }
    
    /**
    * Sets the number of group and size of each group in number of char
    * @param count number of groups
    * @param size size of group in char
    * @return true if group size is set correctly
    */
    protected boolean setGroupCountSize(int count, int size)
    {
        if (count <= 0 || size <= 0) {
            return false;
        }
        m_groupcount_ = count;
        m_groupsize_ = size;
        return true;
    }
      
    /**
    * Sets the group name data
    * @param group index information array
    * @param groupstring name information array
    * @return false if there is a data error
    */
    protected boolean setGroup(char group[], byte groupstring[])
    {
        if (group != null && groupstring != null && group.length > 0 &&
            groupstring.length > 0) {
            m_groupinfo_ = group;
            m_groupstring_ = groupstring;
            return true;
        }
        return false; 
    }
    
    /**
    * Reads a block of compressed lengths of 32 strings and expands them into 
    * offsets and lengths for each string. Lengths are stored with a 
    * variable-width encoding in consecutive nibbles:
    * If a nibble<0xc, then it is the length itself (0 = empty string).
    * If a nibble>=0xc, then it forms a length value with the following 
    * nibble.
    * The offsets and lengths arrays must be at least 33 (one more) long 
    * because there is no check here at the end if the last nibble is still 
    * used.
    * @param index of group string object in array
    * @param offsets array to store the value of the string offsets
    * @param lengths array to store the value of the string length
    * @return next index of the data string immediately after the lengths 
    *         in terms of byte address
    */
    protected int getGroupLengths(int index, char offsets[], char lengths[]) 
    {
        char length = 0xffff;
        byte b = 0,
            n = 0;
        int shift;
        index = index * m_groupsize_; // byte count offsets of group strings
        int stringoffset = UCharacterUtil.toInt(
                                 m_groupinfo_[index + OFFSET_HIGH_OFFSET_], 
                                 m_groupinfo_[index + OFFSET_LOW_OFFSET_]);
            
        offsets[0] = 0;
        
        // all 32 lengths must be read to get the offset of the first group 
        // string
        for (int i = 0; i < LINES_PER_GROUP_; stringoffset ++) {
            b = m_groupstring_[stringoffset];
            shift = 4;
              
            while (shift >= 0) {
                // getting nibble
                n = (byte)((b >> shift) & 0x0F);   
                if (length == 0xffff && n > SINGLE_NIBBLE_MAX_) {
                	length = (char)((n - 12) << 4);
                }
                else {
                	if (length != 0xffff) {
                 	   lengths[i] = (char)((length | n) + 12);
                	}
                	else {
                 	   lengths[i] = (char)n;
                	}
                    
                	if (i < LINES_PER_GROUP_) {
                 	   offsets[i + 1] = (char)(offsets[i] + lengths[i]);
                	}
                    
                	length = 0xffff;
                	i ++;
                }
                      
                shift -= 4;
            }
        }
        return stringoffset;
    }
    
    /**
    * Gets the name of the argument group index
    * @param index of the group name string in byte count
    * @param length of the group name string
    * @param choice of Unicode 1.0 name or the most current name
    * @return name of the group 
    */
    protected String getGroupName(int index, int length, int choice) 
    {
        if (choice == UCharacterNameChoice.U_UNICODE_10_CHAR_NAME) {
        	int oldindex = index;
         	index += UCharacterUtil.skipByteSubString(m_groupstring_, 
         		                               index, length, (byte)';');   
         	length -= (index - oldindex);
        }
        
        StringBuffer s = new StringBuffer();
        byte b;
        char token;
        for (int i = 0; i < length;) {
            b = m_groupstring_[index + i];
            i ++;
              
            if (b >= m_tokentable_.length) {
                if (b == ';') {
                	break;
                }
                s.append(b); // implicit letter
            }
            else {
                token = m_tokentable_[b & 0x00ff];
                if (token == 0xFFFE) {
                    // this is a lead byte for a double-byte token
                    token = m_tokentable_[b << 8 | 
                                      (m_groupstring_[index + i] & 0x00ff)];
                    i ++;
                }
                if (token == 0xFFFF) {
                    if (b == ';') {
                    	// skip the semicolon if we are seeking extended 
                    	// names and there was no 2.0 name but there
                        // is a 1.0 name.
                    	if (s.length() == 0 && choice == 
                    	       UCharacterNameChoice.U_EXTENDED_CHAR_NAME) {
                        	continue;
                    	}
                        break;
                    }
                    s.append((char)(b & 0x00ff)); // explicit letter
                }
                else { // write token word
                    UCharacterUtil.getNullTermByteSubString(s, 
                                                     m_tokenstring_, token);
                }
            }
        }

        if (s.length() == 0) {
            return null;
        }
        return s.toString();
    }
    
    /**
    * Retrieves the extended name
    */
    protected String getExtendedName(int ch) 
    {    
        String result = getName(ch, UCharacterNameChoice.U_UNICODE_CHAR_NAME);    
        if (result == null) {        
            if (getType(ch) == UCharacterCategory.CONTROL) {            
                result = getName(ch, 
                                 UCharacterNameChoice.U_UNICODE_10_CHAR_NAME);        
            }        
            if (result == null) {            
                result = getExtendedOr10Name(ch);
            }
        }    
        return result;
    }
    
    /**
     * Gets the group index for the codepoint, or the group before it.
     * @param codepoint
     * @return group index containing codepoint or the group before it.
     */
    protected int getGroup(int codepoint)
    {
    	int endGroup = m_groupcount_;
    	int msb      = getCodepointMSB(codepoint);
        int result   = 0;    
        // binary search for the group of names that contains the one for 
        // code
        // find the group that contains codepoint, or the highest before it
        while (result < endGroup - 1) {
            int gindex = (result + endGroup) >> 1;
            if (msb < getGroupMSB(gindex)) {
               	endGroup = gindex;
            }
            else {
               	result = gindex;
            }
        }
        return result;
    }
    
    /**
     * Gets the extended and 1.0 name when the most current unicode names
     * fail
     * @param ch codepoint
     * @return name of codepoint extended or 1.0
     */
    protected String getExtendedOr10Name(int ch)
    {
    	String result = null;
    	if (getType(ch) == UCharacterCategory.CONTROL) {            
            result = getName(ch, 
                             UCharacterNameChoice.U_UNICODE_10_CHAR_NAME);        
        }        
        if (result == null) {            
            int type = getType(ch);    
            // Return unknown if the table of names above is not up to 
            // date.
            if (type >= UCharacterCategory.TYPE_NAMES_.length) {       
                result = UCharacterCategory.UNKNOWN_TYPE_NAME_;    
            } 
            else {        
                result = UCharacterCategory.TYPE_NAMES_[type];    
            }
            StringBuffer tempResult = new StringBuffer(result);
            tempResult.insert(0, '<');
            tempResult.append('-');
            String chStr = Integer.toHexString(ch).toUpperCase();
            int zeros = 4 - chStr.length();
            while (zeros > 0) {
                tempResult.append('0');
                zeros --;
            }
            tempResult.append(chStr);
            tempResult.append('>');
            result = tempResult.toString();
        }
        return result;
    }
    
    // these are all UCharacterNameIterator use methods -------------------
    
    /**
     * Gets the MSB from the group index
     * @param gindex group index
     * @return the MSB of the group if gindex is valid, -1 otherwise
     */
    protected int getGroupMSB(int gindex)
    {
    	if (gindex >= m_groupcount_) {
    		return -1;
    	}
    	return m_groupinfo_[gindex * m_groupsize_];
    }
    
    /**
     * Gets the MSB of the codepoint
     * @param codepoint 
     * @return the MSB of the codepoint
     */
    protected int getCodepointMSB(int codepoint)
    {
    	return codepoint >> GROUP_SHIFT_;
    }
    
    /**
     * Gets the maximum codepoint + 1 of the group
     * @param msb most significant byte of the group
     * @return limit codepoint of the group
     */
    protected int getGroupLimit(int msb)
    {
    	return (msb << GROUP_SHIFT_) + LINES_PER_GROUP_;
    }
    
    /**
     * Gets the minimum codepoint of the group
     * @param msb most significant byte of the group
     * @return minimum codepoint of the group
     */
    protected int getGroupMin(int msb)
    {
    	return msb << GROUP_SHIFT_;
    }
    
    /**
     * Gets the offset to a group
     * @param codepoint 
     * @return offset to a group
     */
    protected int getGroupOffset(int codepoint)
    {
    	return codepoint & GROUP_MASK_;
    }

	/**
     * Gets the minimum codepoint of a group
     * @param codepoint
     * @return minimum codepoint in the group which codepoint belongs to
     */
    protected int getGroupMinFromCodepoint(int codepoint)
    {
    	return codepoint & ~GROUP_MASK_;
    }
    
    /**
     * Get the Algorithm range length 
     * @return Algorithm range length
     */
    protected int getAlgorithmLength()
    {
    	return m_algorithm_.length;
    }
        
    /**
     * Gets the start of the range
     * @param index algorithm index
     * @return algorithm range start
     */
    protected int getAlgorithmStart(int index)
    {
      	return m_algorithm_[index].m_rangestart_;
    }
        
    /**
     * Gets the end of the range
     * @param index algorithm index
     * @return algorithm range end
     */
    protected int getAlgorithmEnd(int index)
    {
      	return m_algorithm_[index].m_rangeend_;
    }
    
    /**
     * Gets the Algorithmic name of the codepoint
     * @param index algorithmic range index
     * @param codepoint 
     * @return algorithmic name of codepoint
     */
    protected String getAlgorithmName(int index, int codepoint) 
    {
    	StringBuffer result = new StringBuffer();
    	m_algorithm_[index].appendName(codepoint, result);
        return result.toString();
    }
    
        
    // private data members ----------------------------------------------
    
    /**
    * Data used in unames.dat
    */
    private char m_tokentable_[];
    private byte m_tokenstring_[];
    private char m_groupinfo_[];
    private byte m_groupstring_[];
    private AlgorithmName m_algorithm_[];
      
    /**
    * Group use
    */
    private char m_groupoffsets_[] = new char[LINES_PER_GROUP_ + 1];
    private char m_grouplengths_[] = new char[LINES_PER_GROUP_ + 1];
      	 
    /**
    * Default name of the name datafile
    */
    private static final String NAME_FILE_NAME_ = 
                                           "/com/ibm/icu/impl/data/unames.dat";
    /**
    * Shift count to retrieve group information
    */
    private static final int GROUP_SHIFT_ = 5;
    /**
    * Mask to retrieve the offset for a particular character within a group
    */
    private static final int GROUP_MASK_ = LINES_PER_GROUP_ - 1;
    /**
    * Default buffer size of datafile
    */
    private static final int NAME_BUFFER_SIZE_ = 100000;
      
    /**
    * Position of offsethigh in group information array
    */
    private static final int OFFSET_HIGH_OFFSET_ = 1;
      
    /**
    * Position of offsetlow in group information array
    */
    private static final int OFFSET_LOW_OFFSET_ = 2;
    /**
    * Double nibble indicator, any nibble > this number has to be combined
    * with its following nibble
    */
    private static final int SINGLE_NIBBLE_MAX_ = 11;
     
      
    // private methods ---------------------------------------------------
      
    /**
    * Gets the algorithmic name for the argument character
    * @param ch character to determine name for
    * @param choice name choice
    * @return the algorithmic name or null if not found
    */
    private String getAlgName(int ch, int choice) 
    {
    	// Do not write algorithmic Unicode 1.0 names because Unihan names are 
        // the same as the modern ones, extension A was only introduced with 
        // Unicode 3.0, and the Hangul syllable block was moved and changed 
        // around Unicode 1.1.5.
        if (choice != UCharacterNameChoice.U_UNICODE_10_CHAR_NAME) {
       	 	// index in terms integer index
        	StringBuffer s = new StringBuffer();
        
        	for (int index = m_algorithm_.length - 1; index >= 0; index --) {
         	   if (m_algorithm_[index].contains(ch)) {
          	      m_algorithm_[index].appendName(ch, s);
            	  return s.toString();
         	   }
            }
        }
        return null;
    }
      
    /**
    * Getting the character with the tokenized argument name
    * @param name of the character
    * @return character with the tokenized argument name or -1 if character
    *         is not found
    */
    private synchronized int getGroupChar(String name, int choice) 
    {
    	for (int i = 0; i < m_groupcount_; i ++) {
        	// populating the data set of grouptable
        	
        	int startgpstrindex = getGroupLengths(i, m_groupoffsets_, 
                                                  m_grouplengths_);
          
        	// shift out to function
        	int result = getGroupChar(startgpstrindex, m_grouplengths_, name, 
        	                          choice);
        	if (result != -1) {
            	return (m_groupinfo_[i * m_groupsize_] << GROUP_SHIFT_) 
            	         | result;
        	}
        }
        return -1;
    }
      
    /**
    * Compares and retrieve character if name is found within the argument 
    * group
    * @param index index where the set of names reside in the group block
    * @param length list of lengths of the strings
    * @param name character name to search for
    * @param choice of either 1.0 or the most current unicode name
    * @return relative character in the group which matches name, otherwise if   
    *         not found, -1 will be returned
    */
    private int getGroupChar(int index, char length[], String name, 
                             int choice)
    { 
        byte b = 0; 
        char token;
        int len;
        int namelen = name.length();
        int nindex;
        int count;
        
        for (int result = 0; result <= LINES_PER_GROUP_; result ++) {
            nindex = 0;
            len = length[result];
              
            if (choice == UCharacterNameChoice.U_UNICODE_10_CHAR_NAME) {
                int oldindex = index;
                index += UCharacterUtil.skipByteSubString(m_groupstring_, 
                                                     index, len, (byte)';');
                len -= (index - oldindex);
            }
                
            // number of tokens is > the length of the name
            // write each letter directly, and write a token word per token
            for (count = 0; count < len && nindex != -1 && nindex < namelen;
                ) {
                b = m_groupstring_[index + count];
                count ++;
                   
                if (b >= m_tokentable_.length) {
                    if (name.charAt(nindex ++) != (b & 0xFF)) {
                        nindex = -1;
                    }
                }
                else {
                    token = m_tokentable_[b & 0xFF];
                    if (token == 0xFFFE) {
                        // this is a lead byte for a double-byte token
                        token = m_tokentable_[b << 8 | 
                                   (m_groupstring_[index + count] & 0x00ff)];
                        count ++;
                    }
                    if (token == 0xFFFF) {
                        if (name.charAt(nindex ++) != (b & 0xFF)) {
                            nindex = -1;
                        }
                    }
                    else {
                        // compare token with name
                        nindex = UCharacterUtil.compareNullTermByteSubString(
                                        name, m_tokenstring_, nindex, token);
                    }
                }
            }

            if (namelen == nindex && 
                (count == len || m_groupstring_[index + count] == ';')) {
                return result;
            }
                
            index += len;
        }
        return -1;
    }
       
    /**
    * Binary search for the group strings set that contains the argument Unicode 
    * code point's most significant bits.
    * The return value is always a valid group string set that contain msb.
    * If group string set is not found, -1 is returned
    * @param ch the code point to look for
    * @return group string set index in datatable otherwise -1 is returned if 
    *         group string set is not found
    */
    private int getGroupStringIndex(int ch)
    {
        // gets the msb
        int msb = ch >> GROUP_SHIFT_,
            end = m_groupcount_,
            start,
            gindex = 0;
            
        // binary search for the group of names that contains the one for code
        for (start = 0; start < end - 1;) {
            gindex = (start + end) >> 1;
            if (msb < m_groupinfo_[gindex * m_groupsize_]) {
                end = gindex;
            }
            else {
                start = gindex;
            }
        }

        // return this if it is an exact match
        if (msb == m_groupinfo_[start * m_groupsize_]) {
            start = start * m_groupsize_;
            return UCharacterUtil.toInt(
                                m_groupinfo_[start + OFFSET_HIGH_OFFSET_], 
                                m_groupinfo_[start + OFFSET_LOW_OFFSET_]);
        }
        return -1;
    }
    
    /**
    * Gets the group name of the character
    * @param ch character to get the group name 
    * @param choice name choice selector to choose a unicode 1.0 or newer name
    */
    private synchronized String getGroupName(int ch, int choice) 
    {            
        // gets the msb
        int msb   = getCodepointMSB(ch);
        int group = getGroup(ch);

        // return this if it is an exact match
        if (msb == m_groupinfo_[group * m_groupsize_]) {
            int index = getGroupLengths(group, m_groupoffsets_, 
                                        m_grouplengths_);
            int offset = ch & GROUP_MASK_;
            return getGroupName(index + m_groupoffsets_[offset], 
                                m_grouplengths_[offset], choice);
        }
        
        return null;
    }
    
    /**
    * Gets the character extended type
    * @param ch character to be tested
    * @return extended type it is associated with
    */
    private int getType(int ch)
    {
        if (UCharacter.isNonCharacter(ch)) {  
            // not a character we return a invalid category count
            return UCharacterCategory.NON_CHARACTER_;    
        }    
        int result = UCharacter.getType(ch);
        if (result == UCharacterCategory.SURROGATE) {            
            if (ch <= UTF16.LEAD_SURROGATE_MAX_VALUE) {
                result = UCharacterCategory.LEAD_SURROGATE_;
            }
            else {
                result = UCharacterCategory.TRAIL_SURROGATE_;
            }    
        }    
        return result;
    }
    
    /**
    * Getting the character with extended name of the form <....>.
    * @param name of the character to be found
    * @param choice name choice
    * @return character associated with the name, -1 if such character is not
    *                   found and -2 if we should continue with the search.
    */
    private int getExtendedChar(String name, int choice)
    {
        if (name.charAt(0) == '<') {        
            if (choice == UCharacterNameChoice.U_EXTENDED_CHAR_NAME) {            
                int endIndex = name.length() - 1;
                if (name.charAt(endIndex) == '>') {
                    int startIndex = name.lastIndexOf('-');
                    if (startIndex >= 0) { // We've got a category.     
                        startIndex ++;
                        int result = -1;
                        try {
                            result = Integer.parseInt(
                                        name.substring(startIndex, endIndex), 
                                        16);
                        }
                        catch (NumberFormatException e) {
                            return -1;     
                        } 
                        // Now validate the category name. We could use a 
                        // binary search, or a trie, if we really wanted to. 
                        String type = name.substring(1, startIndex - 1);
                        int length = UCharacterCategory.TYPE_NAMES_.length;
                        for (int i = 0; i < length; ++ i) {             
                            if (type.compareTo(
                                   UCharacterCategory.TYPE_NAMES_[i]) == 0) { 
                                if (getType(result) == i) { 
                                    return result;     
                                }  
                                break;          
                            } 
                        }
                    }
                }
            }            
            return -1; 
        }    
        return -2;
    }
}