// Copyright (c) 1999-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:

// Rrun-time library routines for translating between multibyte and wide characters

// mbstowcs, mbtowc, wcstombs, wctomb and mblen

// 

//

#include <e32std.h>

#include <utf.h>

#include <stdlib.h>

#include <string.h>

extern "C"

{

/**

Converts the multibyte character addressed by s into the corresponding UNICODE

character pwc

@return the length, in bytes, of the multibyte character for which it found 

a UNICODE equivalent

@param pwc Is the address of a wide character, type wchar_t, 

to receive the UNICODE equivalent of s.

@param s Points to the multibyte character to be converted to UNICODE.

@param n Is the maximum width, in bytes, for which to scan s for a valid multibyte

sequence. Regardless of the value of n, no more than MB_CUR_MAX bytes are examined.

*/

EXPORT_C int mbtowc (wchar_t *pwc, const char *s, size_t n)

	{

	int rval = 0;

	if (s)

		{

		wchar_t wide;

		//number of chars to convert has a max of MB_CUR_MAX

		TInt maxlen = (n > MB_CUR_MAX ? MB_CUR_MAX : n);

		TPtrC8 src((const TUint8*)s, maxlen);

		TPtr16 awc((TUint16*)&wide, 1);		//length of 1 as we only want 1 wide character

		TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(awc, src);

		//return the number of chars converted which is the max number - the number not converted

		//unless the character converted was the wide null character

		if (ret >= 0)

			{

			rval = (L'\0' != wide) ? maxlen - ret : 0;

			if (pwc)

				*pwc = wide;	//only assign the return if we have a target

			}

		else

			return -1;	//the conversion failed.

		}

	return rval;

	}

}

extern "C"

{

EXPORT_C int mbstowcs (wchar_t *wstring, const char * string, size_t size)

	{

	//convert the string "string" to wide characters

	//return number of wide characters

	if (string)

		{

		if (wstring)

			{

			TPtrC8 src((const TUint8*)string);

			TPtr16 awc((TUint16*)wstring, size);		//max length of size

			TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(awc, src);

			if (ret >= 0)

				{

				TUint len = awc.Length();	//return number of wide characters

				if (len < size)

					awc.ZeroTerminate();

				return len;

				}

			else

				return -1;	//the conversion failed.

			}

		else

			{

			//we have no output string.  

			//ms say return len required

			//gcc says nowt

			return 1+strlen(string);	//max is could be

			}

		}

	return 0;	

	}

}

extern "C"

{

/**

Converts a wide character to a multibyte character

@return If s is null, the return value is true (non-zero) if multibyte 

characters have state-dependent encodings, or false (zero) if they do not.

@param mbchar multibyte character

@param wc wide character

*/

EXPORT_C int wctomb (char * mbchar, wchar_t wc)

	{

	if (mbchar)

		{

		//deal with the special null character case

		if (L'\0' == wc)

			{

			*mbchar = '\0';

			return 1;

			}

		//so we have possible character which is not null

		TPtr8 multi((TUint8*)mbchar, 0, MB_CUR_MAX);	//limit max length to MB_CUR_MAX

		TPtrC16 wide ((const TUint16*)&wc);

		TInt ret = CnvUtfConverter::ConvertFromUnicodeToUtf8(multi, wide);

		//ret has the number of wide characters left to convert, or an error

		if (ret >= 0)	//we didn't get an error

			//return the number of characters in the output

			return multi.Length();

		else

			return -1;

		}

		//calling with a null dest string is used to initialise shift state

		//we are only dealing with UTF8 which hasn't got one,

		//therefore we always return 0.

	else

		return 0;

	}

}

extern "C"

{

/**

The wcstombs function converts a wide string to a string of multibyte

characters.

@return 

@param string multibyte string

@param wstring wide string

@param size number of bytes written to.

*/

EXPORT_C int wcstombs (char * string, const wchar_t * wstring, size_t size)

	{

	if (wstring)

		{

		if (string)

			{

			TPtr8 multi((TUint8*)string, size);	//limit max length to size

			TPtrC16 wide((TText16*)wstring);

			TInt ret = CnvUtfConverter::ConvertFromUnicodeToUtf8(multi, wide);

			if (ret >= 0)	//we didn't get an error

				{

				TUint len = multi.Length();

				if (len < size)

					multi.ZeroTerminate();

				return len;			//null terminate

				}

			else

				return -1;

			}

		else

			{

			//we have a null output string

			//ms expects the length back.

			//gcc says nothing about it.

			//quick and dirty!!

			return 1 + (MB_CUR_MAX * wcslen(wstring));		//max it can be

			}

		}

	else

		return 0;

	}

}

extern "C"

{

/**

If string is not a null pointer, the function returns the number of bytes in the 

multibyte string 

that constitute the next multibyte character, 

or it returns -1 if the next n (or the remaining) bytes do not constitute a valid 

multibyte character. mblen does not include the terminating null in the count of bytes. 

@return the number of bytes in the multibyte string

@param string 

@param size 

*/

EXPORT_C int mblen (const char *string, size_t size)

	{

	if (string)

		{

		wchar_t wide;

		//deal with an empty string without doing the conversion.

		if ('\0' == *string)

			return 0;

		TInt maxlen = (size > MB_CUR_MAX ? MB_CUR_MAX : size);

		TPtrC8 src((const TUint8*)string, maxlen);

		TPtr16 awc((TUint16*)&wide, 1);		//length of 1 as we only want 1 wide character

		TInt ret = CnvUtfConverter::ConvertToUnicodeFromUtf8(awc, src);

		//return the number of chars converted which is the max number - the number not converted

		//unless the character converted was the wide null character

		if (ret >= 0)

			{

			return ((L'\0' != wide) ? maxlen - ret : 0);

			}

		else

			return -1;

		}

		//shift state would be initialised here if were using them

		return 0;

	}

}