Each list element will be a (limit, offset) pair as described * for the CollationSettings.reorderRanges. * The list will be empty if no ranges are reordered. */ void makeReorderRanges(int[] reorder, UVector32 ranges) { makeReorderRanges(reorder, false, ranges); } private void makeReorderRanges(int[] reorder, boolean latinMustMove, UVector32 ranges) { ranges.removeAllElements(); int length = reorder.length; if(length == 0 || (length == 1 && reorder[0] == UScript.UNKNOWN)) { return; } // Maps each script-or-group range to a new lead byte. short[] table = new short[scriptStarts.length - 1]; // C++: uint8_t[] { // Set "don't care" values for reserved ranges. int index = scriptsIndex[ numScripts + REORDER_RESERVED_BEFORE_LATIN - Collator.ReorderCodes.FIRST]; if(index != 0) { table[index] = 0xff; } index = scriptsIndex[ numScripts + REORDER_RESERVED_AFTER_LATIN - Collator.ReorderCodes.FIRST]; if(index != 0) { table[index] = 0xff; } } // Never reorder special low and high primary lead bytes. assert(scriptStarts.length >= 2); assert(scriptStarts[0] == 0); int lowStart = scriptStarts[1]; assert(lowStart == ((Collation.MERGE_SEPARATOR_BYTE + 1) << 8)); int highLimit = scriptStarts[scriptStarts.length - 1]; assert(highLimit == (Collation.TRAIL_WEIGHT_BYTE << 8)); // Get the set of special reorder codes in the input list. // This supports a fixed number of special reorder codes; // it works for data with codes beyond Collator.ReorderCodes.LIMIT. int specials = 0; for(int i = 0; i < length; ++i) { int reorderCode = reorder[i] - Collator.ReorderCodes.FIRST; if(0 <= reorderCode && reorderCode < MAX_NUM_SPECIAL_REORDER_CODES) { specials |= 1 << reorderCode; } } // Start the reordering with the special low reorder codes that do not occur in the input. for(int i = 0; i < MAX_NUM_SPECIAL_REORDER_CODES; ++i) { int index = scriptsIndex[numScripts + i]; if(index != 0 && (specials & (1 << i)) == 0) { lowStart = addLowScriptRange(table, index, lowStart); } } // Skip the reserved range before Latin if Latin is the first script, // so that we do not move it unnecessarily. int skippedReserved = 0; if(specials == 0 && reorder[0] == UScript.LATIN && !latinMustMove) { int index = scriptsIndex[UScript.LATIN]; assert(index != 0); int start = scriptStarts[index]; assert(lowStart <= start); skippedReserved = start - lowStart; lowStart = start; } // Reorder according to the input scripts, continuing from the bottom of the primary range. boolean hasReorderToEnd = false; for(int i = 0; i < length;) { int script = reorder[i++]; if(script == UScript.UNKNOWN) { // Put the remaining scripts at the top. hasReorderToEnd = true; while(i < length) { script = reorder[--length]; if(script == UScript.UNKNOWN) { // Must occur at most once. throw new IllegalArgumentException( "setReorderCodes(): duplicate UScript.UNKNOWN"); } if(script == Collator.ReorderCodes.DEFAULT) { throw new IllegalArgumentException( "setReorderCodes(): UScript.DEFAULT together with other scripts"); } int index = getScriptIndex(script); if(index == 0) { continue; } if(table[index] != 0) { // Duplicate or equivalent script. throw new IllegalArgumentException( "setReorderCodes(): duplicate or equivalent script " + scriptCodeString(script)); } highLimit = addHighScriptRange(table, index, highLimit); } break; } if(script == Collator.ReorderCodes.DEFAULT) { // The default code must be the only one in the list, and that is handled by the caller. // Otherwise it must not be used. throw new IllegalArgumentException( "setReorderCodes(): UScript.DEFAULT together with other scripts"); } int index = getScriptIndex(script); if(index == 0) { continue; } if(table[index] != 0) { // Duplicate or equivalent script. throw new IllegalArgumentException( "setReorderCodes(): duplicate or equivalent script " + scriptCodeString(script)); } lowStart = addLowScriptRange(table, index, lowStart); } // Put all remaining scripts into the middle. for(int i = 1; i < scriptStarts.length - 1; ++i) { int leadByte = table[i]; if(leadByte != 0) { continue; } int start = scriptStarts[i]; if(!hasReorderToEnd && start > lowStart) { // No need to move this script. lowStart = start; } lowStart = addLowScriptRange(table, i, lowStart); } if(lowStart > highLimit) { if((lowStart - (skippedReserved & 0xff00)) <= highLimit) { // Try not skipping the before-Latin reserved range. makeReorderRanges(reorder, true, ranges); return; } // We need more primary lead bytes than available, despite the reserved ranges. throw new ICUException( "setReorderCodes(): reordering too many partial-primary-lead-byte scripts"); } // Turn lead bytes into a list of (limit, offset) pairs. // Encode each pair in one list element: // Upper 16 bits = limit, lower 16 = signed lead byte offset. int offset = 0; for(int i = 1;; ++i) { int nextOffset = offset; while(i < scriptStarts.length - 1) { int newLeadByte = table[i]; if(newLeadByte == 0xff) { // "Don't care" lead byte for reserved range, continue with current offset. } else { nextOffset = newLeadByte - (scriptStarts[i] >> 8); if(nextOffset != offset) { break; } } ++i; } if(offset != 0 || i < scriptStarts.length - 1) { ranges.addElement(((int)scriptStarts[i] << 16) | (offset & 0xffff)); } if(i == scriptStarts.length - 1) { break; } offset = nextOffset; } } private int addLowScriptRange(short[] table, int index, int lowStart) { int start = scriptStarts[index]; if((start & 0xff) < (lowStart & 0xff)) { lowStart += 0x100; } table[index] = (short)(lowStart >> 8); int limit = scriptStarts[index + 1]; lowStart = ((lowStart & 0xff00) + ((limit & 0xff00) - (start & 0xff00))) | (limit & 0xff); return lowStart; } private int addHighScriptRange(short[] table, int index, int highLimit) { int limit = scriptStarts[index + 1]; if((limit & 0xff) > (highLimit & 0xff)) { highLimit -= 0x100; } int start = scriptStarts[index]; highLimit = ((highLimit & 0xff00) - ((limit & 0xff00) - (start & 0xff00))) | (start & 0xff); table[index] = (short)(highLimit >> 8); return highLimit; } private static String scriptCodeString(int script) { // Do not use the script name here: We do not want to depend on that data. return (script < Collator.ReorderCodes.FIRST) ? Integer.toString(script) : "0x" + Integer.toHexString(script); } private static final int[] EMPTY_INT_ARRAY = new int[0]; /** @see jamoCE32s */ static final int JAMO_CE32S_LENGTH = 19 + 21 + 27; /** Main lookup trie. */ Trie2_32 trie; /** * Array of CE32 values. * At index 0 there must be CE32(U+0000) * to support U+0000's special-tag for NUL-termination handling. */ int[] ce32s; /** Array of CE values for expansions and OFFSET_TAG. */ long[] ces; /** Array of prefix and contraction-suffix matching data. */ String contexts; /** Base collation data, or null if this data itself is a base. */ public CollationData base; /** * Simple array of JAMO_CE32S_LENGTH=19+21+27 CE32s, one per canonical Jamo L/V/T. * They are normally simple CE32s, rarely expansions. * For fast handling of HANGUL_TAG. */ int[] jamoCE32s = new int[JAMO_CE32S_LENGTH]; public Normalizer2Impl nfcImpl; /** The single-byte primary weight (xx000000) for numeric collation. */ long numericPrimary = 0x12000000; /** 256 flags for which primary-weight lead bytes are compressible. */ public boolean[] compressibleBytes; /** * Set of code points that are unsafe for starting string comparison after an identical prefix, * or in backwards CE iteration. */ UnicodeSet unsafeBackwardSet; /** * Fast Latin table for common-Latin-text string comparisons. * Data structure see class CollationFastLatin. */ public char[] fastLatinTable; /** * Header portion of the fastLatinTable. * In C++, these are one array, and the header is skipped for mapping characters. * In Java, two arrays work better. */ char[] fastLatinTableHeader; /** * Data for scripts and reordering groups. * Uses include building a reordering permutation table and * providing script boundaries to AlphabeticIndex. */ int numScripts; /** * The length of scriptsIndex is numScripts+16. * It maps from a UScriptCode or a special reorder code to an entry in scriptStarts. * 16 special reorder codes (not all used) are mapped starting at numScripts. * Up to MAX_NUM_SPECIAL_REORDER_CODES are codes for special groups like space/punct/digit. * There are special codes at the end for reorder-reserved primary ranges. * *
Multiple scripts may share a range and index, for example Hira & Kana. */ char[] scriptsIndex; /** * Start primary weight (top 16 bits only) for a group/script/reserved range * indexed by scriptsIndex. * The first range (separators & terminators) and the last range (trailing weights) * are not reorderable, and no scriptsIndex entry points to them. */ char[] scriptStarts; /** * Collation elements in the root collator. * Used by the CollationRootElements class. The data structure is described there. * null in a tailoring. */ public long[] rootElements; }