sl@0: // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). sl@0: // All rights reserved. sl@0: // This component and the accompanying materials are made available sl@0: // under the terms of the License "Eclipse Public License v1.0" sl@0: // which accompanies this distribution, and is available sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: // sl@0: // Initial Contributors: sl@0: // Nokia Corporation - initial contribution. sl@0: // sl@0: // Contributors: sl@0: // sl@0: // Description: sl@0: // The Unicode collation system. sl@0: // sl@0: // sl@0: sl@0: #include "collateimp.h" sl@0: #include "foldtable.inl" sl@0: sl@0: #include sl@0: #include sl@0: #include "u32std.h" sl@0: sl@0: // maximum size of string which has its own sort key sl@0: // 16 instead of 8, in case all supplementary characters sl@0: static const TInt KKeyedStringBufferSize = 16; sl@0: sl@0: sl@0: inline TText16 GetHighSurrogate(TUint aChar) sl@0: /** sl@0: Retrieve the high surrogate of a supplementary character. sl@0: sl@0: @param aChar The 32-bit code point value of a Unicode character. sl@0: sl@0: @return High surrogate of aChar, if aChar is a supplementary character; sl@0: aChar itself, if aChar is not a supplementary character. sl@0: */ sl@0: { sl@0: return STATIC_CAST(TText16, 0xD7C0 + (aChar >> 10)); sl@0: } sl@0: sl@0: inline TText16 GetLowSurrogate(TUint aChar) sl@0: /** sl@0: Retrieve the low surrogate of a supplementary character. sl@0: sl@0: @param aChar The 32-bit code point value of a Unicode character. sl@0: sl@0: @return Low surrogate of aChar, if aChar is a supplementary character; sl@0: zero, if aChar is not a supplementary character. sl@0: */ sl@0: { sl@0: return STATIC_CAST(TText16, 0xDC00 | (aChar & 0x3FF)); sl@0: } sl@0: sl@0: inline TUint JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate) sl@0: /** sl@0: Combine a high surrogate and a low surrogate into a supplementary character. sl@0: sl@0: @return The 32-bit code point value of the generated Unicode supplementary sl@0: character. sl@0: */ sl@0: { sl@0: return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate; sl@0: } sl@0: sl@0: // Creates a one or two collation keys sequence corresponding to the input character. sl@0: // Returns the number of keys output. sl@0: static TInt CreateDefaultCollationKeySequence(TInt aChar, TCollationKey* aBuffer) sl@0: { sl@0: if (aChar >= 0x3400 && aChar <= 0x9FFF) // CJK sl@0: { sl@0: aBuffer[0].iLow = (TUint32)aChar << 16 | 0x0105; sl@0: aBuffer[0].iHigh = aChar; sl@0: return 1;//Collation key sequence consists of 1 key sl@0: } sl@0: aBuffer[0].iLow = 0xFF800000 | ((aChar << 1) & 0x3F0000) | 0x0104; // no stop bit sl@0: aBuffer[0].iHigh = 1; sl@0: aBuffer[1].iLow = (aChar << 16) | 0x80000105; // stop bit sl@0: aBuffer[1].iHigh = 0; sl@0: return 2;//Collation key sequence consists of 2 keys sl@0: } sl@0: sl@0: // Finds a character's key in the main index, or returns -1 if it is not there sl@0: static TInt FindCollationKeyIndex(TInt aChar, const TCollationKeyTable& aTable) sl@0: { sl@0: TInt n = aTable.iIndices; sl@0: const TUint32 *base = aTable.iIndex; sl@0: const TUint32 *start = base; sl@0: const TUint32 *end = aTable.iIndex + n - 1; sl@0: const TUint32 *p = base; sl@0: TInt currentCharLength = 0; sl@0: sl@0: while (n > 0) sl@0: { sl@0: TInt pivot = n / 2; sl@0: p += pivot; sl@0: if ((p < start) || (p > end)) sl@0: { sl@0: break; sl@0: } sl@0: TInt c = *p >> 16; sl@0: if (IsHighSurrogate( (TText16)c )) sl@0: { sl@0: if ((p < end) && (IsLowSurrogate( (TText16)((*(p+1))>>16) ))) sl@0: { sl@0: currentCharLength = 2; sl@0: c = JoinSurrogate( (TText16)(*p>>16), (TText16)((*(p+1))>>16) ); sl@0: } sl@0: } sl@0: else if (IsLowSurrogate( (TText16)c )) sl@0: { sl@0: if ((p > start) && (IsHighSurrogate( (TText16)((*(p-1))>>16) ))) sl@0: { sl@0: p--; sl@0: pivot = pivot - 1; sl@0: currentCharLength = 2; sl@0: c = JoinSurrogate( (TText16)(*p>>16), (TText16)((*(p+1))>>16) ); sl@0: } sl@0: } sl@0: else sl@0: { sl@0: currentCharLength = 1; sl@0: } sl@0: if (aChar == c) // found it sl@0: { sl@0: return *p & 0xFFFF; sl@0: } sl@0: if (aChar < c) // it's before sl@0: { sl@0: n = pivot; sl@0: } sl@0: else // it's after sl@0: { sl@0: ASSERT(currentCharLength != 0); sl@0: base = p + currentCharLength; sl@0: n -= pivot + currentCharLength; sl@0: } sl@0: p = base; sl@0: } sl@0: return -1; sl@0: } sl@0: sl@0: static void ProcessKeys(TUint32& aKey1, TUint32& aKey2, TUint aFlags) sl@0: { sl@0: if (aFlags & TCollationMethod::EFoldCase) sl@0: { sl@0: static const TUint case_fold_table[21] = sl@0: { 0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x2, 0x3, 0x4, 0x5, 0x6, sl@0: 0xD, 0xE, 0xF, 0x10, 0x11, 0x12, 0x13, 0x14 }; sl@0: aKey1 = case_fold_table[aKey1]; sl@0: aKey2 = case_fold_table[aKey2]; sl@0: } sl@0: if (aFlags & TCollationMethod::ESwapCase) sl@0: { sl@0: static const TUint case_swap_table[21] = sl@0: { 0, 0x1, 0x8, 0x9, 0xA, 0xB, 0xC, 0x7, 0x2, 0x3, 0x4, 0x5, 0x6, sl@0: 0xD, 0xE, 0xF, 0x10, 0x11, 0x12, 0x13, 0x14 }; sl@0: aKey1 = case_swap_table[aKey1]; sl@0: aKey2 = case_swap_table[aKey2]; sl@0: } sl@0: if (aFlags & TCollationMethod::ESwapKana) sl@0: { sl@0: static const TUint kana_swap_table[21] = sl@0: { 0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, sl@0: 0x13, 0x14, 0xD, 0xE, 0xF, 0x10, 0x11, 0x12 }; sl@0: aKey1 = kana_swap_table[aKey1]; sl@0: aKey2 = kana_swap_table[aKey2]; sl@0: } sl@0: } sl@0: sl@0: // Returns the position of the character in the string, or aLength if it is not present. sl@0: // If aChar is found but it is preceded by aEscapeChar (aEscapeChar != 0), then the search continues. sl@0: static TInt FindCharacter(TInt aChar, TInt aEscapeChar, const TUint16* aString, TInt aLength) sl@0: { sl@0: TBool isEscaped = EFalse; sl@0: for(TInt pos=0;pos!=aLength;++pos,++aString) sl@0: { sl@0: if(isEscaped) sl@0: { sl@0: isEscaped = EFalse; sl@0: } sl@0: else if(*aString == aEscapeChar) sl@0: { sl@0: isEscaped = ETrue; sl@0: } sl@0: else if(*aString == aChar) sl@0: { sl@0: if(!isEscaped) sl@0: { sl@0: return pos; sl@0: } sl@0: } sl@0: } sl@0: return aLength; sl@0: } sl@0: sl@0: /* sl@0: The standard collation data, containing keys for all the WGL4 characters, plus sl@0: commonly-used control characters and spaces. Generated by COLTAB. sl@0: */ sl@0: static const TUint32 TheKey[] = sl@0: { sl@0: 0x21e0112,0x21e0113,0x2260112,0x2260112,0x2260113,0x2740112,0x2740113,0x6c60178, sl@0: 0x266017a,0x6c70179,0x6c60178,0x266017a,0x6c90179,0x6c60178,0x266017a,0x6cd0179, sl@0: 0x6c80178,0x266017a,0x6c90179,0x6c80178,0x266017a,0x6cd0179,0x6ca0178,0x266017a, sl@0: 0x6cd0179,0x6cc0178,0x266017a,0x6cd0179,0x6f70110,0x2650112,0x8050111,0x74b0110, sl@0: 0x78d0111,0x74b0110,0x7bd0111,0x78d0110,0x7a10111,0x78d0128,0x7a10129,0x7bd0110, sl@0: 0x2290113,0x7bd0128,0x2290113,0x7ed0128,0x8050111,0x805dd10,0x71f0111,0x805dd28, sl@0: 0x71f0129,0x85ddd10,0x85d0111,0x8750150,0x7e50151,0x9060110,0x7ed0111,0x3, sl@0: 0x201010b,0x202010b,0x203010b,0x204010b,0x205010b,0x206010b,0x207010b,0x208010b, sl@0: 0x209010b,0x2090113,0x209016f,0x209020b,0x209130b,0x209160b,0x209180b,0x2091d0b, sl@0: 0x209240b,0x209280b,0x2092a0b,0x2092f0b,0x209330b,0x209360b,0x209390b,0x2093b0b, sl@0: 0x2093f0b,0x2096b0b,0x20b010b,0x20c010b,0x20d010b,0x20d016f,0x20e010b,0x20f010b, sl@0: 0x210010b,0x211010b,0x214010b,0x21a010b,0x21c010b,0x21e010b,0x21f010b,0x221010b, sl@0: 0x222010b,0x226010b,0x229010b,0x22d010b,0x22e010b,0x22f010b,0x230010b,0x231010b, sl@0: 0x232010b,0x233010b,0x234010b,0x235010b,0x236010b,0x237010b,0x23c010b,0x23d010b, sl@0: 0x23e010b,0x23f010b,0x240010b,0x241010b,0x242010b,0x243010b,0x25e010b,0x25f010b, sl@0: 0x260010b,0x261010b,0x262010b,0x263010b,0x265010b,0x266010b,0x267010b,0x268010b, sl@0: 0x269010b,0x26a010b,0x26c010b,0x26e010b,0x26f010b,0x270010b,0x274010b,0x2ac010b, sl@0: 0x2ad010b,0x2af010b,0x2d6010b,0x2ff010b,0x300010b,0x301010b,0x302010b,0x303010b, sl@0: 0x304010b,0x317010b,0x35c010b,0x35f010b,0x366010b,0x368010b,0x369010b,0x36a010b, sl@0: 0x36b010b,0x36c010b,0x36d010b,0x36e010b,0x36f010b,0x370010b,0x371010b,0x372010b, sl@0: 0x374010b,0x375010b,0x378010b,0x37c010b,0x37d010b,0x381010b,0x382010b,0x38a010b, sl@0: 0x38c010b,0x3a2010b,0x3b9010b,0x3bb010b,0x3bc010b,0x42f010b,0x43d010b,0x44d010b, sl@0: 0x44e010b,0x4d6010b,0x4d8010b,0x4e2010b,0x4e6010b,0x4ea010b,0x4ee010b,0x4f2010b, sl@0: 0x4fa010b,0x502010b,0x50a010b,0x512010b,0x526010b,0x527010b,0x528010b,0x529010b, sl@0: 0x52a010b,0x52b010b,0x52c010b,0x52d010b,0x52e010b,0x52f010b,0x530010b,0x531010b, sl@0: 0x532010b,0x533010b,0x534010b,0x535010b,0x536010b,0x537010b,0x538010b,0x539010b, sl@0: 0x53a010b,0x53b010b,0x53c010b,0x53d010b,0x53e010b,0x53f010b,0x540010b,0x541010b, sl@0: 0x542010b,0x556010b,0x55a010b,0x55e010b,0x562010b,0x566010b,0x567010b,0x568010b, sl@0: 0x569010b,0x56c010b,0x56d010b,0x576010b,0x577010b,0x578010b,0x57e010b,0x586010b, sl@0: 0x588010b,0x590010b,0x596010b,0x597010b,0x59b010b,0x5a4010b,0x5a5010b,0x5b2010b, sl@0: 0x5f0010b,0x5f1010b,0x5f2010b,0x5f6010b,0x5f8010b,0x616010b,0x619010b,0x61b010b, sl@0: 0x61c010b,0x620010b,0x621010b,0x6b4010b,0x6b5010b,0x1309,0x1609,0x1809, sl@0: 0x1d09,0x2209,0x2409,0x2809,0x2f09,0x3009,0x3309,0x3609, sl@0: 0x3909,0x3b09,0x4109,0x2c20109,0x2c30109,0x2c40109,0x2c50109,0x2c60109, sl@0: 0x2cd0109,0x2ce0109,0x2d10109,0x2d50109,0x2fa0109,0x6c50109,0x6c60109,0x6c60151, sl@0: 0x6c70109,0x6c70151,0x6c80109,0x6c80151,0x6c90109,0x6ca0109,0x6cb0109,0x6cc0109, sl@0: 0x6cd0109,0x6ce0109,0x6cf0109,0x6cf0121,0x6cf0151,0x6d30109,0x6d30121,0x6e30109, sl@0: 0x6e30121,0x6f70109,0x6f70121,0x7030109,0x7030121,0x7070109,0x7070121,0x7170109, sl@0: 0x7170121,0x71f0109,0x71f0121,0x74b0109,0x74b0121,0x74f0109,0x7530109,0x7530121, sl@0: 0x7730109,0x7730121,0x77f0109,0x77f0121,0x78d0109,0x78d0121,0x7910109,0x7a10109, sl@0: 0x7a10121,0x7b10109,0x7b10121,0x7bd0109,0x7bd0115,0x7bd0121,0x7c50109,0x7c50121, sl@0: 0x7e50109,0x7e50121,0x7ed0109,0x7ed0121,0x7ed0151,0x8010109,0x8010121,0x8050109, sl@0: 0x8050121,0x8050151,0x80d0109,0x80d0121,0x81d0109,0x81d0121,0x8290109,0x8290121, sl@0: 0x8310109,0x8350109,0x8350121,0x85d0109,0x85d0121,0x85dde11,0x8750109,0x8750121, sl@0: 0x8790109,0x8790121,0x88d0109,0x88d0121,0x8a50109,0x8a50121,0x8b10109,0x8b10121, sl@0: 0x8b90109,0x8b90121,0x8bd0109,0x8bd0121,0x8c90109,0x8c90121,0x8e90109,0x8e90121, sl@0: 0x9360109,0x9360121,0x9370109,0x9370121,0x9380109,0x9380121,0x9390109,0x9390121, sl@0: 0x93a0109,0x93a0121,0x93d0109,0x93d0121,0x93e0109,0x93e0121,0x93f0109,0x93f0121, sl@0: 0x9400109,0x9400121,0x9420109,0x9420121,0x9430109,0x9430121,0x9440109,0x9440111, sl@0: 0x9440121,0x9450109,0x9450121,0x9460109,0x9460121,0x9470109,0x9470121,0x9480109, sl@0: 0x9480121,0x94a0109,0x94a0121,0x94b0109,0x94b0121,0x94c0109,0x94c0121,0x94d0109, sl@0: 0x94d0121,0x94e0109,0x94e0121,0x94f0109,0x94f0121,0x9500109,0x9500121,0x9510109, sl@0: 0x9510121,0x95a0109,0x95a0121,0x9660109,0x9660121,0x96a0109,0x96a0121,0x96e0109, sl@0: 0x96e0121,0x9720109,0x9720121,0x97e0109,0x97e0121,0x9820109,0x9820121,0x98a0109, sl@0: 0x98a0121,0x98e0109,0x98e0121,0x9920109,0x9920121,0x99a0109,0x99a0121,0x99e0109, sl@0: 0x99e0121,0x9a60109,0x9a60121,0x9aa0109,0x9aa0121,0x9ae0109,0x9ae0121,0x9b20109, sl@0: 0x9b20121,0x9ca0109,0x9ca0121,0x9ce0109,0x9ce0121,0x9d20109,0x9d20121,0x9d60109, sl@0: 0x9d60121,0x9e60109,0x9e60121,0x9ea0109,0x9ea0121,0x9f20109,0x9f20121,0x9fe0109, sl@0: 0x9fe0121,0xa020109,0xa020121,0xa0a0109,0xa0a0121,0xa120109,0xa120121,0xa160109, sl@0: 0xa160121,0xa260109,0xa260121,0xa2a0109,0xa2a0121,0xa460109,0xa460121,0xa4e0109, sl@0: 0xa4e0121,0xa660109,0xa660121,0xa6a0109,0xa6a0121,0xa6e0109,0xa6e0121,0xa720109, sl@0: 0xa720121,0xa760109,0xa760121,0xa7a0109,0xa7a0121,0xa820109,0xa820121,0xa860109, sl@0: 0xa860121,0xa8a0109,0xa8a0121, sl@0: }; sl@0: sl@0: static const TUint32 TheIndex[] = sl@0: { sl@0: 0x37,0x10037,0x20037,0x30037,0x40037,0x50037,0x60037,0x70037, sl@0: 0x80037,0x90038,0xa0039,0xb003a,0xc003b,0xd003c,0xe0037,0xf0037, sl@0: 0x100037,0x110037,0x120037,0x130037,0x140037,0x150037,0x160037,0x170037, sl@0: 0x180037,0x190037,0x1a0037,0x1b0037,0x1c0037,0x1d0037,0x1e0037,0x1f0037, sl@0: 0x200040,0x21005d,0x22006a,0x230080,0x24010d,0x250081,0x26007f,0x270063, sl@0: 0x280070,0x290071,0x2a007b,0x2b0096,0x2c005a,0x2d0053,0x2e0061,0x2f007c, sl@0: 0x300115,0x310116,0x320118,0x33011a,0x34011c,0x35011d,0x36011e,0x37011f, sl@0: 0x380120,0x390121,0x3a005c,0x3b005b,0x3c009a,0x3d009b,0x3e009c,0x3f005f, sl@0: 0x40007a,0x410123,0x420128,0x43012a,0x44012c,0x450132,0x460134,0x470137, sl@0: 0x480139,0x49013d,0x4a0140,0x4b0142,0x4c0145,0x4d0149,0x4e014b,0x4f0150, sl@0: 0x500155,0x510157,0x52015a,0x53015c,0x54015f,0x550163,0x560165,0x570167, sl@0: 0x580169,0x59016b,0x5a016d,0x5b0072,0x5c007e,0x5d0073,0x5e0047,0x5f0043, sl@0: 0x600045,0x610122,0x620127,0x630129,0x64012b,0x650131,0x660133,0x670136, sl@0: 0x680138,0x69013c,0x6a013f,0x6b0141,0x6c0143,0x6d0148,0x6e014a,0x6f014f, sl@0: 0x700154,0x710156,0x720159,0x73015b,0x74015e,0x750162,0x760164,0x770166, sl@0: 0x780168,0x79016a,0x7a016c,0x7b0074,0x7c009e,0x7d0075,0x7e00a0,0xa00042, sl@0: 0xa1005e,0xa2010c,0xa3010e,0xa4010b,0xa5010f,0xa6009f,0xa70076,0xa80049, sl@0: 0xa90078,0xaa0124,0xab006e,0xac009d,0xad0052,0xae0079,0xaf004f,0xb0008a, sl@0: 0xb10097,0xb20119,0xb3011b,0xb40044,0xb50187,0xb60077,0xb70062,0xb8004d, sl@0: 0xb90117,0xba0151,0xbb006f,0xbc000a,0xbd0007,0xbe0010,0xbf0060,0xc60126, sl@0: 0xd00130,0xd70099,0xd80153,0xde016f,0xdf0031,0xe60125,0xf0012f,0xf70098, sl@0: 0xf80152,0xfe016e,0x110012e,0x111012d,0x126013b,0x127013a,0x131013e,0x1320025, sl@0: 0x1330023,0x1380158,0x13f0029,0x1400027,0x1410147,0x1420146,0x1490035,0x14a014e, sl@0: 0x14b014d,0x152002f,0x153002d,0x1660161,0x1670160,0x17f015d,0x1920135,0x2c60087, sl@0: 0x2c70088,0x2c90089,0x2d80046,0x2d9004c,0x2da0048,0x2db004e,0x2dd004b,0x30000fe, sl@0: 0x30100fd,0x3020100,0x3030105,0x3040109,0x30600ff,0x3070106,0x3080103,0x30a0102, sl@0: 0x30b0104,0x30c0101,0x30d010a,0x3270107,0x3280108,0x3840044,0x385004a,0x3870062, sl@0: 0x3910171,0x3920173,0x3930175,0x3940177,0x3950179,0x396017b,0x397017d,0x398017f, sl@0: 0x3990181,0x39a0183,0x39b0185,0x39c0188,0x39d018a,0x39e018c,0x39f018e,0x3a00190, sl@0: 0x3a10192,0x3a30194,0x3a40196,0x3a50198,0x3a6019a,0x3a7019c,0x3a8019e,0x3a901a0, sl@0: 0x3b10170,0x3b20172,0x3b30174,0x3b40176,0x3b50178,0x3b6017a,0x3b7017c,0x3b8017e, sl@0: 0x3b90180,0x3ba0182,0x3bb0184,0x3bc0186,0x3bd0189,0x3be018b,0x3bf018d,0x3c0018f, sl@0: 0x3c10191,0x3c20193,0x3c30193,0x3c40195,0x3c50197,0x3c60199,0x3c7019b,0x3c8019d, sl@0: 0x3c9019f,0x40201ae,0x40401b2,0x40501b8,0x40601bc,0x40801be,0x40901c4,0x40a01ca, sl@0: 0x40b01d6,0x40f01e2,0x41001a2,0x41101a4,0x41201a6,0x41301a8,0x41401ac,0x41501b0, sl@0: 0x41601b4,0x41701b6,0x41801ba,0x41a01c0,0x41b01c2,0x41c01c6,0x41d01c8,0x41e01cc, sl@0: 0x41f01ce,0x42001d0,0x42101d2,0x42201d4,0x42301d8,0x42401da,0x42501dc,0x42601de, sl@0: 0x42701e0,0x42801e4,0x42901e6,0x42a01e8,0x42b01ea,0x42c01ec,0x42d01ee,0x42e01f0, sl@0: 0x42f01f2,0x43001a1,0x43101a3,0x43201a5,0x43301a7,0x43401ab,0x43501af,0x43601b3, sl@0: 0x43701b5,0x43801b9,0x43a01bf,0x43b01c1,0x43c01c5,0x43d01c7,0x43e01cb,0x43f01cd, sl@0: 0x44001cf,0x44101d1,0x44201d3,0x44301d7,0x44401d9,0x44501db,0x44601dd,0x44701df, sl@0: 0x44801e3,0x44901e5,0x44a01e7,0x44b01e9,0x44c01eb,0x44d01ed,0x44e01ef,0x44f01f1, sl@0: 0x45201ad,0x45401b1,0x45501b7,0x45601bb,0x45801bd,0x45901c3,0x45a01c9,0x45b01d5, sl@0: 0x45f01e1,0x49001aa,0x49101a9,0x20000041,0x20010041,0x20020041,0x20030041,0x20040041, sl@0: 0x20050041,0x20060041,0x20070042,0x20080041,0x20090041,0x200a0041,0x200b003f,0x200c0037, sl@0: 0x200d0037,0x200e0037,0x200f0037,0x20100054,0x20110055,0x20120056,0x20130057,0x20140058, sl@0: 0x20150059,0x20170051,0x20180064,0x20190065,0x201a0066,0x201b0067,0x201c006b,0x201d006c, sl@0: 0x201e006d,0x20200083,0x20210084,0x20220085,0x20260002,0x2028003d,0x2029003e,0x202a0037, sl@0: 0x202b0037,0x202c0037,0x202d0037,0x202e0037,0x20300082,0x20320086,0x20330005,0x20390068, sl@0: 0x203a0069,0x203c0000,0x203e0050,0x2044007d,0x207f014c,0x20a30110,0x20a40111,0x20a70112, sl@0: 0x20ac0113,0x2105001c,0x21130144,0x2116002b,0x21220033,0x212601a0,0x212e0114,0x215b000d, sl@0: 0x215c0013,0x215d0016,0x215e0019,0x2190008b,0x2191008d,0x2192008c,0x2193008e,0x2194008f, sl@0: 0x21950090,0x21a80091,0x22020092,0x22060093,0x220f0094,0x22110095,0x221200a1,0x221500a2, sl@0: 0x221900a3,0x221a00a4,0x221e00a5,0x221f00a6,0x222900a7,0x222b00a8,0x224800a9,0x226100aa, sl@0: 0x226400ab,0x226500ac,0x230200ad,0x231000ae,0x232000af,0x232100b0,0x250000b1,0x250200b2, sl@0: 0x250c00b3,0x251000b4,0x251400b5,0x251800b6,0x251c00b7,0x252400b8,0x252c00b9,0x253400ba, sl@0: 0x253c00bb,0x255000bc,0x255100bd,0x255200be,0x255300bf,0x255400c0,0x255500c1,0x255600c2, sl@0: 0x255700c3,0x255800c4,0x255900c5,0x255a00c6,0x255b00c7,0x255c00c8,0x255d00c9,0x255e00ca, sl@0: 0x255f00cb,0x256000cc,0x256100cd,0x256200ce,0x256300cf,0x256400d0,0x256500d1,0x256600d2, sl@0: 0x256700d3,0x256800d4,0x256900d5,0x256a00d6,0x256b00d7,0x256c00d8,0x258000d9,0x258400da, sl@0: 0x258800db,0x258c00dc,0x259000dd,0x259100de,0x259200df,0x259300e0,0x25a000e1,0x25a100e2, sl@0: 0x25aa00e3,0x25ab00e4,0x25ac00e5,0x25b200e6,0x25ba00e7,0x25bc00e8,0x25c400e9,0x25ca00ea, sl@0: 0x25cb00eb,0x25cf00ec,0x25d800ed,0x25d900ee,0x25e600ef,0x263a00f0,0x263b00f1,0x263c00f2, sl@0: 0x264000f3,0x264200f4,0x266000f5,0x266300f6,0x266500f7,0x266600f8,0x266a00f9,0x266b00fa, sl@0: 0xfb01001f,0xfb020021,0xfeff0037,0xfffc00fb,0xfffd00fc, sl@0: }; sl@0: sl@0: static const TCollationKeyTable TheStandardTable = sl@0: { TheKey, TheIndex, 517, NULL, NULL, 0 }; sl@0: sl@0: const TCollationKeyTable* StandardCollationMethod() sl@0: { sl@0: return &TheStandardTable; sl@0: }; sl@0: sl@0: inline void Increment(TUint16 const *& aPointer,TBool aNarrow) sl@0: { sl@0: aPointer = aNarrow ? (const TUint16*)(((const TUint8*)aPointer) + 1) : aPointer + 1; sl@0: } sl@0: sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////// sl@0: // TCollationValueIterator sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////// sl@0: sl@0: /** sl@0: Initializes TCollationValueIterator object with a new character sequence. sl@0: @param aSourceIt An iterator used to access the input character (non-normalized or sl@0: normalized) sequence. sl@0: @internalComponent sl@0: */ sl@0: void TCollationValueIterator::SetSourceIt(TUTF32Iterator& aSourceIt) sl@0: { sl@0: iCurrentKeyPos = 0; sl@0: iKey.iKeys = 0; sl@0: iDecompStrIt.Set(aSourceIt); sl@0: } sl@0: sl@0: /** sl@0: Gets current raw key. sl@0: Note: the method may move the iterator one or more positions forward if there are no produced sl@0: collation keys. sl@0: @param aKey A reference to a TCollationKey object, initialized with the sl@0: current collation key after the call, if there is available key. sl@0: @return ETrue Successfull call, aKey initialized with the current collation key, sl@0: EFalse - the iteration has come to the end. sl@0: @internalComponent sl@0: */ sl@0: TBool TCollationValueIterator::GetCurrentKey(TCollationKey& aKey) sl@0: { sl@0: ASSERT(iCurrentKeyPos <= iKey.iKeys); sl@0: if(!ProduceCollationKeys()) sl@0: { sl@0: return EFalse; sl@0: } sl@0: aKey = iKey.iKey[iCurrentKeyPos]; sl@0: return ETrue; sl@0: } sl@0: sl@0: /** sl@0: Gets current key at the specified level. sl@0: Note: the method may move the iterator one or more positions forward if there are no produced sl@0: collation keys. sl@0: @param aLevel Desired level of the collation key: 0..3 sl@0: @param aKey A reference to TUint32 where the retrieved key will be stored. sl@0: @return ETrue Success, EFalse - end of the iteration. sl@0: @internalComponent sl@0: */ sl@0: TBool TCollationValueIterator::GetCurrentKey(TInt aLevel, TUint32& aKey) sl@0: { sl@0: TCollationKey rawKey; sl@0: if(GetCurrentKey(rawKey)) sl@0: { sl@0: //Key values are ignored if their ignore bit is set and the level is less than 3: in other words, the sl@0: //actual Unicode value is never ignored. This does NOT conform to the system of alternate weightings sl@0: //described in Unicode Technical Report 10, and will probably have to be changed. sl@0: aKey = (aLevel < 3 && (rawKey.iLow & TCollationKeyTable::EIgnoreFlag) && !IgnoringNone()) ? 0 : rawKey.Level(aLevel); sl@0: return ETrue; sl@0: } sl@0: return EFalse; sl@0: } sl@0: sl@0: /** sl@0: The method iterates through the controlled character sequence and tries to find first non-zero sl@0: corresponding collation key at the specified level. sl@0: @param aLevel Desired level of the collation key: 0..3 sl@0: @return Non-zero collation key value or 0 if the iteration has come to the end. sl@0: @internalComponent sl@0: */ sl@0: TUint32 TCollationValueIterator::GetNextNonZeroKey(TInt aLevel) sl@0: { sl@0: TUint32 key = 0; sl@0: while(GetCurrentKey(aLevel, key) && key == 0) sl@0: { sl@0: Increment(); sl@0: } sl@0: return key; sl@0: } sl@0: sl@0: /** sl@0: The method determines wheter the specified as a parameter character matches current iterator's sl@0: character. sl@0: If there is a match, the iterator will be moved one position forward. sl@0: Note: the method may move the iterator one or more positions forward if there are no produced sl@0: collation keys. sl@0: @param aMatch The character to compare with the current iterator's character. sl@0: @return ETrue The characters match, EFalse otherwise (or the iteration has come to the end). sl@0: @internalComponent sl@0: */ sl@0: TBool TCollationValueIterator::MatchChar(TChar aMatch) sl@0: { sl@0: TUint32 key; sl@0: if(GetCurrentKey(3, key)) sl@0: { sl@0: // Find a match for the quaternary key.. will probably be the unicode value sl@0: // This is a bit poor. sl@0: if(aMatch == key) sl@0: { sl@0: Increment(); sl@0: return ETrue; sl@0: } sl@0: } sl@0: return EFalse; sl@0: } sl@0: sl@0: /** sl@0: Note: the method may move the iterator one or more positions forward if there are no produced sl@0: collation keys. sl@0: @return The method returns ETrue if the iterator is at a combining character, EFalse otherwise sl@0: (or the iterator has come to the end) sl@0: @internalComponent sl@0: */ sl@0: TBool TCollationValueIterator::AtCombiningCharacter() sl@0: { sl@0: TCollationKey rawKey; sl@0: if(!GetCurrentKey(rawKey)) sl@0: { sl@0: return EFalse; // iteration ended sl@0: } sl@0: return rawKey.IsStarter() ? (TBool)EFalse : (TBool)ETrue; sl@0: } sl@0: sl@0: /** sl@0: Skips the following combining characters if they are. sl@0: Note: the method may move the iterator one or more positions forward. sl@0: @return The number of skipped combining characters. sl@0: @internalComponent sl@0: */ sl@0: TInt TCollationValueIterator::SkipCombiningCharacters() sl@0: { sl@0: TInt count; sl@0: for(count=0;AtCombiningCharacter();++count) sl@0: { sl@0: Increment(); sl@0: } sl@0: return count; sl@0: } sl@0: sl@0: /** sl@0: Moves the iterator one step forward making the next collation key available for getting sl@0: using GetCurrentKey(). sl@0: @return ETrue Successfull call, there is a collation key available. sl@0: EFalse - the iteration has come to the end. sl@0: @internalComponent sl@0: @see TCollationValueIterator::GetCurrentKey() sl@0: */ sl@0: TBool TCollationValueIterator::Increment() sl@0: { sl@0: ASSERT(iCurrentKeyPos <= iKey.iKeys); sl@0: if(!ProduceCollationKeys()) sl@0: { sl@0: return EFalse; sl@0: } sl@0: ++iCurrentKeyPos; sl@0: return ETrue; sl@0: } sl@0: sl@0: /** sl@0: Returns the position in the underlying string of the iteration, sl@0: if this is well defined. It is not well defined if either we are sl@0: half way through keys defined as a string in the collation table sl@0: or if we are half way through a canonically reordered sequence. sl@0: @return The position in the underlying string if this is well sl@0: defined, or 0 if it is not. sl@0: */ sl@0: const TText16* TCollationValueIterator::CurrentPositionIfAtCharacter() sl@0: { sl@0: if (!ProduceCollationKeys()) sl@0: return iCurrentPosition; sl@0: return iCurrentKeyPos == 0? iCurrentPosition : 0; sl@0: } sl@0: sl@0: /** sl@0: Produces the longest possible collation keys sequence using the decomposed character sequence, sl@0: pointed by iDecompStrIt iterator. But this will happen only if all keys from iKey array are sl@0: consumed. sl@0: @return ETrue Successfull call, iKey initialized with the produced collation keys sequence, sl@0: EFalse - the iteration has come to the end. sl@0: @internalComponent sl@0: */ sl@0: TBool TCollationValueIterator::ProduceCollationKeys() sl@0: { sl@0: //iKey.iKeys represents the keys count in iKey array, so load more keys, only if all sl@0: //collation keys are already consumed. sl@0: if(iCurrentKeyPos == iKey.iKeys) sl@0: { sl@0: iCurrentPosition = iDecompStrIt.CurrentPositionIfAtCharacter(); sl@0: if(iDecompStrIt.AtEnd()) sl@0: {//No more characters in the input decomposed canonical string sl@0: return EFalse; sl@0: } sl@0: //Try to get the next collation key sequence. There should be at least one key. sl@0: GetNextRawKeySequence(); sl@0: ASSERT(iKey.iKeys > 0); sl@0: iCurrentKeyPos = 0; sl@0: } sl@0: return ETrue; sl@0: } sl@0: sl@0: /** sl@0: Consume zero or more characters from the input and convert them into zero or more collation keys. sl@0: @internalComponent sl@0: */ sl@0: void TCollationValueIterator::GetNextRawKeySequence() sl@0: { sl@0: //Store the first character combining class type for later use. sl@0: TChar firstChar = iDecompStrIt.Get(0); sl@0: TBool combining = !::IsBaseCharacter(firstChar); sl@0: // Initialise. sl@0: iKey.iCharactersConsumed = 0; sl@0: iKey.iKeys = 0; sl@0: // See if the override table has a key for the current collation unit. sl@0: if(iMethod.iOverrideTable) sl@0: { sl@0: GetKeyFromTable(iMethod.iOverrideTable); sl@0: } sl@0: // If not, try the main table. sl@0: if(iKey.iCharactersConsumed == 0) sl@0: { sl@0: GetKeyFromTable(iMethod.iMainTable); sl@0: } sl@0: //If no key was found use a default value depending on the current character. sl@0: //For CJK characters: sl@0: //the Unicode value itself as the primary key and 1 as the secondary and tertiary keys; sl@0: //the lower 16 bits end up as 0x0105 because the bottom two bits are used for the ignorable bit, sl@0: //which is clear, and the stop bit, which is set. sl@0: //For other characters: sl@0: //Return two keys containing the 21 bits of the character code (anything from 0 to 0x10FFFF), as sl@0: //explained in Unicode Technical Report 10. sl@0: if(iKey.iCharactersConsumed == 0) sl@0: { sl@0: iKey.iCharactersConsumed = 1; sl@0: iDecompStrIt.Next(1); sl@0: iKey.iKeys = ::CreateDefaultCollationKeySequence(firstChar, iKey.iKey); sl@0: } sl@0: if(!combining) sl@0: { sl@0: iKey.iKey[0].iHigh |= (TUint32)TCollationKey::KFlagIsStarter; sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Search for the string aText. sl@0: Put the key index in aIndex if found, otherwise set aIndex to -1. sl@0: If the sought string might be a prefix to a key in the table set aPossiblePrefix to TRUE. sl@0: @internalComponent sl@0: */ sl@0: static void GetStringKey(const TCollationKeyTable* aTable,const TText* aText,TInt aLength, sl@0: TInt& aIndex,TBool& aPossiblePrefix) sl@0: { sl@0: aIndex = -1; sl@0: aPossiblePrefix = EFalse; sl@0: TInt n = aTable->iStringIndices; sl@0: const TUint32* base = aTable->iStringIndex; sl@0: const TUint32* p = base; sl@0: TInt pivot; sl@0: while (n > 0) sl@0: { sl@0: pivot = n / 2; sl@0: p += pivot; sl@0: TUint16 string_index = (TUint16)(*p >> 16); sl@0: const TText* cur_text = aTable->iString + string_index + 1; sl@0: TInt cur_length = aTable->iString[string_index]; sl@0: TInt order = TUnicode::Compare(aText,aLength,cur_text,cur_length); sl@0: if (order == 0) // found it sl@0: { sl@0: aIndex = *p & 0xFFFF; sl@0: aPossiblePrefix = ETrue; sl@0: break; sl@0: } sl@0: if (order < 1 && !aPossiblePrefix) sl@0: { sl@0: if (aLength < cur_length && TUnicode::Compare(aText,aLength,cur_text,aLength) == 0) sl@0: aPossiblePrefix = ETrue; sl@0: n = pivot; sl@0: } sl@0: else sl@0: { sl@0: base = p + 1; sl@0: n -= pivot + 1; sl@0: } sl@0: p = base; sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Consumes output from iDecompStrIt, produces list of keys in iKey. sl@0: @param aTable A const pointer to the collation key table used by the method. sl@0: @internalComponent sl@0: */ sl@0: void TCollationValueIterator::GetKeyFromTable(const TCollationKeyTable* aTable) sl@0: { sl@0: ASSERT(aTable != NULL); sl@0: iKey.iCharactersConsumed = 0; sl@0: iKey.iKeys = 0; sl@0: sl@0: TInt cur_char = iDecompStrIt.Get(0); sl@0: sl@0: // Find the longest matching string. sl@0: TInt index = -1; sl@0: if(aTable->iStringIndices > 0) sl@0: { sl@0: TInt moved = 0; sl@0: TText text[KKeyedStringBufferSize]; sl@0: TInt textLen = 0; sl@0: if (cur_char <= 0xFFFF) sl@0: { sl@0: text[textLen++] = static_cast (cur_char); sl@0: } sl@0: else sl@0: { sl@0: text[textLen++] = GetHighSurrogate(cur_char); sl@0: text[textLen++] = GetLowSurrogate(cur_char); sl@0: } sl@0: TBool possible_prefix = ETrue; sl@0: for(TInt i = 1; (i < KKeyedStringBufferSize) && possible_prefix; i++) sl@0: { sl@0: ++moved; sl@0: TInt c = iDecompStrIt.Get(i);//get the next character sl@0: if(c == -1) sl@0: { sl@0: break; sl@0: } sl@0: if (c <= 0xFFFF) sl@0: { sl@0: text[textLen++] = static_cast (c); sl@0: } sl@0: else sl@0: { sl@0: text[textLen++] = GetHighSurrogate(c); sl@0: text[textLen++] = GetLowSurrogate(c); sl@0: } sl@0: TInt cur_index = -1; sl@0: ::GetStringKey(aTable, text, textLen, cur_index, possible_prefix); sl@0: if(cur_index != -1) sl@0: { sl@0: index = cur_index; sl@0: iKey.iCharactersConsumed = i + 1; sl@0: } sl@0: } sl@0: if (iKey.iCharactersConsumed < moved) sl@0: { sl@0: moved = 0; sl@0: } sl@0: while (moved != iKey.iCharactersConsumed) sl@0: { sl@0: ++moved; sl@0: } sl@0: if(moved > 0) sl@0: { sl@0: iDecompStrIt.Next(moved);//adjust the iterator start position sl@0: } sl@0: } sl@0: sl@0: // Now search the main index. sl@0: if(index == -1) sl@0: { sl@0: index = ::FindCollationKeyIndex(cur_char, *aTable); sl@0: if(0 <= index) sl@0: { sl@0: iKey.iCharactersConsumed = 1; sl@0: iDecompStrIt.Next(1);//adjust the iterator start position sl@0: } sl@0: } sl@0: sl@0: // Fill in the key or keys. sl@0: if(index != -1) sl@0: { sl@0: const TUint32* p = &aTable->iKey[index]; sl@0: TCollationKey* q = iKey.iKey; sl@0: iKey.iKeys = 0; sl@0: while(iKey.iKeys < TKeyInfo::EMaxKeys) sl@0: { sl@0: q->iLow = *p; sl@0: q->iHigh = cur_char; sl@0: iKey.iKeys++; sl@0: if(*p & 1) sl@0: { sl@0: break; sl@0: } sl@0: q++; sl@0: p++; sl@0: } sl@0: } sl@0: } sl@0: sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////// sl@0: // TCollate sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////// sl@0: sl@0: /** sl@0: Construct a TCollate object based on the collation method specified sl@0: within aCharSet, if any. If there is none, or aCharSet is null, the sl@0: standard collation method will be used. sl@0: aMask and aFlags provide a method for overriding the flags in the collation method: sl@0: Each flag set to 1 in aMask is a flag that will be overridden and set to the sl@0: corresponding flag value in aFlags. sl@0: Ownership of aCharSet is not passed. sl@0: @param aCharSet Locale-specific character attribute and collation data sl@0: @param aMask Provides a method for overriding the flags in the collation method sl@0: @param aFlags Provides a method for overriding the flags in the collation method sl@0: @internalComponent sl@0: */ sl@0: TCollate::TCollate(const LCharSet* aCharSet, TUint aMask, TUint aFlags) sl@0: { sl@0: iMethod.iMainTable = NULL; sl@0: iMethod.iOverrideTable = NULL; sl@0: iMethod.iFlags = 0; sl@0: if (aCharSet && aCharSet->iCollationDataSet && aCharSet->iCollationDataSet->iMethod) sl@0: { sl@0: iMethod = aCharSet->iCollationDataSet->iMethod[0]; sl@0: } sl@0: if (iMethod.iMainTable == NULL) sl@0: { sl@0: iMethod.iMainTable = &TheStandardTable; sl@0: } sl@0: if (aMask) sl@0: { sl@0: iMethod.iFlags &= ~aMask; sl@0: iMethod.iFlags |= (aMask & aFlags); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Construct a TCollate object based on an already constructed sl@0: TCollationMethod specified in aMethod. sl@0: Ownership is not passed. sl@0: @param aMethod Collation keys table sl@0: @internalComponent sl@0: */ sl@0: TCollate::TCollate(const TCollationMethod& aMethod) : sl@0: iMethod(aMethod) sl@0: { sl@0: if(!iMethod.iMainTable) sl@0: { sl@0: iMethod.iMainTable = &TheStandardTable; sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Compare the string beginning at aString1 of length aLength1 against the sl@0: string beginning at aString2 of length aLength2. sl@0: sl@0: @param aString1 First string to compare sl@0: @param aLength1 Length of aString1 sl@0: @param aString2 Second string to compare sl@0: @param aLength2 Length of aString2 sl@0: @param aMaxLevel Determines the tightness of the collation. At level 0, only sl@0: character identities are distinguished. At level 1 accents are sl@0: distinguished as well. At level 2 case is distinguished as well. At sl@0: level 3 all non canonically equivalent Unicode characters are considered sl@0: different. By default aMaxLevel is 3. sl@0: @return EStringsIdentical The strings are identical. sl@0: ELeftComparesLessAndIsNotPrefix For example: aString1 = "aaa", aString2 = "zzzz". sl@0: ELeftIsPrefixOfRight For example: aString1 = "abc", aString2 = "abcd". sl@0: ERightIsPrefixOfLeft For example: aString1 = "abcd", aString2 = "abc". sl@0: ERightComparesLessAndIsNotPrefix For example: aString1 = "zzzz", aString2 = "aaa". sl@0: @internalComponent sl@0: */ sl@0: TCollate::TComparisonResult TCollate::Compare(const TUint16 *aString1, TInt aLength1, sl@0: const TUint16 *aString2, TInt aLength2, sl@0: TInt aMaxLevel) const sl@0: { sl@0: TUTF32Iterator itL(aString1, aString1 + aLength1); sl@0: TUTF32Iterator itR(aString2, aString2 + aLength2); sl@0: return CompareKeySequences(itL, itR, aMaxLevel, 0, 0); sl@0: } sl@0: sl@0: /** sl@0: Find the string beginning at aString2 of length aLength2 in the string sl@0: beginning at aString1 of length aLength1. sl@0: sl@0: @param aString1 String to search sl@0: @param aLength1 Length of aString1 sl@0: @param aString2 String to search for sl@0: @param aLength2 Length of aString2 sl@0: @param aMaxLevel Determines the tightness of the collation. At level 0, only sl@0: character identities are distinguished. At level 1 accents are sl@0: distinguished as well. At level 2 case is distinguishes as well. At sl@0: level 3 all valid different Unicode characters are considered different. sl@0: @param aString2WildChar Wild card character which may be specified for aString2. By default sl@0: wild card character is not specified and not used. sl@0: @return KErrNotFound aString2 not found in aString1. sl@0: Non-negative value telling the position in aString1 where the first occurrence of sl@0: aString2 was found. sl@0: @internalComponent sl@0: */ sl@0: TInt TCollate::Find(const TUint16 *aString1, TInt aLength1, sl@0: const TUint16 *aString2, TInt aLength2, sl@0: TInt aMaxLevel, TUint aString2WildChar) const sl@0: { sl@0: TInt dummy(0); sl@0: return Find(aString1, aLength1, aString2,aLength2, dummy, aMaxLevel,aString2WildChar ); sl@0: } sl@0: sl@0: /** sl@0: Find the string beginning at aString2 of length aLength2 in the string sl@0: beginning at aString1 of length aLength1. sl@0: sl@0: @param aString1 String to search sl@0: @param aLength1 Length of aString1 sl@0: @param aString2 String to search for sl@0: @param aLength2 Length of aString2 sl@0: @param aLengthFound A refernce to the length of the match found in the candidate string sl@0: @param aMaxLevel Determines the tightness of the collation. At level 0, only sl@0: character identities are distinguished. At level 1 accents are sl@0: distinguished as well. At level 2 case is distinguishes as well. At sl@0: level 3 all valid different Unicode characters are considered different. sl@0: @param aString2WildChar Wild card character which may be specified for aString2. By default sl@0: wild card character is not specified and not used. sl@0: @return KErrNotFound aString2 not found in aString1. sl@0: Non-negative value telling the position in aString1 where the first occurrence of sl@0: aString2 was found. sl@0: @internalComponent sl@0: */ sl@0: TInt TCollate::Find(const TUint16 *aString1, TInt aLength1, sl@0: const TUint16 *aString2, TInt aLength2, sl@0: TInt &aLengthFound, TInt aMaxLevel, TUint aString2WildChar) const sl@0: { sl@0: TUTF32Iterator itL(aString1, aString1 + aLength1); sl@0: TUTF32Iterator itR(aString2, aString2 + aLength2); sl@0: return FindKeySequence(itL, itR, aMaxLevel, aString2WildChar, 0, aLengthFound); sl@0: } sl@0: sl@0: /** sl@0: Match the pattern defined by aSearchTerm with aCandidate. sl@0: Return the index in aCandidate of the start of the first pattern matched - sl@0: that is, the first character in aSearchTerm after all wild-sequence characters sl@0: have been matched. Return KErrNotFound if there is no match. sl@0: sl@0: For example, if aCandidate is "abcdefghijkl", the following values of aSearchTerm yield the sl@0: following results: sl@0: "abc*" gives 0 sl@0: "abc" gives KErrNotFound sl@0: "xyz" gives KErrNotFound sl@0: "*def" gives KErrNotFound sl@0: "*def*" gives 3 sl@0: "*d?f*" gives 3 sl@0: "a*kl" gives 0 sl@0: "*d*kl" gives 4 sl@0: sl@0: To match a pattern anywhere in aCandidate, aSearchTerm must both start and end sl@0: with aString2WildSequenceChar sl@0: sl@0: @param aCandidate String to search sl@0: @param aCandidateLength Length of aCandidate sl@0: @param aSearchTerm String to search for sl@0: @param aSearchTermLength Length of aSearchTerm sl@0: @param aMaxLevel Determines the tightness of the collation. At level 0, only sl@0: character identities are distinguished. At level 1 accents are sl@0: distinguished as well. At level 2 case is distinguishes as well. At sl@0: level 3 all valid different Unicode characters are considered different. sl@0: @param aWildChar Wild card character which may be specified for aSearchTerm. By default sl@0: the wild card character used is '?'. sl@0: @param aWildSequenceChar Wild card sequence character which may be specified for aSearchTerm. sl@0: Its default value is '*'. sl@0: @param aEscapeChar Escape character. If it is non-zero and precdes aWildChar and aWildSequenceChar characters in sl@0: aCandidate string, then these characters should be treated as normal characters. sl@0: @return The index in aCandidate of the start of the first pattern matched. sl@0: sl@0: @internalComponent. sl@0: */ sl@0: TInt TCollate::Match(const TUint16 *aCandidate, TInt aCandidateLength, sl@0: const TUint16 *aSearchTerm,TInt aSearchTermLength, sl@0: TInt aMaxLevel, TUint aWildChar, TUint aWildSequenceChar, sl@0: TUint aEscapeChar) const sl@0: { sl@0: ASSERT(0 <= aSearchTermLength); sl@0: ASSERT(0 <= aCandidateLength); sl@0: sl@0: if(aMaxLevel == 3 && (iMethod.iFlags & TCollationMethod::EFoldCase)) sl@0: { sl@0: aMaxLevel = 2; sl@0: } sl@0: sl@0: TUTF32Iterator candidate(aCandidate, aCandidate + aCandidateLength); sl@0: TUTF32Iterator searchTerm(aSearchTerm, aSearchTerm + aSearchTermLength); sl@0: sl@0: TInt firstMatch = KErrNotFound; sl@0: TInt segEnd = ::FindCharacter(aWildSequenceChar, aEscapeChar, aSearchTerm, aSearchTermLength); sl@0: sl@0: // Is there any prefix that the candidate string must have? sl@0: // aSearchTerm looks like "abc*...". Then segEnd will be 3 (the position of '*'). sl@0: // Check that aCandidate begins with "abc" too. sl@0: if(segEnd != 0 || aSearchTermLength == 0) sl@0: { sl@0: searchTerm = TUTF32Iterator(aSearchTerm, aSearchTerm + segEnd); sl@0: TComparisonResult order = CompareKeySequences(candidate, searchTerm, aMaxLevel, aWildChar, aEscapeChar); sl@0: if(order != ERightIsPrefixOfLeft && order != EStringsIdentical) sl@0: { sl@0: return KErrNotFound; sl@0: } sl@0: if(aSearchTermLength == segEnd) sl@0: { sl@0: return order == EStringsIdentical ? 0 : KErrNotFound; sl@0: } sl@0: firstMatch = 0; sl@0: } sl@0: sl@0: // search for all remaining segments sl@0: // For example: aSearchTerm = "abc*def*ghi", aCandidate = "abc...". sl@0: // aCandidate was already searched for "abc" and segEnd = 3. sl@0: // Search aCandidate for the remaining segments: "def" and "ghi". sl@0: while(aSearchTermLength != (segEnd + 1)) sl@0: { sl@0: ++segEnd; sl@0: aSearchTermLength -= segEnd; sl@0: aSearchTerm += segEnd; sl@0: segEnd = ::FindCharacter(aWildSequenceChar, aEscapeChar, aSearchTerm, aSearchTermLength); sl@0: searchTerm = TUTF32Iterator(aSearchTerm, aSearchTerm + segEnd);//searchTerm holds the next aSearchTerm segment sl@0: //We will store here the current position of candidate string. sl@0: const TUint16* candidateCurrentPos = candidate.CurrentPosition(); sl@0: TInt dummy(0); sl@0: TInt match = FindKeySequence(candidate, searchTerm, aMaxLevel, aWildChar, aEscapeChar, dummy); sl@0: if (match < 0) sl@0: { sl@0: return KErrNotFound; sl@0: } sl@0: if (aSearchTermLength == segEnd) sl@0: { sl@0: candidate.SetStart(candidateCurrentPos + match); sl@0: TComparisonResult order = CompareKeySequences(candidate, searchTerm, aMaxLevel, aWildChar, aEscapeChar); sl@0: if (order == EStringsIdentical) sl@0: return firstMatch < 0 ? (match + candidateCurrentPos - aCandidate): firstMatch; sl@0: while (match >= 0) sl@0: { sl@0: // We are at the very end of the search term, so this segment must sl@0: // match the end of the candidate string. sl@0: candidate.SetStart(candidateCurrentPos + match + 1); sl@0: candidateCurrentPos = candidate.CurrentPosition(); sl@0: match = FindKeySequence(candidate, searchTerm, aMaxLevel, aWildChar, aEscapeChar, dummy); sl@0: candidate.SetStart(candidateCurrentPos + match); sl@0: order = CompareKeySequences(candidate, searchTerm, aMaxLevel, aWildChar, aEscapeChar); sl@0: if (order == EStringsIdentical) sl@0: return firstMatch < 0 ? (match + candidateCurrentPos - aCandidate): firstMatch; sl@0: } sl@0: return KErrNotFound; sl@0: } sl@0: //Initialize the first match position, if not initialized yet sl@0: if (firstMatch < 0 && segEnd != 0) sl@0: { sl@0: firstMatch = match; sl@0: } sl@0: } sl@0: return firstMatch < 0 ? aCandidateLength : firstMatch; sl@0: } sl@0: sl@0: /** sl@0: Compare values output from the iterators. After the comparison, if sl@0: ERightIsPrefixOfLeft or EStringsIdentical is returned, then aLeft sl@0: will be pointing at the next character (at MaxLevel) after the match. sl@0: If right is shown to be a prefix of left, this means that it has been sl@0: checked at all requested levels. If it is reported that the right is a sl@0: prefix of the left, then this will mean also that there are no unmatched sl@0: combining characters on the left. sl@0: sl@0: @internalComponent sl@0: */ sl@0: TCollate::TComparisonResult TCollate::CompareKeySequences(TUTF32Iterator& aLeft, TUTF32Iterator& aRight, sl@0: TInt aMaxLevel, TInt aRightStringWildChar, TInt aEscapeChar) const sl@0: { sl@0: // Clamp the maximum level of the comparison. sl@0: if(aMaxLevel < 0) sl@0: { sl@0: aMaxLevel = 0; sl@0: } sl@0: if(aMaxLevel > 3) sl@0: { sl@0: aMaxLevel = 3; sl@0: } sl@0: //Case folding forces the maximum level to 2. Case folding could only be done at level 3, which sl@0: //makes use of the actual Unicode values, if we had access to a case conversion table appropriate for sl@0: //the collation method. sl@0: if(aMaxLevel == 3 && (iMethod.iFlags & TCollationMethod::EFoldCase)) sl@0: { sl@0: aMaxLevel = 2; sl@0: } sl@0: TCollationValueIterator itL(iMethod); sl@0: TCollationValueIterator itR(iMethod); sl@0: // Perform the comparison. sl@0: TComparisonResult order = EStringsIdentical; sl@0: TComparisonResult accumulatedOrder = EStringsIdentical; sl@0: const TText16* endOfLeft = 0; sl@0: for (int cur_level = 0; cur_level <= aMaxLevel; cur_level++) sl@0: { sl@0: itL.SetSourceIt(aLeft); sl@0: itR.SetSourceIt(aRight); sl@0: sl@0: for (;;) sl@0: { sl@0: TUint32 c2 = itR.GetNextNonZeroKey(cur_level); sl@0: if (c2 == 0) sl@0: { sl@0: TUint32 more = itL.GetNextNonZeroKey(cur_level); sl@0: if (cur_level == 0) sl@0: endOfLeft = itL.CurrentPositionIfAtCharacter(); sl@0: if (more == 0) sl@0: {//No non-zero keys at all sl@0: order = EStringsIdentical; sl@0: } sl@0: else if (!(TCollationMethod::EIgnoreCombining & iMethod.iFlags) sl@0: && itL.AtCombiningCharacter()) sl@0: { sl@0: order = ERightComparesLessAndIsNotPrefix; sl@0: } sl@0: else sl@0: { sl@0: order = ERightIsPrefixOfLeft; sl@0: } sl@0: break; sl@0: } sl@0: TUint32 c1 = itL.GetNextNonZeroKey(cur_level); sl@0: if (c1 == 0) sl@0: { sl@0: order = ELeftIsPrefixOfRight; sl@0: break; sl@0: } sl@0: sl@0: itL.Increment(); sl@0: if(cur_level == 0 && aEscapeChar != 0 && itR.MatchChar(aEscapeChar)) sl@0: {//Escape character found. Get the next key. sl@0: c2 = itR.GetNextNonZeroKey(cur_level); sl@0: itR.Increment(); sl@0: } sl@0: else sl@0: { sl@0: if(aRightStringWildChar && itR.MatchChar(aRightStringWildChar)) sl@0: { sl@0: itL.SkipCombiningCharacters(); sl@0: itR.SkipCombiningCharacters(); sl@0: c1 = c2; sl@0: } sl@0: else sl@0: { sl@0: itR.Increment(); sl@0: } sl@0: } sl@0: sl@0: // Has an order been determined by key difference? sl@0: if (c1 != c2) sl@0: { sl@0: // Fold to lower case, or switch ordering for case or kana syllabary if necessary. sl@0: if (cur_level == 2 && (c1 <= (0x14 * 4) && c2 <= (0x14 * 4))) sl@0: { sl@0: // Divide keys by 4 to get them back into the range 0..63 sl@0: // because keys returned by GetKey are masked but not shifted. sl@0: c1 /= 4; sl@0: c2 /= 4; sl@0: ProcessKeys(c1, c2, iMethod.iFlags); sl@0: } sl@0: if (c1 != c2) // test equality again because case folding might have made them equal sl@0: { sl@0: order = c1 > c2 ? ERightComparesLessAndIsNotPrefix : ELeftComparesLessAndIsNotPrefix; sl@0: TBool backwards = cur_level == 1 && (iMethod.iFlags & TCollationMethod::EAccentsBackwards); sl@0: if (order && !backwards) sl@0: { sl@0: break; sl@0: } sl@0: } sl@0: } sl@0: } sl@0: if (accumulatedOrder != order && order != EStringsIdentical) sl@0: { sl@0: if (accumulatedOrder == ERightIsPrefixOfLeft) sl@0: { sl@0: return ERightComparesLessAndIsNotPrefix; sl@0: } sl@0: else if (accumulatedOrder == ELeftIsPrefixOfRight) sl@0: { sl@0: return ELeftComparesLessAndIsNotPrefix; sl@0: } sl@0: else sl@0: { sl@0: // accumulatedOrder == EStringsIdentical sl@0: if (order == ELeftComparesLessAndIsNotPrefix || order == ERightComparesLessAndIsNotPrefix) sl@0: { sl@0: return order; sl@0: } sl@0: } sl@0: accumulatedOrder = order; sl@0: } sl@0: } sl@0: sl@0: if (accumulatedOrder == EStringsIdentical || accumulatedOrder == ERightIsPrefixOfLeft) sl@0: { sl@0: if (endOfLeft) sl@0: { sl@0: aLeft.SetStart(endOfLeft); sl@0: } sl@0: else if (accumulatedOrder == ERightIsPrefixOfLeft) sl@0: { sl@0: accumulatedOrder = ERightComparesLessAndIsNotPrefix; sl@0: } sl@0: } sl@0: return accumulatedOrder; sl@0: } sl@0: sl@0: /** sl@0: Finds search term inside candidate string. Returns KErrNotFound if there sl@0: is no match, returns the offset into the candidate string at which the sl@0: search term was found. If a string was found, the search term iterator is left sl@0: pointing at the end of the search term, and the candidate iterator is sl@0: left pointing just after the matched keys. aMatchPos returns where in sl@0: the candidate string the match was found. sl@0: sl@0: @internalComponent sl@0: */ sl@0: TInt TCollate::FindKeySequence(TUTF32Iterator& aCandidate, TUTF32Iterator& aSearchTerm, sl@0: TInt aMaxLevel, TInt aWildChar, TInt aEscapeChar, TInt& aLengthFound) const sl@0: { sl@0: TInt matchOffset = 0; sl@0: //Save the start of the candidate string sl@0: const TText* candidateStart = aCandidate.CurrentPosition(); sl@0: //Create copies of aCandidate and aSearchTerm sl@0: TUTF32Iterator candidateCopy(aCandidate); sl@0: TUTF32Iterator searchTermCopy(aSearchTerm); sl@0: aLengthFound = KErrNotFound; sl@0: //Do the search sl@0: for(;;) sl@0: { sl@0: TComparisonResult order = CompareKeySequences(aCandidate, aSearchTerm, aMaxLevel, aWildChar, aEscapeChar); sl@0: if(order == ELeftIsPrefixOfRight) sl@0: { sl@0: return KErrNotFound; sl@0: } sl@0: if(order == ERightIsPrefixOfLeft || order == EStringsIdentical) sl@0: { sl@0: aLengthFound = (aCandidate.CurrentPosition() - candidateStart) - matchOffset; sl@0: return matchOffset; sl@0: } sl@0: sl@0: aCandidate = candidateCopy; sl@0: aCandidate.Next(); sl@0: ::SkipCombiningCharacters(aCandidate); sl@0: candidateCopy = aCandidate; sl@0: sl@0: matchOffset = aCandidate.CurrentPosition() - candidateStart; sl@0: sl@0: aSearchTerm = searchTermCopy; sl@0: } sl@0: }