1 // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\euser\us_func.cpp

    15 // 

    16 //

    17 

    18 #ifdef __TOOLS2__

    19 #include <stdlib.h>

    20 #include <stdio.h>

    21 #endif

    22 

    23 #include "us_std.h"

    24 //#define __DEBUG_IMAGE__ 1

    25 #if defined(__DEBUG_IMAGE__) && defined (__EPOC32__)

    26 #include "e32svr.h" 

    27 #define __IF_DEBUG(t) {RDebug debug;debug.t;}

    28 #else

    29 #define __IF_DEBUG(t)

    30 #endif

    31 #ifdef _UNICODE

    32 #include <collate.h>

    33 #include "compareimp.h"

    34 #endif

    35 

    36 #include "us_data.h"

    37 

    38 typedef union

    39 	{

    40 	TAny *tany;

    41 	TText8 *ttext8;

    42 	TText16 *ttext16;

    43 	TDesC8 *tdesc8;

    44 	TDesC16 *tdesc16;

    45 	TInt8 *tint8;

    46 	TInt16 *tint16;

    47 	TInt32 *tint32;

    48 	TInt64 *tint64;

    49 	TInt *tint;

    50 	TUint8 *tuint8;

    51 	TUint16 *tuint16;

    52 	TUint32 *tuint32;

    53 	TUint *tuint;

    54 	} UPTR;

    55 

    56 const TUint crcTab[256] =

    57     {

    58 	0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,0x8108,0x9129,0xa14a,

    59 	0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,

    60 	0x72f7,0x62d6,0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,0x2462,

    61 	0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,0xa56a,0xb54b,0x8528,0x9509,

    62 	0xe5ee,0xf5cf,0xc5ac,0xd58d,0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,

    63 	0x46b4,0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,0x48c4,0x58e5,

    64 	0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,

    65 	0x9969,0xa90a,0xb92b,0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,

    66 	0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,0x6ca6,0x7c87,0x4ce4,

    67 	0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,

    68 	0x8d68,0x9d49,0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,0xff9f,

    69 	0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,0x9188,0x81a9,0xb1ca,0xa1eb,

    70 	0xd10c,0xc12d,0xf14e,0xe16f,0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,

    71 	0x6067,0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,0x02b1,0x1290,

    72 	0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,

    73 	0xe54f,0xd52c,0xc50d,0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,

    74 	0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,0x26d3,0x36f2,0x0691,

    75 	0x16b0,0x6657,0x7676,0x4615,0x5634,0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,

    76 	0xb98a,0xa9ab,0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,0xcb7d,

    77 	0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,0x4a75,0x5a54,0x6a37,0x7a16,

    78 	0x0af1,0x1ad0,0x2ab3,0x3a92,0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,

    79 	0x8dc9,0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,0xef1f,0xff3e,

    80 	0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,

    81 	0x3eb2,0x0ed1,0x1ef0

    82     };

    83 

    84 const TInt KQDepth=150; // Maximum queue depth

    85 

    86 LOCAL_C TUint checkSum(const TAny *aPtr)

    87 //

    88 // Checksum every other byte

    89 //

    90 	{

    91 

    92 	const TUint8* pB=(const TUint8*)aPtr;

    93 	const TUint8* pE=pB+(KMaxCheckedUid*sizeof(TUid));

    94 	TUint8 buf[(KMaxCheckedUid*sizeof(TUid))>>1];

    95 	TUint8* pT=(&buf[0]);

    96 	while (pB<pE)

    97 		{

    98 		*pT++=(*pB);

    99 		pB+=2;

   100 		}

   101 	TUint16 crc=0;

   102 	Mem::Crc(crc,&buf[0],(KMaxCheckedUid*sizeof(TUid))>>1);

   103 	return(crc);

   104 	}

   105 	

   106 LOCAL_C TInt partit(TInt n,TInt m,const TKey &aKey,const TSwap &aSwap)

   107 //

   108 // Partition n elements of array stating from element m, 

   109 // return element no. of partition point. 

   110 //

   111 	{

   112 

   113 	TInt i=m-1;

   114 	TInt j=i+n;

   115 	TInt pivlin=j;

   116 	aSwap.Swap((j+m)>>1,j);

   117 	while (i<j) 

   118 		{

   119 		for (i++;aKey.Compare(i,pivlin)<0;i++)

   120 			{

   121 			}

   122 		for (--j;j>i;j--)

   123 			{

   124 			if (aKey.Compare(j,pivlin)<=0)

   125 				break;

   126 			}

   127 		if (i<j)

   128 			aSwap.Swap(i,j);

   129 		}

   130 	aSwap.Swap(i,m+n-1);

   131 	return(i);

   132 	}

   133 

   134 #ifdef __TOOLS2__

   135 extern TPckgBuf<TExtendedLocale> gLocale;

   136 extern TBool gLocalSet;

   137 #endif

   138 

   139 static const TCollationMethod TheCollationMethod[] =

   140 	{

   141 		{

   142 		KUidBasicCollationMethod,				// this is the standard unlocalised method

   143 		NULL,									// null means use the standard table

   144 		NULL,									// there's no override table

   145 		0										// the flags are standard

   146 		}

   147 	};

   148 

   149 static const TCollationDataSet TheCollationDataSet =

   150 	{

   151 	TheCollationMethod,

   152 	1

   153 	};

   154 

   155 // The one and only locale character set object.

   156 const LCharSet TheCharSet =

   157 	{

   158 	NULL,

   159 	&TheCollationDataSet

   160 	};

   161 

   162 const LCharSet* GetLocaleDefaultCharSet()

   163 	{

   164 	return &TheCharSet;

   165 	}

   166 

   167 const LCharSet* GetLocaleCharSet()

   168 	{

   169 #ifndef __TOOLS2__

   170 	const LCharSet* charSet = (const LCharSet*)Exec::GetGlobalUserData(ELocaleDefaultCharSet);

   171 #else

   172 	const LCharSet* charSet = gLocale().GetDefaultCharSet();

   173 #endif // __TOOLS2__

   174 	if(charSet)

   175 		return charSet;

   176 	return &TheCharSet;

   177 	}

   178 

   179 const LCharSet* GetLocalePreferredCharSet()

   180 	{

   181 #ifndef __TOOLS2__

   182 	const LCharSet* charSet = (const LCharSet*)Exec::GetGlobalUserData(ELocalePreferredCharSet);

   183 #else

   184 	const LCharSet* charSet = gLocale().GetPreferredCharSet();

   185 #endif // __TOOLS2__

   186 	if(charSet)

   187 		return charSet;

   188 	return &TheCharSet;

   189 	}

   190 

   191 EXPORT_C TCollationMethod TExtendedLocale::GetPreferredCollationMethod(TInt aIndex)

   192 /**

   193 Get the preferred collation method for the preferred charset.

   194 

   195 Note that some charsets may contain more than one collation

   196 method (e.g "dictionary" v "phonebook" ordering) so an optional

   197 index parameter can be used to select between them.

   198 

   199 @param aIndex Optional parameter specifying the index of the collation 

   200               method in the locale to get. This is the responsibility of 

   201 			  the caller to make sure that the index is less than the total 

   202 			  number of collation methods in the preferred charset in this locale.

   203 

   204 @return TCollationMethod representing the requested collation method.

   205 

   206 @panic USER 185 In both debug and release builds, if either the current charset 

   207        is not set up or aIndex is greater than or equal to the total number of 

   208 	   collation methods in the preferred charset in this locale.

   209 

   210 @see TCollationMethod

   211 */

   212 	{

   213 	__ASSERT_ALWAYS(iPreferredCharSet && (TUint(aIndex)<=TUint(iPreferredCharSet->iCollationDataSet->iMethods)), Panic(EBadLocaleParameter));

   214 	return iPreferredCharSet->iCollationDataSet->iMethod[aIndex];

   215 	}

   216 

   217 extern const TUint8 __FoldCollTab8[256];

   218 

   219 EXPORT_C TInt Mem::CompareF(const TUint8 *aLeft,TInt aLeftL,const TUint8 *aRight,TInt aRightL)

   220 /**

   221 Compares a block of data at one specified location with a block of data at 

   222 another specified location, using the standard folding method appropriate 

   223 to the current locale.

   224 

   225 @param aLeft   A pointer to the first (or left) block of 8 bit data to be

   226                compared.

   227 @param aLeftL  The length of the first (or left) block of data to be compared, 

   228                i.e. the number of bytes.

   229 @param aRight  A pointer to the second (or right) block of 8 bit data to be 

   230                compared.

   231 @param aRightL The length of the second (or right) block of data to be

   232                compared, i.e. the number of bytes.

   233 

   234 @return Positive, if the first (or left) block of data is greater than the 

   235         second (or right) block of data.

   236         Negative, if the first (or left) block of data is less than the second

   237         (or right) block of data.

   238         Zero, if both the first (or left) and second (or right) blocks of data

   239         have the same length and the same content. 

   240         

   241 @see Mem::Compare

   242 */

   243 	{

   244 

   245 	__ASSERT_DEBUG(aLeftL>=0,Panic(EMemLeftNegative));

   246 	__ASSERT_DEBUG(aRightL>=0,Panic(EMemRightNegative));

   247 	const TUint8 *pE=aLeft+Min(aLeftL,aRightL);

   248 	const TUint8* table=__FoldCollTab8;

   249     while (aLeft<pE)

   250 		{

   251 		TUint l=*aLeft++;

   252 		TUint r=*aRight++;

   253 		l = table[l];

   254 		r = table[r];

   255 		TInt d=l-r;

   256 		if (d!=0)

   257 		    return(d);

   258 		}

   259     return(aLeftL-aRightL);

   260 	}

   261 

   262 

   263 

   264 

   265 EXPORT_C TInt Mem::CompareC(const TUint8 *aLeft,TInt aLeftL,const TUint8 *aRight,TInt aRightL)

   266 /**

   267 Compares a block of data at one specified location with a block of data at 

   268 another specified location using the standard collation method appropriate 

   269 to the current locale.

   270 

   271 @param aLeft   A pointer to the first (or left) block of 8 bit data to be

   272                compared.

   273 @param aLeftL  The length of the first (or left) block of data to be compared 

   274                i.e. the number of bytes.

   275 @param aRight  A pointer to the second (or right) block of 8 bit data to be 

   276                compared.

   277 @param aRightL The length of the second (or right) block of data to be compared 

   278                i.e. the number of bytes.

   279 

   280 @return Positive, if the first (or left) block of data is greater than the 

   281         second (or right) block of data.

   282         Negative, if the first (or left) block of data is less than the second

   283         (or right) block of data.

   284         Zero, if both the first (or left) and second (or right) blocks of data

   285         have the same length and the same content.

   286         

   287 @see Mem::Compare

   288 @deprecated

   289 */

   290 	{

   291 	return Mem::CompareF(aLeft, aLeftL, aRight, aRightL);

   292 	}

   293 

   294 

   295 

   296 

   297 EXPORT_C TInt Mem::Compare(const TUint16 *aLeft,TInt aLeftL,const TUint16 *aRight,TInt aRightL)

   298 /**

   299 Compares a block of data at one specified location with a block of data at 

   300 another specified location.

   301 

   302 The comparison proceeds on a double-byte for double-byte basis, the result 

   303 of the comparison is based on the difference of the first pair of bytes to 

   304 disagree.

   305 

   306 The data at the two locations are equal if they have the same length and content. 

   307 Where the lengths are different and the shorter section of data is the same 

   308 as the first part of the longer section of data, the shorter is considered 

   309 to be less than the longer.

   310 

   311 @param aLeft   A pointer to the first (or left) block of 16 bit data to be

   312                compared.

   313 @param aLeftL  The length of the first (or left) block of data to be compared 

   314                i.e. the number of double-bytes. 

   315 @param aRight  A pointer to the second (or right) block of 16 bit data to be 

   316                compared.

   317 @param aRightL The length of the second (or right) block of data to be compared 

   318                i.e. the number of double-bytes.

   319 

   320 @return Positive, if the first (or left) block of data is greater than the 

   321         second (or right) block of data.

   322         Negative, if the first (or left) block of data is less than the second

   323         (or right) block of data.

   324         Zero, if both the first (or left) and second (or right) blocks of data

   325         have the same length and the same content.

   326 */

   327 	{

   328 

   329 	__ASSERT_DEBUG(aLeftL>=0,Panic(EMemLeftNegative));

   330 	__ASSERT_DEBUG(aRightL>=0,Panic(EMemRightNegative));

   331 	const TUint16 *pE=aLeft+Min(aLeftL,aRightL);

   332     while (aLeft<pE)

   333 		{

   334 		TInt d=(*aLeft++)-(*aRight++);

   335 		if (d!=0)

   336 		    return(d);

   337 		}

   338     return(aLeftL-aRightL);

   339 	}

   340 

   341 

   342 

   343 

   344 EXPORT_C TInt Mem::CompareF(const TUint16 *aLeft,TInt aLeftL,const TUint16 *aRight,TInt aRightL)

   345 /**

   346 Compares a block of data at one specified location with a block of data at 

   347 another specified location, using the standard folding method appropriate 

   348 to the current locale.

   349 

   350 @param aLeft   A pointer to the first (or left) block of 16 bit data to be

   351                compared.

   352 @param aLeftL  The length of the first (or left) block of data to be compared 

   353                i.e. the number of double-bytes.

   354 @param aRight  A pointer to the second (or right) block of 16 bit data to be 

   355                compared.

   356 @param aRightL The length of the second (or right) block of data to be compared 

   357                i.e the number of double-bytes.

   358 

   359 @return Positive, if the first (or left) block of data is greater than the 

   360         second (or right) block of data.

   361         Negative, if the first (or left) block of data is less than the second

   362         (or right) block of data.

   363         Zero, if both the first (or left) and second (or right) blocks of data

   364         have the same length and the same content.

   365         

   366 @see Mem::Compare

   367 */

   368 	{

   369 	__ASSERT_DEBUG(aLeftL >= 0,Panic(EMemLeftNegative));

   370 	__ASSERT_DEBUG(aRightL >= 0,Panic(EMemRightNegative));

   371 

   372 	const TText16* aLeftEnd = aLeft + aLeftL;

   373 	const TText16* aRightEnd = aRight + aRightL;

   374 	

   375 	const TUint8* table=__FoldCollTab8;

   376 

   377 	while (aLeft != aLeftEnd)

   378 		{

   379 		if (aRight == aRightEnd)

   380 			return 1;

   381 

   382 		TUint l = *aLeft;

   383 		TUint r = *aRight;

   384 

   385 		// check if character is Ascii, if so treat as Ascii

   386 		if (l < 128 && r < 128)

   387 			{

   388 			l = table[l];

   389 			r = table[r];

   390 

   391 			if (r != l)

   392 				return l-r;

   393 			

   394 			aLeft++;

   395 			aRight++;

   396 			}

   397 		// covers Unicode characters...

   398 		else

   399 			{

   400 			TUTF32Iterator leftIt(aLeft, aLeftEnd);

   401 			TUTF32Iterator rightIt(aRight, aRightEnd);

   402 			return ::CompareFolded(leftIt, rightIt);

   403 			}

   404 		}

   405 

   406 	return aRight == aRightEnd? 0:-1;

   407 	}

   408 	

   409 

   410 

   411 

   412 

   413 EXPORT_C TInt Mem::CompareC(const TUint16 *aLeft,TInt aLeftL,const TUint16 *aRight,TInt aRightL)

   414 /**

   415 Compares a block of data at one specified location with a block of data at 

   416 another specified location using the standard collation method appropriate 

   417 to the current locale.

   418 

   419 @param aLeft   A pointer to the first (or left) block of 16 bit data to be

   420                compared.

   421 @param aLeftL  The length of the first (or left) block of data to be compared 

   422                i.e. the number of double-bytes).

   423 @param aRight  A pointer to the second (or right) block of 16 bit data to be 

   424                compared.

   425 @param aRightL The length of the second (or right) block of data to be compared 

   426                i.e. the number of double-bytes. 

   427                

   428 @return Positive, if the first (or left) block of data is greater than the 

   429         second (or right) block of data.

   430         Negative, if the first (or left) block of data is less than the second

   431         (or right) block of data.

   432         Zero, if both the first (or left) and second (or right) blocks of data

   433         have the same length and the same content. 

   434         

   435 @see Mem::Compare

   436 */

   437 	{

   438 	__ASSERT_DEBUG(aLeftL>=0,Panic(EMemLeftNegative));

   439 	__ASSERT_DEBUG(aRightL>=0,Panic(EMemRightNegative));

   440 #ifdef _UNICODE

   441 	TCollate c(GetLocaleCharSet());

   442 	return c.Compare(aLeft,aLeftL,aRight,aRightL);

   443 #else

   444 	const TUint16 *pE=aLeft+Min(aLeftL,aRightL);

   445     while (aLeft<pE)

   446 		{

   447 		TInt d=User::Collate(*aLeft++)-User::Collate(*aRight++);

   448 		if (d!=0)

   449 		    return(d);

   450 		}

   451     return(aLeftL-aRightL);

   452 #endif

   453 	}

   454 

   455 

   456 

   457 

   458 #ifdef _UNICODE

   459 EXPORT_C TInt Mem::CompareC(const TUint16* aLeft,TInt aLeftL,const TUint16* aRight,TInt aRightL,

   460 							TInt aMaxLevel,const TCollationMethod* aCollationMethod)

   461 /**

   462 Compares a block of data at one location with a block of data at another location 

   463 using the specified collation method and collating to the specified maximum 

   464 collation level.

   465 

   466 If no collation method is supplied, a default method, appropriate to the current 

   467 locale, is used.

   468 

   469 This function is only defined for 16 bit (Unicode) build variants. This means 

   470 that the function is not defined for 8 bit build variants, even when an explicit 

   471 16 bit descriptor is used.

   472 

   473 @param aLeft            A pointer to the first (or left) block of 16 bit data

   474                         to be compared.

   475 @param aLeftL           The length of the first (or left) block of data to be

   476                         compared. This is the number of double-bytes. 

   477 @param aRight           A pointer to the second (or right) block of 16 bit data

   478                         to be compared.

   479 @param aRightL          The length of the second (or right) block of data to be

   480                         compared. This is the number of double-bytes. 

   481 @param aMaxLevel        The maximum collation level. 

   482 @param aCollationMethod A pointer to the collation method or NULL. 

   483 

   484 @return Positive, if this descriptor is greater than the specified descriptor. 

   485         Negative, if this descriptor is less than the specified descriptor.

   486         Zero, if both descriptors have the same length and their contents

   487         are the same.

   488 */

   489 	{

   490 	__ASSERT_DEBUG(aLeftL>=0,Panic(EMemLeftNegative));

   491 	__ASSERT_DEBUG(aRightL>=0,Panic(EMemRightNegative));

   492 	if (aCollationMethod == NULL)

   493 		{

   494 		TCollate c(GetLocaleCharSet());

   495 		return c.Compare(aLeft,aLeftL,aRight,aRightL,aMaxLevel);

   496 		}

   497 	else

   498 		{

   499 		TCollate c(*aCollationMethod);

   500 		return c.Compare(aLeft,aLeftL,aRight,aRightL,aMaxLevel);

   501 		}

   502 	}

   503 #endif

   504 

   505 

   506 

   507 

   508 #ifdef _UNICODE

   509 EXPORT_C TInt Mem::CollationMethods()

   510 /**

   511 Gets the number of collation methods in this locale.

   512 

   513 This function is only defined for 16 bit (Unicode) build variants. This means 

   514 that the function is not defined for 8 bit build variants, even when an

   515 explicit 16 bit descriptor is used.

   516 

   517 @return The number of collation methods.

   518 */

   519 	{

   520 	return GetLocaleCharSet()->iCollationDataSet->iMethods;

   521 	}

   522 #endif

   523 

   524 

   525 

   526 

   527 #ifdef _UNICODE

   528 EXPORT_C TUint Mem::CollationMethodId(TInt aIndex)

   529 /**

   530 Gets the Uid associated with the specified collation method.

   531 

   532 This function is only defined for 16 bit (Unicode) build variants. This means 

   533 that the function is not defined for 8 bit build variants, even when an

   534 explicit 16 bit descriptor is used.

   535 

   536 @param aIndex An index into the set of collation methods in thie locale. This 

   537               value is relative to zero; i.e. a zero value refers to the first

   538               collation method. This value must not be negative, and must be

   539               less than the total number of collation methods in this locale.

   540 

   541 @return The Uid of the collation method.

   542 

   543 @panic USER 132 In debug builds only, if aIndex is negative or is greater than

   544        or equal to the total number of collation methods in this locale.

   545 */

   546 	{

   547 	const TCollationDataSet* s = GetLocaleCharSet()->iCollationDataSet;

   548 	__ASSERT_DEBUG(aIndex >= 0 && aIndex < s->iMethods,Panic(EBadCollationRulesIndex));

   549 	return s->iMethod[aIndex].iId;

   550 	}

   551 #endif

   552 

   553 

   554 

   555 

   556 #ifdef _UNICODE

   557 EXPORT_C const TCollationMethod* Mem::CollationMethodByIndex(TInt aIndex)

   558 /**

   559 Gets the collation method identified by the specified index.

   560 

   561 This function is only defined for 16 bit (Unicode) build variants. This means 

   562 that the function is not defined for 8 bit build variants, even when an

   563 explicit 16 bit descriptor is used.

   564 

   565 @param aIndex An index into the set of collation methods in this locale. This 

   566               value is relative to zero; i.e. a zero value refers to the first

   567               collation method. This value must not be negative, and must be

   568               less than the total number of collation methods in this locale.

   569               

   570 @return A pointer to the collation method.

   571 

   572 @panic USER 132 In debug builds only, if aIndex is negative or is greater than

   573        or equal to the total number of collation methods in this locale.

   574 */

   575 	{

   576 	const TCollationDataSet* s = GetLocaleCharSet()->iCollationDataSet;

   577 	__ASSERT_DEBUG(aIndex >= 0 && aIndex < s->iMethods,Panic(EBadCollationRulesIndex));

   578 	return &s->iMethod[aIndex];

   579 	}

   580 #endif

   581 

   582 

   583 

   584 

   585 #ifdef _UNICODE

   586 EXPORT_C const TCollationMethod* Mem::CollationMethodById(TUint aId)

   587 /**

   588 Gets the collation method identified by the specified Uid.

   589 

   590 This function is only defined for 16 bit (Unicode) build variants. This means 

   591 that the function is not defined for 8 bit build variants, even when an

   592 explicit 16 bit descriptor is used.

   593 

   594 @param aId The Uid of a collation method in the set of collation methods in 

   595            this locale. 

   596            

   597 @return A pointer to the collation method.

   598 */

   599 	{

   600 	const TCollationDataSet* set = GetLocaleCharSet()->iCollationDataSet;

   601 	const TCollationMethod* method = set->iMethod;

   602 	const TCollationMethod* m = method;

   603 	int methods = set->iMethods;

   604 	for (int i = 0; i < methods; i++, m++)

   605 		if (m->iId == aId)

   606 			{

   607 			method = m;

   608 			break;

   609 			}

   610 	return method;

   611 	}

   612 #endif

   613 

   614 #ifdef _UNICODE

   615 EXPORT_C const TCollationMethod* Mem::GetDefaultMatchingTable()

   616 /**

   617 Gets the collation method specific for matching purpose.

   618 

   619 This function is only defined for 16 bit (Unicode) build variants. This means 

   620 that the function is not defined for 8 bit build variants, even when an

   621 explicit 16 bit descriptor is used.

   622 

   623 @return A pointer to the collation method

   624 */

   625 	{

   626 	const TCollationDataSet* set=GetLocaleCharSet()->iCollationDataSet;

   627 	const TCollationMethod* method=set->iMethod;

   628 	const TCollationMethod* m= method;

   629 	int methods = set->iMethods;

   630 	for (; methods-->0; m++)

   631 		if (m->iFlags & TCollationMethod::EMatchingTable)

   632 			{

   633 			method=m;

   634 			break;

   635 			}

   636 	return method;

   637 	}

   638 #endif

   639 

   640 

   641 #if !defined(__MEM_MACHINE_CODED__)

   642 EXPORT_C void Mem::Swap(TAny *aPtr1,TAny *aPtr2,TInt aLength)

   643 /**

   644 Swaps a number of bytes of data between two specified locations.

   645 

   646 The source and target areas can overlap.

   647 

   648 @param aPtr1   A pointer to the first location taking part in the swap. 

   649 @param aPtr2   A pointer to second location taking part in the swap. 

   650 @param aLength The number of bytes to be swapped between the two locations. 

   651                This value must not be negative.

   652 

   653 @panic USER 94 In debug builds only, if aLength is negative.

   654 */

   655 	{

   656 

   657 	__ASSERT_DEBUG(aLength>=0,Panic(EMemSwapLengthNegative));

   658 	if (aPtr1==aPtr2)

   659 		return;

   660 	TUint8 *pT=(TUint8 *)aPtr1;

   661 	TUint8 *pE=pT+aLength;

   662 	TUint8 *pS=(TUint8 *)aPtr2;

   663 	while (pT<pE)

   664 		{

   665 		TUint b=(*pT);

   666 		*pT++=(*pS);

   667 		*pS++=(TUint8)b;

   668 		}

   669 	}

   670 #endif

   671 

   672 

   673 

   674 

   675 EXPORT_C void Mem::Crc(TUint16& aCrc,const TAny* aPtr,TInt aLength)

   676 /**

   677 Performs a CCITT CRC checksum on the specified data.

   678 

   679 On return from this function, the referenced 16 bit integer contains the checksummed 

   680 value.

   681 

   682 @param aCrc    A reference to a 16 bit integer to contain the checksummed value. 

   683 @param aPtr    A pointer to the start of the data to be checksummed. 

   684 @param aLength The length of the data to be checksummed.

   685 */

   686 	{

   687 

   688 	const TUint8* pB=(const TUint8*)aPtr;

   689 	const TUint8* pE=pB+aLength;

   690 	TUint crc=aCrc;

   691     while (pB<pE)

   692 		crc=(crc<<8)^crcTab[((crc>>8)^*pB++)&0xff];

   693 	aCrc=(TUint16)crc;

   694 	}

   695 

   696 

   697 

   698 

   699 EXPORT_C TInt User::StringLength(const TUint8 *aString)

   700 /**

   701 Gets the length of a C style, null terminated, string of single-byte valued 

   702 characters.

   703 

   704 The length does not include the null terminator.

   705 

   706 @param aString A pointer to the single byte valued, null terminated, string.

   707 

   708 @return The length of the string.

   709 */

   710 	{

   711 

   712 	const TUint8 *pS=aString;

   713 	while (*pS)

   714 		pS++;

   715 	return(pS-aString);

   716 	}

   717 

   718 

   719 

   720 

   721 EXPORT_C TInt User::StringLength(const TUint16 *aString)

   722 /**

   723 Gets the length of a C style, null terminated, string of double-byte valued 

   724 characters.

   725 

   726 The length does not include the null terminator.

   727 

   728 @param aString A pointer to the double-byte valued, null terminated, string.

   729 

   730 @return The length of the string.

   731 */

   732 	{

   733 

   734 	const TUint16 *pS=aString;

   735 	while (*pS)

   736 		pS++;

   737 	return(pS-aString);

   738 	}

   739 

   740 #ifdef __TOOLS2__

   741 

   742 TPanicHandler gPanicHandler = NULL;

   743 

   744 EXPORT_C void User::Panic(const TDesC &aCategory,TInt aReason)

   745 	{

   746 	if (gPanicHandler != NULL) 

   747 		{

   748 		TRAPD(r, (*gPanicHandler)(aCategory, aReason));		

   749 		return;

   750 		}

   751 	TBuf8<17> cat;

   752 	cat.Copy(aCategory.Left(16));

   753 	fprintf(stderr, "PANIC - %s: %d\n", cat.PtrZ(), aReason);

   754 	exit(2);

   755 	}

   756 

   757 #else

   758 EXPORT_C void User::Panic(const TDesC &aCategory,TInt aReason)

   759 /**

   760 Panics the current thread, specifying a category name and panic number.

   761 

   762 Keep the length of the category name small; it is limited to 16 characters.

   763 

   764 @param aCategory A reference to the descriptor containing the text that defines 

   765                  the category for this panic.

   766 @param aReason   The panic number.

   767 */

   768 	{

   769 

   770 	__IF_DEBUG(Print(_L("User::Panic %S %d\n"),&aCategory,aReason));

   771 	TPtrC cat16(aCategory.Ptr(),Min(KMaxExitCategoryName,aCategory.Length()));

   772 	TBuf8<KMaxExitCategoryName> cat;

   773 	cat.Copy(cat16);

   774 	ExitCurrentThread(EExitPanic,aReason,&cat);

   775 	}

   776 

   777 

   778 

   779 

   780 void CallStaticEntryPoints(TBool aInit)

   781 	{

   782 	TLinAddr ep[KMaxLibraryEntryPoints];

   783 	TInt numEps=KMaxLibraryEntryPoints;

   784 	TInt r=E32Loader::StaticCallList(numEps, ep);

   785 	if (r!=KErrNone)

   786 		return;

   787 	if (aInit)

   788 		{

   789 		for (TInt i=0; i<numEps-1; ++i)	// last EP is always process entry point

   790 			{

   791 			TLibraryEntry f=(TLibraryEntry)ep[i];

   792 			(*f)(KModuleEntryReasonProcessAttach);

   793 			}

   794 		}

   795 	else

   796 		{

   797 		for (TInt i=numEps-2; i>=0; --i)	// last EP is always process entry point

   798 			{

   799 			TLibraryEntry f=(TLibraryEntry)ep[i];

   800 			(*f)(KModuleEntryReasonProcessDetach);

   801 			}

   802 		}

   803 	}

   804 

   805 

   806 

   807 

   808 EXPORT_C void User::InitProcess()

   809 /**

   810 @internalAll

   811 */

   812 	{

   813 	CallStaticEntryPoints(ETrue);

   814 	}

   815 

   816 

   817 

   818 

   819 EXPORT_C void User::Exit(TInt aReason)

   820 /**

   821 Terminates the current thread, specifying a reason.

   822 All child threads are terminated and all resources are cleaned up.

   823 

   824 If the current thread is the main thread in a process, the process is also 

   825 terminated.

   826 

   827 @param aReason The reason code.

   828 */

   829 	{

   830 	// Notify kernel that thread is exiting

   831 	TBool lastThread = Exec::UserThreadExiting(aReason);

   832 	if (lastThread)

   833 		{

   834 		// Call global destructors if we're the last thread in the process

   835 		TGlobalDestructorFunc func = (TGlobalDestructorFunc)UserSvr::DllTls(KGlobalDestructorTlsKey, KDllUid_Special);

   836 		if (func)

   837 			{

   838 			func();

   839 			CallStaticEntryPoints(EFalse);

   840 			}

   841 		}

   842 	

   843 	FOREVER

   844 		{

   845 		TInt h=Exec::LastThreadHandle();

   846 		if (h==0)

   847 			break;

   848 		if (Exec::HandleClose(h)>0)

   849 			RHandleBase::DoExtendedClose();

   850 		}

   851 

   852 #ifdef __USERSIDE_THREAD_DATA__

   853 	LocalThreadData()->Close();

   854 #endif

   855 	

   856 	ExitCurrentThread(EExitKill,aReason,NULL);

   857 	}

   858 #endif // __TOOLS2__

   859 

   860 

   861 

   862 EXPORT_C TInt User::QuickSort(TInt aCount,const TKey &aKey,const TSwap &aSwap)

   863 //

   864 // Routine sorts a set of records into the order defined by the key aKey.

   865 // There are aCount records to sort, each record is numbered, the first is

   866 // record 0, the last record aCount-1.

   867 // Each time the quicksort algorithm needs to compare two records it calls

   868 //     aKey.Compare(TInt n,TInt m).

   869 // where n and m (both type TUint) are the record no.s of the two records to compare.

   870 // The compare routine should return

   871 //     >0 if record(n) > record(m)

   872 //      0 if record(n) == record(m)

   873 //     <0 if record(n) < record(m)

   874 // Each time the quicksort algorithm needs to exchange two records it calls

   875 //     aSwap.Swap(n,m)

   876 // where n and m (both type TUint) are the record numbers of the two records to 

   877 // exchange.

   878 // The swap routine should exchange the positions of records n and m so that

   879 // the value of record m becomes the former value of record n and visa versa.

   880 //

   881 /**

   882 Quick sorts array elements.

   883 

   884 It is used by the standard Symbian OS arrays having 

   885 CArrayFixBase, CArrayVarBase or CArrayPakBase in their class hierarchy in 

   886 the implementation of their sort functions. The function can be used by other 

   887 arrays. 

   888 

   889 The function returns KErrNone if the operation is successful otherwise it 

   890 returns KErrGeneral.

   891 

   892 @param aCount The number of elements in the array.

   893 @param aKey   A reference to a suitably initialised TKey derived object.

   894 @param aSwap  A reference to a suitably initialised TSwap derived object.

   895 

   896 @return KErrNone if the operation is successful; KErrGeneral otherwise.

   897 

   898 @panic USER 96, if aCount is negative.

   899 */

   900 	{

   901 	TInt *parts_sp; // Stack pointer for partitions todo

   902 	TInt m; // First element of partition

   903 	TInt n; // No. of elements in partition

   904 	TInt d1,d2; // Temporary variables

   905 	TInt division_point; // Seperation point of partitions

   906 	TInt parts_todo[KQDepth]; // Stack pairs are <n,base>

   907 

   908 	__ASSERT_ALWAYS(aCount>=0,::Panic(ESortCountNegative));

   909 	if (aCount<=1) 

   910 		return(KErrNone); // Discard trivial sorts

   911 	parts_sp=(&parts_todo[0]); // Reset partitions to do stack

   912 	m=0; // Initial limits, first element

   913 	n=aCount; // No_elm elements to do

   914 	do  {

   915 		while (n>1 && parts_sp<(&parts_todo[KQDepth-2]))

   916 			{

   917 			division_point=partit(n,m,aKey,aSwap);

   918 			d1=division_point-m;

   919 			d2=m+n-division_point-1;

   920 			if (d1<d2)

   921 				{

   922 				// Less elements in first partition, do it first

   923 				// Stack bigger partition for later

   924 				*(parts_sp++)=d2;

   925 				*(parts_sp++)=division_point+1;

   926 				n=d1;

   927 				}

   928 			else

   929 				{

   930 				// Less elements in second partition,do it first

   931 				// Stack bigger partition for later

   932 				*(parts_sp++)=d1;

   933 				*(parts_sp++)=m;                      

   934 				n=d2;

   935 				m=division_point+1;

   936 				}

   937 			}

   938 		if (parts_sp>=&parts_todo[KQDepth-2]) 

   939 			return(KErrGeneral); // Stack overflow

   940 		m=(*(--parts_sp));

   941 		n=(*(--parts_sp)); // Unstack next partit to do

   942 		} while (parts_sp>=(&parts_todo[0])); // Stop on stack underflow

   943 	return(KErrNone);

   944 	}

   945 

   946 

   947 

   948 

   949 EXPORT_C TInt User::BinarySearch(TInt aCount,const TKey &aKey,TInt &aPos)

   950 //

   951 // Perform a binary search on any array. aKey.Compare() will be

   952 // called to lexically compare a record in the array with the

   953 // value being searched for. The second index to aKey.Compare() will

   954 // always be KIndexPtr, meaning the value being compared. The result

   955 // returned will be 0 if a match is found and >0 if no match is found.

   956 // The index of the matching record or the index of the record logically

   957 // following the value being searched for will be returned in aPos.

   958 //

   959 /**

   960 Performs a binary search for an array element containing a specified key.

   961 

   962 It can be used on any kind of array where elements can be identified by key. 

   963 It is used by the standard Symbian OS arrays having CArrayFix, CArrayVar or 

   964 CArrayPak in their class hierarchy in the implementation of the various

   965 functions for inserting, deleting and finding elements by key. The function

   966 can be used by other arrays. 

   967 

   968 The function returns a zero value if the search is successful and a non-zero 

   969 value otherwise.

   970 

   971 If the search is successful, the function puts the position (i.e. the index) 

   972 of the element into aPos. If the search is unsuccessful, then the function 

   973 puts into aPos the position of the first element in the array whose key is 

   974 greater than the search key.

   975 

   976 If the array is empty, i.e. aCount is zero, then the search is unsuccessful 

   977 and aPos is not defined.

   978 

   979 @param aCount The number of elements in the array.

   980 @param aKey   A reference to a suitably initialised TKey derived object.

   981               In particular, the object will have been initialised with

   982               a pointer to a sample element containing the search key.

   983 @param aPos   If the element is found, the reference is set to the position of 

   984               that element within the array. The position is relative to zero,

   985               (i.e. the first element in the array is at position 0).

   986               If the element is not found and the array is not empty, then

   987               the reference is set to the position of the first element in

   988               the array with a key which is greater than the search key. 

   989               If the element is not found and the array is empty, then the

   990               reference is undefined.

   991 

   992 @return Zero, if the element with the specified key is found. Non-zero, if 

   993 the element with the specified key is not found.

   994 

   995 @panic USER 97, if aCount is negative.

   996 */

   997 	{

   998 

   999 	__ASSERT_ALWAYS(aCount>=0,::Panic(EBinarySearchCountNegative));

  1000     TInt mid=0;

  1001     TInt r=(-1);

  1002     if (aCount)

  1003         {

  1004         TInt low=0;

  1005         TInt high=aCount-1;

  1006         while (low<=high)

  1007             {

  1008             mid=(low+high)>>1;

  1009             if ((r=aKey.Compare(mid,KIndexPtr))==0)

  1010                 break;

  1011             if (r<0)

  1012                 low=mid+1;

  1013             else

  1014                 high=mid-1;

  1015             }

  1016         }

  1017 	if (r<0)

  1018 		mid++;

  1019     aPos=mid;

  1020     return(r);

  1021 	}

  1022 

  1023 

  1024 

  1025 

  1026 EXPORT_C TVersion User::Version()

  1027 /**

  1028 Retrieves the E32 component version number, which is the kernel architecture version number.  

  1029 For example for EKA2 the major part of the version number will be 2.

  1030 

  1031 @return  The E32 component version number.

  1032 */

  1033 	{

  1034 

  1035 	return(TVersion(KE32MajorVersionNumber,KE32MinorVersionNumber,KE32BuildVersionNumber));

  1036 	}

  1037 

  1038 

  1039 

  1040 

  1041 EXPORT_C void User::Invariant()

  1042 /**

  1043 Panics the current thread with a USER 0 panic.

  1044 

  1045 Typically, this is called when a test for a class invariant fails, i.e. when

  1046 a test which checks that the internal data of an object is

  1047 self-consistent, fails.

  1048 

  1049 Such tests are almost always done in debug builds, commonly using

  1050 the __ASSERT_DEBUG macro.

  1051 */

  1052 	{

  1053 

  1054 	::Panic(EInvariantFalse);

  1055 	}

  1056 

  1057 

  1058 

  1059 

  1060 EXPORT_C TBool User::QueryVersionSupported(const TVersion &aCurrent,const TVersion &aRequested)

  1061 /**

  1062 Compares two version objects and returns true if the test version is less 

  1063 than the current version.

  1064 

  1065 Version information is encapsulated by a TVersion type object and consists

  1066 of a major version number, a minor version number and a build number.

  1067 

  1068 The function returns true if one of the following conditions is true:

  1069 

  1070 1. the test major version is strictly less than the current major version

  1071 

  1072 2. the test major version is equal to the current major version and the test 

  1073    minor version is less than or equal to the current minor version

  1074 

  1075 If neither condition is true, the function returns false.

  1076 

  1077 @param aCurrent   A reference to the current version against which aRequested 

  1078                   is compared.

  1079 @param aRequested A reference to the test version to be compared

  1080                   against aCurrent.

  1081                   

  1082 @return True, if one or both conditions are true. False otherwise.

  1083 */

  1084 	{

  1085 

  1086 	if (aRequested.iMajor<aCurrent.iMajor || (aRequested.iMajor==aCurrent.iMajor && aRequested.iMinor<=aCurrent.iMinor))

  1087 		return(ETrue);

  1088 	return(EFalse);

  1089 	}

  1090 

  1091 

  1092 

  1093 

  1094 EXPORT_C TKey::TKey()

  1095 /**

  1096 Protected default constructor.

  1097 

  1098 This constructor prevents TKey objects from being constructed directly.

  1099 */

  1100 	{}

  1101 

  1102 

  1103 

  1104 

  1105 EXPORT_C TKey::TKey(TInt anOffset,TKeyCmpText aType)

  1106 	: iKeyOffset(anOffset),iCmpType(ECmpCollated16+aType+1)

  1107 /**

  1108 Constructs the characteristics of a descriptor type key.

  1109 

  1110 This constructor should be called by the corresponding derived class

  1111 constructor that takes the same arguments. Typically, the derived class

  1112 constructor calls this constructor in its constructor initialization list.

  1113 

  1114 No length value is passed as this is implied by the type of key.

  1115 

  1116 Note that the constructor sets the offset value into the protected data member 

  1117 iKeyOffset.

  1118 

  1119 @param anOffset The offset of the key from the start of an array element.

  1120 @param aType    An enumeration which defines the type of comparison to be made 

  1121                 between two descriptor keys.

  1122                 

  1123 @panic USER 98, if anOffset is negative.

  1124                 

  1125 @see TKeyCmpText

  1126 */

  1127 	{

  1128 

  1129 	__ASSERT_ALWAYS(iKeyOffset>=0,Panic(EKeyOffsetNegative));

  1130 	}

  1131 

  1132 

  1133 

  1134