// 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\common\des8.cpp

// 

//

#include "common.h"

#include <e32des8_private.h>

#ifndef __KERNEL_MODE__

#include <collate.h>

#else

#include <kernel/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;

	if (i>=0)

		{

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

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

		TUint s=lookup(pS,table);

		for (;;)

			{

			do

				{

				if (pC==pEndB)

					return KErrNotFound;

				} while (lookup(++pC,table)!=s);

			const TUint8 *p1=pC;

			const TUint8 *p2=pS;

			do

				{

				if (p2==pEndS)

					return (pC-pB);

				} while (lookup(++p1,table)==lookup(++p2,table));

			}

		}

	return(KErrNotFound);

	}

EXPORT_C TInt TDesC8::FindF(const TDesC8 &aDes) 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 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. Zero, if the 

        length of the search data sequence is zero.

@see TDesC8::FindC()

*/

	{

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

	}

EXPORT_C TInt TDesC8::FindC(const TUint8* aText,TInt aLength) const

/**

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

this descriptor's collated data.

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

uses the standard collation method for narrow text appropriate to the current 

locale.

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

               searched for.

@param aLength The length of 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.

@panic USER 29 if aLength is negative.

@deprecated

*/

	{

	return FindF(aText, aLength);

	}

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

/**

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

this descriptor's collated data.

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

uses the standard collation method for narrow text appropriate to the current 

locale.

@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.

@deprecated

*/

	{

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

	}

EXPORT_C TInt TDesC8::LocateF(TChar aChar) const

/**

Searches for the first occurrence of a folded character within this

descriptor's folded data.

The search starts at the beginning of the data,i.e. at the leftmost position.

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 searching strings in natural language.

@param aChar The character to be found.

@return The offset of the character position from the beginning of the data.

        KErrNotFound, if no matching character can be found.

*/

	{

	TUint c = User::Fold(aChar);

	if(c>=0x100)

		return KErrNotFound;

	const TUint8 *pBuf=Ptr();

	const TUint8 *pB=pBuf-1;

	const TUint8 *pE=pB+Length();

	const TUint8* table=__FoldCollTab8;

	do

		{

		if (pB==pE)

			return KErrNotFound;

		} while (table[*++pB]!=c);

	return pB-pBuf;

	}

#endif	// __KERNEL_MODE__

#ifndef __DES8_MACHINE_CODED__

EXPORT_C TInt TDesC8::Locate(TChar aChar) const

/**

Searches for the first occurrence of a character within this descriptor's

data.

The search starts at the beginning of the data, i.e. at the leftmost position.

@param aChar The character to be found. 

@return The offset of the character position from the beginning of the data.

        KErrNotFound, if no matching character can be found.

*/

	{

	const TUint8 *pBuf=Ptr();

	const TUint8 *pB=pBuf-1;

	const TUint8 *pE=pB+Length();

	do

		{

		if (pB==pE)

			return KErrNotFound;

		} while (*++pB!=aChar);

	return pB-pBuf;

	}

#endif

#ifndef __DES8_MACHINE_CODED__

EXPORT_C TInt TDesC8::LocateReverse(TChar aChar) const

/**

Searches for the first occurrence of a character within this descriptor's data, 

searching from the end of the data.

The search starts at the rightmost position.

@param aChar The character to be found.

@return The offset of the character position from the beginning of the data.

        KErrNotFound, if no matching character can be found.

*/

	{

	TInt len=Length();

	if (len==0)

		return(KErrNotFound);

	const TUint8 *pB=Ptr();

	const TUint8 *pE=pB+len-1;

	while (pE>=pB)

		{

		if (*pE==aChar)

			break;

		pE--;

		}

	return(pE<pB ? KErrNotFound : pE-pB);

	}

#endif

#ifndef __KERNEL_MODE__

EXPORT_C TInt TDesC8::LocateReverseF(TChar aChar) const

/**

Searches for the first occurrence of a folded character within this descriptor's 

folded data, searching from the end of the data.

The search starts at the rightmost position. 

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 searching strings in natural language.

@param aChar The character to be found 

@return The offset of the character position from the beginning of the data.

        KErrNotFound, if no matching character can be found

*/

	{

	TInt len=Length();

	if (len==0)

		return(KErrNotFound);

	const TUint8 *pB=Ptr();

	const TUint8 *pE=pB+len-1;

	const TUint8* table=__FoldCollTab8;

	TUint c = table[aChar];

	while (pE>=pB)

		{

		if (table[*pE]==c)

			break;

		pE--;

		}

	return(pE<pB ? KErrNotFound : pE-pB);

	}

EXPORT_C HBufC8 *TDesC8::Alloc() const

/**

Creates a new 8-bit heap descriptor and initialises it with a copy of this 

descriptor's data.

@return A pointer to the new 8 bit heap descriptor, if creation is successful. 

        NULL, if creation of the descriptor fails.

*/

	{

	HBufC8 *pH=HBufC8::New(Length());

	if (pH)

		*pH=(*this);

	return(pH);

	}

EXPORT_C HBufC8 *TDesC8::AllocL() const

/**

Creates a new 8-bit heap descriptor and initialises it with a copy of this 

descriptor's data.

The function leaves, if creation of the descriptor fails.

@return A pointer to the 8-bit heap descriptor, if creation is successful.

*/

	{

	HBufC8 *pH=HBufC8::NewL(Length());

	*pH=(*this);

	return(pH);

	}

EXPORT_C HBufC8 *TDesC8::AllocLC() const

/**

Creates a new 8-bit heap descriptor, initialises it with a copy of this 

descriptor's data, and puts a pointer to the descriptor onto the cleanup stack.

The function leaves, if creation of the descriptor fails.

@return A pointer to the 8 bit heap descriptor, if creation is successful. 

        The pointer is also put onto the cleanup stack.

*/

	{

	HBufC8 *pH=HBufC8::NewLC(Length());

	*pH=(*this);

	return(pH);

	}

#endif	// __KERNEL_MODE__

#if !defined(__DES8_MACHINE_CODED__)

EXPORT_C TPtrC8 TDesC8::Left(TInt aLength) const

/**

Extracts the leftmost part of the data. 

The function does not cut or remove any data but constructs a non-modifiable 

pointer descriptor to represent the leftmost part of the data.

@param aLength The length of the data to be extracted. If this value

               is greater than the length of the descriptor, the function

               extracts the whole of the descriptor.

@return The 8-bit non-modifiable pointer descriptor representing the leftmost 

        part of the data.

@panic USER 22 if aLength is negative. 

*/

	{

	__ASSERT_ALWAYS(aLength>=0,Panic(ETDes8PosOutOfRange));

	return(TPtrC8(Ptr(),Min(aLength,Length())));

	}

EXPORT_C TPtrC8 TDesC8::Right(TInt aLength) const

/**

Extracts the rightmost part of the data.

The function does not cut or remove any data but constructs a non-modifiable 

pointer descriptor to represent the rightmost part of the data.

@param aLength The length of data to be extracted. If this value

               is greater than the length of the descriptor, the function 

               extracts the whole of the descriptor. 

@return The 8 bit non-modifiable pointer descriptor representing the rightmost 

        part of the data.

@panic USER 22 if aLength is negative. 

*/

	{

	__ASSERT_ALWAYS(aLength>=0,Panic(ETDes8PosOutOfRange));

	TInt len=Length();

	if (aLength>len)

		aLength=len;

    return(TPtrC8(Ptr()+len-aLength,aLength));

	}

EXPORT_C TPtrC8 TDesC8::Mid(TInt aPos) const

/**

Extracts a portion of the data.

The function does not cut or remove any data but constructs a non-modifiable 

pointer descriptor to represent the defined portion.

The portion is identified by its starting position and by the length of the 

remainder of the data starting from the specified position.

@param aPos The starting position of the data to be extracted. This is an 

            offset value; a zero value refers to the leftmost data position. 

@return The 8-bit non-modifiable pointer descriptor representing the specified 

        portion of the data.

@panic USER 22  if aPos is negative or aPos is greater than the

                length of the descriptor.       

*/

	{

	TInt len=Length();

	__ASSERT_ALWAYS(aPos>=0 && aPos<=len,Panic(ETDes8PosOutOfRange));

    return(TPtrC8(Ptr()+aPos,len-aPos));

	}

EXPORT_C TPtrC8 TDesC8::Mid(TInt aPos,TInt aLength) const

/**

Extracts a portion of the data.

The function does not cut or remove any data but constructs a non-modifiable 

pointer descriptor to represent the defined portion.

The portion is identified by its starting position and by its length.

@param aPos    The starting position of the data to be extracted. This is an 

               offset value; a zero value refers to the leftmost data position. 

@param aLength The length of data to be extracted.

@return The 8 bit non-modifiable pointer descriptor representing the specified 

        portion of the data.

@panic USER 22  if aPos is negative or aPos plus aLength is greater than the

                length of the descriptor.

*/

	{

	__ASSERT_ALWAYS(aPos>=0 && (aPos+aLength)<=Length(),Panic(ETDes8PosOutOfRange));

    return(TPtrC8(Ptr()+aPos,aLength));

	}

#endif  // !defined(__DES8_MACHINE_CODED__)

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

EXPORT_C TBufCBase8::TBufCBase8()

//

// Constructor

//

	: TDesC8(EBufC,0)

	{}

EXPORT_C TBufCBase8::TBufCBase8(const TUint8 *aString,TInt aMaxLength)

//

// Constructor

//

	: TDesC8(EBufC,0)

	{

	Copy(aString,aMaxLength);

	}

EXPORT_C TBufCBase8::TBufCBase8(const TDesC8 &aDes,TInt aMaxLength)

//

// Constructor

//

	: TDesC8(EBufC,0)

	{

	Copy(aDes,aMaxLength);

	}

#endif 

#ifndef __DES8_MACHINE_CODED__

EXPORT_C void TBufCBase8::Copy(const TUint8 *aString,TInt aMaxLength)

//

// Copy from a string.

//

	{

	TInt len=STRING_LENGTH(aString);

	__ASSERT_ALWAYS(len<=aMaxLength,Panic(ETDes8Overflow));

	memmove(WPtr(), aString, len);

	DoSetLength(len);

	}

EXPORT_C void TBufCBase8::Copy(const TDesC8 &aDes,TInt aMaxLength)

//

// Copy from a descriptor.

//

	{

	TInt len=aDes.Length();

	__ASSERT_ALWAYS(len<=aMaxLength,Panic(ETDes8Overflow));

	memmove(WPtr(), aDes.Ptr(), len);

	DoSetLength(len);

	}

#endif

#ifndef __KERNEL_MODE__

inline HBufC8::HBufC8(TInt aLength)

	:TBufCBase8(aLength)

	{}

EXPORT_C HBufC8 *HBufC8::New(TInt aMaxLength)

/**

Creates, and returns a pointer to, a new 8-bit heap descriptor.

The heap descriptor is empty and its length is zero.

Data can, subsequently, be assigned into it using the assignment operators.

@param aMaxLength The requested maximum length of the descriptor. Note that 

                  the resulting heap cell size and, therefore, the resulting

                  maximum length of the descriptor may be larger

                  than requested.

@return A pointer to the new 8-bit heap descriptor. NULL, if the 8-bit heap 

        descriptor cannot be created.

@panic USER 30 if aMaxLength is negative.

@see HBufC8::operator=()

*/

	{

	__ASSERT_ALWAYS(aMaxLength>=0,Panic(ETDes8MaxLengthNegative));

	return new(STD_CLASS::Alloc(_FOFF(HBufC8,iBuf[aMaxLength]))) HBufC8(0);

	}

EXPORT_C HBufC8 *HBufC8::NewL(TInt aMaxLength)

/** 

Creates, and returns a pointer to, a new 8-bit heap descriptor, and leaves 

on failure.

The heap descriptor is empty and its length is zero.

Data can, subsequently, be assigned into it using the assignment operators.

@param aMaxLength The requested maximum length of the descriptor. Note that 

                  the resulting heap cell size and, therefore, the resulting