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

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "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:

 // Name        : MRT_WCHARCNVT.CPP

 // Part of     : MRT LIBC

 // Contains the source for the helper functions used by wchar 

 // restartable conversion API's in libc

 // Version     : 1.0

 //

 // Copyright (c) 1997-2003 Symbian Ltd.  All rights reserved.

 // system includes

 #include <e32std.h>

 #include <e32base.h>

 #include <utf.h>

 #include <stdlib.h>

 #include <string.h>

 #include <errno.h>

 #include <wchar.h>

 #include "wcharcnv.h"

 #define  KSURROGATE_OFFSET 0x10000 - (0xD800 << 10) - 0xDC00

 //-----------------------------------------------------------------------------

 //Function Name : TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const 

 //                           TDesC8& aUtf8, mbstate_t *state)

 //Description   : Converts the unicode to UTF8 

 //Return Value  : The number of unconverted bytes left at the end of the input

 //descriptor, or one of the error values defined in TError.

 //-----------------------------------------------------------------------------

 TInt ConvertToUnicodeFromUtf8(TDes16& aUnicode, const TDesC8& aUtf8, mbstate_t *state)

 {

 	aUnicode.SetLength(0);

 	if (aUtf8.Length()==0)

 	{

 		return 0;

 	}

 	if (aUnicode.MaxLength()==0)

 	{

 		return aUtf8.Length();

 	}

 	HBufC8* utf8 = NULL;

 	if ( state->__count > 0)

         {

 	        // state have some information, use that.

 	        utf8 = HBufC8::NewLC ( state->__count + aUtf8.Length() );

 	        TPtr8 tempBuf = utf8->Des();

 	        TPtr8 temp ((TUint8*)state->__value.__wchb, state->__count);

 	        tempBuf.Copy(temp);

 	        tempBuf.Append(aUtf8);

         }

 	TUint16* pointerToCurrentUnicodeCharacter=CONST_CAST(TUint16*, aUnicode.Ptr());

 	const TUint16* pointerToLastUnicodeCharacter=pointerToCurrentUnicodeCharacter+(aUnicode.MaxLength()-1);

 	const TUint8* pointerToCurrentUtf8Byte= utf8 ? utf8->Des().Ptr() : aUtf8.Ptr();

 	const TUint8* pointerToPendingUtf8Byte=utf8 ? utf8->Des().Ptr() : aUtf8.Ptr();

 	TInt length = utf8 ? utf8->Des().Length() : aUtf8.Length();

 	const TUint8* pointerToLastUtf8Byte=pointerToCurrentUtf8Byte+(length-1);

 	TUint16 replacementcharacter = 0xFFFD;

 	TUint8 currentUtf8Byte;

 	TUint currentUnicodeCharacter;

 	TInt sequenceLength;		

 	FOREVER

 	{

 		currentUtf8Byte=*pointerToCurrentUtf8Byte;

 		pointerToPendingUtf8Byte = pointerToCurrentUtf8Byte;

 		sequenceLength=100;

 		for(TInt i=0;i<7;i++)

 		{

 			if ((currentUtf8Byte&(0xf8<<i))==(static_cast<TUint8>(0xF0<<i)))

 			{

 				sequenceLength = 4-i;

 				break;

 			}

 		}

 		if ((sequenceLength<2 || sequenceLength>6) && sequenceLength!=0)

 		{

 			currentUnicodeCharacter=replacementcharacter;

 		}

 		else

 		{		

 			if ((pointerToLastUtf8Byte-pointerToCurrentUtf8Byte+1)<sequenceLength)

 			{

 				// we dnt have enough UTF-8 bytes to complete the Muti-Byte character.

 				// store the character within the state.

 				state->__count = 0;

             			while (pointerToCurrentUtf8Byte <= pointerToLastUtf8Byte)

         		        {

             			        state->__value.__wchb[state->__count++] = *(pointerToCurrentUtf8Byte++);

 		                }

             			// reset the current pointer

     	        		pointerToCurrentUtf8Byte -= state->__count;

 				if((pointerToCurrentUnicodeCharacter-aUnicode.Ptr())==0)

 			        {

 				        // still nothing is decoded.

 				        if ( utf8 )

 			                {

 	        			        CleanupStack::PopAndDestroy(); // utf8

 			                }

 				        return -2;

 				        //return -1;

 				}

         			// something is already decoded, so return the no of bytes that use for 

 	        		// decoding.

 		        	break;

 		        }			

                         // reset the state				

                     	state->__count = 0;

 			currentUnicodeCharacter = currentUtf8Byte&(0x7F>>sequenceLength);

         		for(TInt i=sequenceLength;i>1; i--)

 	                {

         			currentUtf8Byte = *(++pointerToCurrentUtf8Byte);

         			if ((currentUtf8Byte&0xc0)==0x80)

         			{

 	       				currentUnicodeCharacter = (currentUnicodeCharacter<<6)|(currentUtf8Byte&0x3F);

         			}

         			else

         			{

         				// Encoding error occured.

         				// store the contained within the state and return -1.

         				// set the error EILSEQ to errno

                 		        if ( utf8 )

                			        {

                 			        CleanupStack::PopAndDestroy(); // utf8

                			        }

         				errno = EILSEQ;

                				return -1;

         				//currentUnicodeCharacter=replacementcharacter;

         				//--pointerToCurrentUtf8Byte;

         			}

 	       		}

 	        }

        		if (currentUnicodeCharacter > 0xFFFF)

        		{

 	        	if(pointerToCurrentUnicodeCharacter>=pointerToLastUnicodeCharacter)

 	        	{

         			// unicode descriptor dnt have 2 wchar bytes to hold the data.

 	       			pointerToCurrentUtf8Byte=pointerToPendingUtf8Byte;

 	        		break;

 	        	}

         		TUint surrogate = (currentUnicodeCharacter>>10) + 0xD7C0;

 	       		*pointerToCurrentUnicodeCharacter=static_cast<TUint16>(surrogate);			

 	        	++pointerToCurrentUnicodeCharacter;

 		        surrogate = (currentUnicodeCharacter&0x3FF)+0xDC00;

         		*pointerToCurrentUnicodeCharacter=static_cast<TUint16>(surrogate);			

 	       		++pointerToCurrentUnicodeCharacter;

 	        	++pointerToCurrentUtf8Byte;

 	        }

         	else

 		{

 	        	*pointerToCurrentUnicodeCharacter=static_cast<TUint16>(currentUnicodeCharacter);

 		        ++pointerToCurrentUnicodeCharacter;

         		++pointerToCurrentUtf8Byte;

 		}

 	        if ((pointerToCurrentUtf8Byte>pointerToLastUtf8Byte) || (pointerToCurrentUnicodeCharacter>pointerToLastUnicodeCharacter))

 	        {

         		// checking the boundary condition.

         		// Here either the UTF-8 or Unicode descriptor reached to the end.

         		break;

         	}

 	} // forever

         // decoding finished.

 	aUnicode.SetLength(pointerToCurrentUnicodeCharacter-aUnicode.Ptr());

         if ( utf8 )

         {

                 CleanupStack::PopAndDestroy(); // utf8

         }

        	//return pointerToLastUtf8Byte-pointerToCurrentUtf8Byte+1;

 	// returns the number of bytes used to complete a valid multibyte character.

 	return pointerToCurrentUtf8Byte - aUtf8.Ptr();

 } //end of function

 //-----------------------------------------------------------------------------

 //Function Name : TInt _Utf16ToUtf8(char* aDst, wchar_t aSrc, mbstate_t* ps, int aLen )

 //Description   : Converts wide char in UCS2 format to UTF8 equivalent

 //Return Value  : The number of bytes converted, 0 if L'\0\' was translated, -1 on

 //generic error and errno set appropriately, -2 if len is not sufficient to store aSrc wide char

 //-----------------------------------------------------------------------------

 TInt _Utf16ToUtf8(char* dst, wchar_t aSrc, mbstate_t* ps, int aLen)

 {

 	int retval = 0;

 	// check the state 

 	if(ps->__count !=_EUTF16InitialState && ps->__count != _EUTF16_21BitExtensionState)

 	{

 		errno = EINVAL;

 		return -1;

 	}

 	//following characters are illegal

 	//see http://www.unicode.org/faq/utf_bom.html#40

 	if(aSrc == 0xFFFE || aSrc == 0xFFFF || (aSrc >= 0xFDD0 && aSrc <= 0xFDEF) )

 	{

 		errno = EILSEQ;

 		return -1;

 	}

 	if(ps->__count == _EUTF16InitialState)

 	{

 		//following characters in addition are illegal in initial state

 		//see http://www.unicode.org/faq/utf_bom.html#40

 		if((aSrc >= 0xDC00 && aSrc <= 0xDFFF) )

 		{

 			errno = EILSEQ;

 			return -1;

 		}

 		if ((aSrc & 0xff80)==0x0000)

 		{

 			if(aLen >= 1)

 			{

 				*dst++ = static_cast<TUint8>(aSrc);

 				retval = 1;

 			}

 			else

 			{

 				return -2;

 			}

 		}

 		else if ((aSrc & 0xf800)==0x0000)

 		{

 			if (aLen >= 2)

 			{

 				*dst++ = static_cast<TUint8>(0xc0|(aSrc>>6));

 				*dst++ = static_cast<TUint8> (0x80|(aSrc&0x3f));

 				retval = 2;

 			}

 			else

 			{

 				return -2;

 			}

 		}

 		else if ((aSrc & 0xfc00)==0xd800)

 		{

 			 ps->__value.lead = aSrc;

 		 	 ps->__count = _EUTF16_21BitExtensionState;

 		 	retval = 0; //nothing written out just yet

 		}

 		else

 		{

 			if ( aLen >= 3)

 			{

 				*dst++ = static_cast<TUint8>(0xe0|(aSrc>>12));

 				*dst++ = static_cast<TUint8>(0x80|((aSrc>>6)&0x3f));

 				*dst++ = static_cast<TUint8>(0x80|(aSrc&0x3f));

 				retval = 3;

 			}

 			else

 			{

 				return -2;

 			}

 		}

 	}

 	else //ps->__count == _EUCS2_21BitExtensionState)

 	{

 		//characters outside this range are illegal in this state

 		//see http://www.unicode.org/faq/utf_bom.html#40

 		if((aSrc < 0xDC00 || aSrc > 0xDFFF) )

 		{

 			errno = EILSEQ;

 			return -1;

 		}

 		if ((aSrc & 0xfc00)!=0xdc00)

 		{

 			errno = EILSEQ;

 			return -1;

 		}

 		if ( aLen >= 4)

 		{

 			//snippet taken from unicode faq

 			//http://www.unicode.org/faq/utf_bom.html#39

 			unsigned long  codepoint = (ps->__value.lead << 10) + aSrc + KSURROGATE_OFFSET;

 			*dst++ = static_cast<TUint8>( 0xf0|(codepoint>>18));

 			*dst++ = static_cast<TUint8>(0x80|((codepoint>>12)&0x3f));

 			*dst++ = static_cast<TUint8>(0x80|((codepoint>>6)&0x3f));

 			*dst++ = static_cast<TUint8>(0x80|(codepoint&0x3f));

 			retval = 4;

 		}

 		else

 		{

 			return -2;

 		}

 		ps->__count = _EUTF16InitialState;

 	}

 	return retval;

 }//end of function