// 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 "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\common\des8.cpp

// 

//

#include "common.h"

#ifndef __KERNEL_MODE__

#include <collate.h>

#else

#include <kern_priv.h>

#endif

#include <unicode.h>

// Folding/Collation for 8 bit characters

extern const TUint8 __FoldCollTab8[256];

const TUint8 __FoldCollTab8[256] =

	{

	0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, // 0x00

	0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,

	0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17, // 0x10

	0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,

	0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27, // 0x20

	0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,

	0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37, // 0x30

	0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,

	0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67, // 0x40

	0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,

	0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77, // 0x50

	0x78,0x79,0x7a,0x5b,0x5c,0x5d,0x5e,0x5f,

	0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67, // 0x60

	0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,

	0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77, // 0x70

	0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,

	0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, // 0x80

	0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,

	0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97, // 0x90

	0x98,0x99,0x9a,0x9b,0x9c,0x9d,0x9e,0x9f,

	0x20,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7, // 0xa0

	0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,

	0xb0,0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7, // 0xb0

	0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,

	0x61,0x61,0x61,0x61,0x61,0x61,0xe6,0x63, // 0xc0

	0x65,0x65,0x65,0x65,0x69,0x69,0x69,0x69,

	0xf0,0x6e,0x6f,0x6f,0x6f,0x6f,0x6f,0xd7, // 0xd0

	0xf8,0x75,0x75,0x75,0x75,0x79,0xfe,0xdf,

	0x61,0x61,0x61,0x61,0x61,0x61,0xe6,0x63, // 0xe0

	0x65,0x65,0x65,0x65,0x69,0x69,0x69,0x69,

	0xf0,0x6e,0x6f,0x6f,0x6f,0x6f,0x6f,0xf7, // 0xf0

	0xf8,0x75,0x75,0x75,0x75,0x79,0xfe,0x79

	};

#ifndef __KERNEL_MODE__

inline TUint8* memCopy(TUint8* aPtr, const TUint8* aSrc, TInt aLength)

//

// Copy 8 bit values.

//

	{

	return Mem::Copy(aPtr, aSrc, aLength);

	}

#endif

#if (defined(__KERNEL_MODE__) && !defined(__DES8_MACHINE_CODED__)) | defined(__EABI_CTORS__)

inline TInt StringLength(const TUint8* aPtr)

	{

	const TUint8* p = aPtr;

	while (*p)

		++p;

	return p-aPtr;

	}

#endif

inline TDesC8::TDesC8(TInt aType,TInt aLength)

	:iLength(aLength|(aType<<KShiftDesType8))

	{}

inline TInt TDesC8::Type() const

//

// Return the descriptor type

//

	{

	return(iLength>>KShiftDesType8);

	}

inline TDes8::TDes8(TInt aType,TInt aLength,TInt aMaxLength)

	: TDesC8(aType,aLength),iMaxLength(aMaxLength)

	{}

// Class TBufCBase8

inline TBufCBase8::TBufCBase8(TInt aLength)

	:TDesC8(EBufC,aLength)

	{}

inline TUint8* TBufCBase8::WPtr() const

	{return const_cast<TUint8*>(Ptr());}

#ifndef __DES8_MACHINE_CODED__

EXPORT_C const TUint8* TDesC8::Ptr() const

/**

Gets a pointer to the data represented by the descriptor.

The data cannot be changed through the returned pointer.

@return A pointer to the data

*/

	{

	switch (Type())

		{

	case EBufC:

		return(&((SBufC8 *)this)->buf[0]);

	case EPtrC:

		return(((SPtrC8 *)this)->ptr);

	case EPtr:

		return(((SPtr8 *)this)->ptr);

	case EBuf:

		return(&((SBuf8 *)this)->buf[0]);

	case EBufCPtr:

		return(&((SBufCPtr8 *)this)->ptr->buf[0]);

		}

	Panic(ETDes8BadDescriptorType);

	return(NULL);

	}

EXPORT_C const TUint8 &TDesC8::AtC(TInt anIndex) const

//

// Return a reference to the character in the buffer.

//

	{

	__ASSERT_ALWAYS(anIndex>=0 && anIndex<Length(),Panic(ETDes8IndexOutOfRange));

	return(Ptr()[anIndex]);

	}

EXPORT_C TInt TDesC8::Compare(const TDesC8 &aDes) const

/**

Compares this descriptor's data with the specified descriptor's data.

The comparison proceeds on a byte for byte basis. The result of the comparison 

is based on the difference of the first bytes to disagree.

Two descriptors are equal if they have the same length and content. Where 

two descriptors have different lengths and the shorter descriptor's data

matches the first part of the longer descriptor's data, the shorter is

considered to be less than the longer.

@param aDes The 8-bit non-modifable descriptor whose data is to be compared 

            with this descriptor's data.

@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 the their contents

        are the same.

*/

	{

	return memcompare(Ptr(), Length(), aDes.Ptr(), aDes.Length());

	}

#ifndef __KERNEL_MODE__

EXPORT_C TInt TDesC8::CompareF(const TDesC8 &aDes) const

/**

Compares this descriptor's folded data with the specified descriptor's folded 

data. 

Note that folding is locale-independent behaviour. It is also important to 

note that there can be no guarantee that folding is in any way culturally 

appropriate, and should not be used for comparing strings in natural language; 

use CompareC() for this.

@param aDes The 8-bit non modifable descriptor whose data is to be compared 

            with this descriptor's data. 

@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 the their contents

        are the same.

@see TDesC8::Compare()

*/

	{

	return(Mem::CompareF(Ptr(),Length(),aDes.Ptr(),aDes.Length()));

	}

EXPORT_C TInt TDesC8::CompareC(const TDesC8 &aDes) const

/**

Compares this descriptor's data with the specified descriptor's data using 

the standard collation method for narrow text appropriate to the current locale.

@param aDes The 8-bit non modifable descriptor whose data is to be compared 

            with this descriptor's data. 

@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 the their contents

        are the same.

@see TDesC8::Compare()

@deprecated

*/

	{

	return(Mem::CompareC(Ptr(),Length(),aDes.Ptr(),aDes.Length()));

	}

#endif

#endif

EXPORT_C TInt TDesC8::Find(const TUint8 *pS,TInt aLenS) const

/**

Searches for the first occurrence of the specified data sequence within this 

descriptor.

Searching always starts at the beginning of this descriptor's data.

@param pS    A pointer to a location containing the data sequence to be searched 

             for.

@param aLenS The length of the data sequence to be searched for. This value 

             must not be negative, otherwise the function raises a panic.

@return The offset of the data sequence from the beginning of this descriptor's 

        data. KErrNotFound, if the data sequence cannot be found.

@panic  USER 29 if aLenS is negative. 

*/

	{

	if (!aLenS)

		return(0);

	__ASSERT_ALWAYS(aLenS>0,Panic(ETDes8LengthNegative));

	const TUint8 *pB=Ptr();

	TInt aLenB=Length();

	const TUint8 *pC=pB-1;			// using pre-increment addressing

	TInt i=aLenB-aLenS;

	if (i>=0)

		{

		const TUint8* pEndS=pS+aLenS-1;		// using pre-increment addressing

		const TUint8 *pEndB=pB+i;			// using pre-increment addressing

		TUint s=*pS;

		for (;;)

			{

			do

				{

				if (pC==pEndB)

					return KErrNotFound;

				} while (*++pC!=s);

			const TUint8 *p1=pC;

			const TUint8 *p2=pS;

			do

				{

				if (p2==pEndS)

					return (pC-pB);

				} while (*++p1==*++p2);

			}

		}

	return(KErrNotFound);

	}

EXPORT_C TInt TDesC8::Find(const TDesC8 &aDes) const

/**

Searches for the first occurrence of the specified data sequence within this 

descriptor.

Searching always starts at the beginning of this descriptor's data.

@param aDes The 8-bit non modifable descriptor containing the data sequence 

            to be searched for. 

@return The offset of the data sequence from the beginning of this descriptor's 

        data. KErrNotFound, if the data sequence cannot be found.

*/

	{

	return(Find(aDes.Ptr(),aDes.Length()));

	}

const TUint8* convTable(TMatchType aType)

	{

	switch (aType)

		{

		case EMatchFolded:

		case EMatchCollated: return __FoldCollTab8;

		default: return NULL;

		}

	}

inline TUint conv(const TUint8* aStr,const TUint8* aConv)

	{

	TUint c=*aStr;

	return aConv ? aConv[c] : c;

	}

inline TUint lookup(const TUint8* aStr,const TUint8* aConv)

	{

	return aConv[*aStr];

	}

TInt DoMatch8(const TDesC8 &aLeftD,const TDesC8 &aRightD,TMatchType aType)

	{

	const TUint8* table=convTable(aType);

	const TUint8* pRight=aRightD.Ptr();

	const TUint8* pM=pRight-1;				// pre-increment addressing

	const TUint8* pP=pM+aRightD.Length();

	const TUint8* pLeft=aLeftD.Ptr()-1;		// pre-increment addressing

	const TUint8* pB=pLeft;	

	const TUint8* pE=pB+aLeftD.Length();

	// Match any pattern up to the first star

	TUint c;

	for (;;)

		{

		if (pM==pP)		// exhausted the pattern

			return pB==pE ? 0 : KErrNotFound;

		TUint c=conv(++pM,table);

		if (c==KMatchAny)

			break;

		if (pB==pE)			// no more input

			return KErrNotFound;

		if (c!=conv(++pB,table) && c!=KMatchOne)	// match failed

			return KErrNotFound;

		}

	// reached a star

	if (pM==pP)

		return 0;

	TInt r=pM==pRight ? -1 : 0;

	for (;;)

		{

		c=conv(++pM,table);

		if (c==KMatchAny)

			{

star:		if (pM==pP)		// star at end of pattern, always matches

				return Max(r,0);

			if (r<-1)		// skipped some '?', matches at beginning

				r=0;

			continue;

			}

		if (pB==pE)			// no more input

			return KErrNotFound;

		if (c==KMatchOne)

			{				// skip a character in the input

			if (pM==pP)

				return r+((r>=0) ? 0 : (pE-pLeft));

			++pB;

			if (r<0)

				--r;

			continue;

			}

	// Matching a non-wild character

		for (;;)

			{

			if (table)	// pull this test out of the tight loop (10-20% faster)

				{

				while (lookup(++pB,table)!=c)

					{

					if (pB==pE)				// no more input

						return KErrNotFound;

					}

				}

			else

				{

				while (*++pB!=c)

					{

					if (pB==pE)				// no more input

						return KErrNotFound;

					}

				}

			// Try to match up to the next star

			const TUint8* pb=pB;

			const TUint8* pm=pM;

			for (;;)

				{

				if (pm<pP)

					{

					TUint cc=conv(++pm,table);

					if (cc==KMatchAny)

						{	// sub-match successful, back to main loop

						r+=(r>=0 ? 0 : pB-pLeft);

						pB=pb;

						pM=pm;

						goto star;

						}

					if (pb==pE)

						return KErrNotFound;	// no more input

					if (cc!=conv(++pb,table) && cc!=KMatchOne)

						break;	// sub-match failed, try next input character

					}

				else if (pb==pE)	// end of matching pattern

					return r+(r>=0 ? 0 : pB-pLeft);	// end of input, so have a match

				else

					break;		// try next input character

				}

			}

		}

	}

EXPORT_C TInt TDesC8::Match(const TDesC8 &aDes) const

/**

Searches this descriptor's data for a match with the match pattern supplied 

in the specified descriptor.

The match pattern can contain the wildcard characters "*" and "?", where "*" 

matches zero or more consecutive occurrences of any character and "?" matches 

a single occurrence of any character.

Note that there is no 'escape character', which means that it is not possible

to match either the "*" character itself or the "?" character itself using

this function.

@param aDes An 8-bit non-modifable descriptor containing the match pattern.

@return If a match is found, the offset within this descriptor's data where 

        the match first occurs. KErrNotFound, if there is no match.

*/

	{

	return DoMatch8(*this,aDes,EMatchNormal);

	}

EXPORT_C TInt TDesC8::MatchF(const TDesC8 &aDes) const

/**

Searches this descriptor's folded data for a match with the folded match 

pattern supplied in the specified descriptor.

The match pattern can contain the wildcard characters "*" and "?", where "*" 

matches zero or more consecutive occurrences of any character and "?" matches 

a single occurrence of any character.

Note that folding is locale-independent behaviour. It is also important to 

note that there can be no guarantee that folding is in any way culturally 

appropriate, and should not be used for matching strings in natural language; 

use MatchC() for this.

Note that there is no 'escape character', which means that it is not possible

to match either the "*" character itself or the "?" character itself using

this function.

@param aDes An 8-bit non-modifable descriptor containing the match pattern. 

@return If a match is found, the offset within this descriptor's data where 

        the match first occurs. KErrNotFound, if there is no match. 

@see TDesC8::MatchC()

*/

	{

	return DoMatch8(*this,aDes,EMatchFolded);

	}

EXPORT_C TInt TDesC8::MatchC(const TDesC8 &aPattern) const

/**

Searches this descriptor's collated data for a match with the collated match 

pattern supplied in the specified descriptor.

The function uses the standard collation method for narrow text appropriate to 

the current locale.

The match pattern can contain the wildcard characters "*" and "?", where "*" 

matches zero or more consecutive occurrences of any character and "?" matches 

a single occurrence of any character.

Note that there is no 'escape character', which means that it is not possible

to match either the "*" character itself or the "?" character itself using

this function.

@param aPattern An 8-bit non-modifable descriptor containing the match pattern. 

@return If a match is found, the offset within this descriptor's data where 

        the match first occurs. KErrNotFound, if there is no match.

@deprecated

*/

	{

#ifndef __KERNEL_MODE__

	return MatchF(aPattern);

#else

	return DoMatch8(*this,aPattern,EMatchCollated);

#endif

	}

#ifndef __KERNEL_MODE__

EXPORT_C TInt TDesC8::FindF(const TUint8 *pS,TInt aLenS) const

/**

Searches for the first occurrence of the specified folded data sequence within 

this descriptor's folded data.

Searching always starts at the beginning of this descriptor's data.

Note that folding is locale-independent behaviour. It is also important to 

note that there can be no guarantee that folding is in any way culturally 

appropriate, and should not be used for finding strings in natural language; 

use FindC() for this.

@param pS    A pointer to a location containing the data sequence to be

             searched for.

@param aLenS The length of the data sequence to be searched for. This value 

             must not be negative, otherwise the function raises a panic.

@return The offset of the data sequence from the beginning of this descriptor's 

        data. KErrNotFound, if the data sequence cannot be found. Zero, if the

        length of the search data sequence is zero.

@panic USER 29 if aLenS is negative

@see TDesC8::FindC()

*/

	{

	if (!aLenS)

		return(0);

	const TUint8* table=convTable(EMatchFolded);

	const TUint8 *pB=Ptr();

	TInt aLenB=Length();

	const TUint8 *pC=pB-1;			// using pre-increment addressing

	TInt i=aLenB-aLenS;