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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\euser\us_func.cpp

// 

//

#include "us_std.h"

//#define __DEBUG_IMAGE__ 1

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

#include "e32svr.h" 

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

#else

#define __IF_DEBUG(t)

#endif

#ifdef _UNICODE

#include <collate.h>

#include "CompareImp.h"

#endif

#include "us_data.h"

typedef union

	{

	TAny *tany;

	TText8 *ttext8;

	TText16 *ttext16;

	TDesC8 *tdesc8;

	TDesC16 *tdesc16;

	TInt8 *tint8;

	TInt16 *tint16;

	TInt32 *tint32;

	TInt64 *tint64;

	TInt *tint;

	TUint8 *tuint8;

	TUint16 *tuint16;

	TUint32 *tuint32;

	TUint *tuint;

	} UPTR;

const TUint crcTab[256] =

    {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	0x3eb2,0x0ed1,0x1ef0

    };

const TInt KQDepth=150; // Maximum queue depth

LOCAL_C TUint checkSum(const TAny *aPtr)

//

// Checksum every other byte

//

	{

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

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

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

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

	while (pB<pE)

		{

		*pT++=(*pB);

		pB+=2;

		}

	TUint16 crc=0;

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

	return(crc);

	}

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

//

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

// return element no. of partition point. 

//

	{

	TInt i=m-1;

	TInt j=i+n;

	TInt pivlin=j;

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

	while (i<j) 

		{

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

			{

			}

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

			{

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

				break;

			}

		if (i<j)

			aSwap.Swap(i,j);

		}

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

	return(i);

	}

static const TCollationMethod TheCollationMethod[] =

	{

		{

		KUidBasicCollationMethod,				// this is the standard unlocalised method

		NULL,									// null means use the standard table

		NULL,									// there's no override table

		0										// the flags are standard

		}

	};

static const TCollationDataSet TheCollationDataSet =

	{

	TheCollationMethod,

	1

	};

// The one and only locale character set object.

const LCharSet TheCharSet =

	{

	NULL,

	&TheCollationDataSet

	};

const LCharSet* GetLocaleDefaultCharSet()

	{

	return &TheCharSet;

	}

const LCharSet* GetLocaleCharSet()

	{

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

	if(charSet)

		return charSet;

	return &TheCharSet;

	}

const LCharSet* GetLocalePreferredCharSet()

	{

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

	if(charSet)

		return charSet;

	return &TheCharSet;

	}

EXPORT_C TCollationMethod TExtendedLocale::GetPreferredCollationMethod(TInt aIndex)

/**

Get the preferred collation method for the preferred charset.

Note that some charsets may contain more than one collation

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

index parameter can be used to select between them.

@param aIndex Optional parameter specifying the index of the collation 

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

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

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

@return TCollationMethod representing the requested collation method.

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

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

	   collation methods in the preferred charset in this locale.

@see TCollationMethod

*/

	{

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

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

	}

extern const TUint8 __FoldCollTab8[256];

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

/**

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

another specified location, using the standard folding method appropriate 

to the current locale.

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

               compared.

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

               i.e. the number of bytes.

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

               compared.

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

               compared, i.e. the number of bytes.

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

        second (or right) block of data.

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

        (or right) block of data.

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

        have the same length and the same content. 

@see Mem::Compare

*/

	{

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

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

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

	const TUint8* table=__FoldCollTab8;

    while (aLeft<pE)

		{

		TUint l=*aLeft++;

		TUint r=*aRight++;

		l = table[l];

		r = table[r];

		TInt d=l-r;

		if (d!=0)

		    return(d);

		}

    return(aLeftL-aRightL);

	}

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

/**

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

another specified location using the standard collation method appropriate 

to the current locale.

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

               compared.

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

               i.e. the number of bytes.

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

               compared.

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

               i.e. the number of bytes.

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

        second (or right) block of data.

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

        (or right) block of data.

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

        have the same length and the same content.

@see Mem::Compare

@deprecated

*/

	{

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

	}

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

/**

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

another specified location.

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

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

disagree.

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

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

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

to be less than the longer.

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

               compared.

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

               i.e. the number of double-bytes. 

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

               compared.

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

               i.e. the number of double-bytes.

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

        second (or right) block of data.

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

        (or right) block of data.

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

        have the same length and the same content.

*/

	{

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

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

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

    while (aLeft<pE)

		{

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

		if (d!=0)

		    return(d);

		}

    return(aLeftL-aRightL);

	}

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

/**

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

another specified location, using the standard folding method appropriate 

to the current locale.

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

               compared.

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

               i.e. the number of double-bytes.

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

               compared.

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

               i.e the number of double-bytes.

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

        second (or right) block of data.

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

        (or right) block of data.

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

        have the same length and the same content.

@see Mem::Compare

*/

	{

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

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

	const TText16* aLeftEnd = aLeft + aLeftL;

	const TText16* aRightEnd = aRight + aRightL;

	const TUint8* table=__FoldCollTab8;

	while (aLeft != aLeftEnd)

		{

		if (aRight == aRightEnd)

			return 1;

		TUint l = *aLeft;

		TUint r = *aRight;

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

		if (l < 128 && r < 128)

			{

			l = table[l];

			r = table[r];

			if (r != l)

				return l-r;

			aLeft++;

			aRight++;

			}

		// covers Unicode characters...

		else

			{

			TUTF32Iterator leftIt(aLeft, aLeftEnd);

			TUTF32Iterator rightIt(aRight, aRightEnd);

			return ::CompareFolded(leftIt, rightIt);

			}

		}

	return aRight == aRightEnd? 0:-1;

	}

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

/**

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

another specified location using the standard collation method appropriate 

to the current locale.

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

               compared.

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

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

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

               compared.

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

               i.e. the number of double-bytes. 

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

        second (or right) block of data.

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

        (or right) block of data.

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

        have the same length and the same content. 

@see Mem::Compare

*/

	{

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

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

#ifdef _UNICODE

	TCollate c(GetLocaleCharSet());

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

#else

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

    while (aLeft<pE)

		{

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

		if (d!=0)

		    return(d);

		}

    return(aLeftL-aRightL);

#endif

	}

#ifdef _UNICODE

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

							TInt aMaxLevel,const TCollationMethod* aCollationMethod)

/**

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

using the specified collation method and collating to the specified maximum 

collation level.

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

locale, is used.

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

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

16 bit descriptor is used.

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

                        to be compared.

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

                        compared. This is the number of double-bytes. 

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

                        to be compared.

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

                        compared. This is the number of double-bytes. 

@param aMaxLevel        The maximum collation level. 

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

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

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

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

        are the same.

*/

	{

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

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

	if (aCollationMethod == NULL)

		{

		TCollate c(GetLocaleCharSet());

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

		}

	else

		{

		TCollate c(*aCollationMethod);

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

		}

	}

#endif

#ifdef _UNICODE

EXPORT_C TInt Mem::CollationMethods()

/**

Gets the number of collation methods in this locale.

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

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

explicit 16 bit descriptor is used.

@return The number of collation methods.

*/

	{

	return GetLocaleCharSet()->iCollationDataSet->iMethods;

	}

#endif

#ifdef _UNICODE

EXPORT_C TUint Mem::CollationMethodId(TInt aIndex)

/**

Gets the Uid associated with the specified collation method.

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

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

explicit 16 bit descriptor is used.

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

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

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

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

@return The Uid of the collation method.

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

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

*/

	{