/*

* Copyright (c) 2007-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: 

* Unicode converter codes

*

*/

/**

 @file 

 @internalComponent 

*/

#ifndef __UNICODE_CONVERTOR_H__

#define __UNICODE_CONVERTOR_H__

#if _MSC_VER <= 1200

#define FIX_VC6_BROKEN_FSTREAM

#endif

// The default C++ wide streams narrow all wchar_t to char before writing to disk!!!!

// This file defeats the narrowing, whilst still mapping NL <-> CR/NL.

// This code is hard coded to use little endian UTF-16.

// You probably want to #define FIX_VC6_BROKEN_FSTREAM then

// include this file, and do the following to create an output stream:-

//

//	std::wofstream out;

//	locale loc = _ADDFAC(locale::classic(), new NullCodecvt);

//

//	out.imbue(loc); 

//	out.open("c:\\test.txt", std::ios_base::out|std::ios_base::trunc|std::ios_base::binary);

//	out << wchar_t(0xfeff); // UTF-16 BOM - swapped by NullCondecvt to ff,fe == little endian

//

// Input streams should work as well, but the user will have to discard the BOM (if present).

#include <iostream>

#ifdef FIX_VC6_BROKEN_FSTREAM

#define fwrite(a,b,c,d) fwrite_hack(a,b,c,d)

#endif

#include <fstream>

#ifdef FIX_VC6_BROKEN_FSTREAM

#undef fwrite

static int fwrite_hack(const void *buffer, size_t size, size_t num, FILE *stream)

{

	// fstream _Fputc does a call of the form fwrite(p, N, 1, fs) == 1 for noconv data

	// fstream uses call of the form fwrite(p, N, 1, fs) == N for partial or ok data.

	// The second call is incorrect!

	// As a hack for VC6 we always say we converted (so _FPutc is not used),

	// and swap the arguments to fwrite...

	return fwrite(buffer, num, size, stream); // write num 1 byte elements

}

#endif

using namespace std;

typedef codecvt<wchar_t, char, mbstate_t> NullCodecvtBase;

// CLASS NullCodecvt

class NullCodecvt : public NullCodecvtBase

	{

public:

	explicit NullCodecvt(size_t _R = 0)

	: NullCodecvtBase(_R) {}

protected:

	virtual result do_in(mbstate_t& _State,

						 const char *fromStart, const char *fromEnd, const char *& fromNext,

						 wchar_t *toStart, wchar_t *toLimit, wchar_t *& toNext) const

	{		

		fromNext = fromStart;

		toNext = toStart;

		result r = noconv;

		int fromBytes = fromEnd - fromStart;

		int toWChars = toLimit - toStart;

		while((fromBytes >= 2) && (toWChars >= 1))

		{

			wchar_t wch = (fromNext[0] << 8) | fromNext[1];

			fromNext += 2;

			fromBytes -= 2;

			if(wch == '\r')

			{

				// Drop CR characters, so did at least partial conversion

				r = partial;

				continue;

			}

			*toNext++ = wch;

			--toWChars;

		}

		if(r == partial)

		{

			// Dropped some CR characters

			if(fromBytes == 0)

			{

				// and converted all input

				r = ok;

			}

		}

		return r;	

	}

	virtual result do_out(mbstate_t& _State,

						  const wchar_t *fromStart, const wchar_t *fromEnd, const wchar_t *& fromNext,

						  char *toStart, char *toLimit, char *& toNext) const

	{

		fromNext = fromStart;

		toNext = toStart;

		result r = noconv;

#ifdef FIX_VC6_BROKEN_FSTREAM

		r = partial;

#endif

		int fromWChars = fromEnd - fromStart;

		int toBytes = toLimit - toStart;

		while((fromWChars >= 1) && (toBytes >= 2))

		{

			if(*fromNext == '\r')

			{

				r = partial;

				// Do not expect CR internally, skip

				++fromNext;

				--fromWChars;

				continue;

			}

			if(*fromNext == '\n')

			{

				r = partial;

				if(toBytes < 4)

				{

					// Not enough space!!!!

					// Hopefully they will call us again with at least do_max_length() bytes (ie. 4)

					break;

				}

				*toNext++ = 0x0d; --toBytes; // 16 bit CR (little endian)

				*toNext++ = 0x00; --toBytes;

				*toNext++ = 0x0a; --toBytes; // 16 bit NL

				*toNext++ = 0x00; --toBytes;

				++fromNext;

				--fromWChars;

				continue;

			}

			*toNext++ = (*fromNext & 0x00ff); --toBytes; // little endian

			*toNext++ = (*fromNext & 0xff00) >> 8; --toBytes;

			++fromNext;

			--fromWChars;

			}

		if( (r==partial) && (fromWChars == 0))

		{

			r = ok;

		}

		return r;	

	}

	virtual result do_unshift(mbstate_t& _State,

							  char *_F2, char *_L2, char *& _Mid2) const

	{		return noconv;	}

	virtual int do_length(mbstate_t& _State, const char *from,

						  const char *fromEnd, size_t maxInternal) const _THROW0()

	{

		int conWChars = 0;

		const char *fromNext = from;

		while(((fromEnd-fromNext) >= 2) && (conWChars < maxInternal))

		{

			wchar_t wch = (fromNext[0] << 8) | fromNext[1];

			fromNext += 2;

			if(wch == '\r')

			{

				// Drop CR characters, so did at least partial conversion

				continue;

			}

			++conWChars;

		}

		return fromNext - from;

	}

	virtual bool do_always_noconv() const _THROW0()

	{	

		// Sometimes we do CRNL -> NL conversion

		return false;	

	}

	virtual int do_max_length() const _THROW0()

	{	

		// This is documented as the max number of external chars (bytes) that could

		// be consumed to create a single wchar_t.....

		// We convert 1 to 1, except for dropping CRs. This probably only, at worst,

		// converts 4 external bytes (16bit CR, 16bit NL) to a single 16 bit NL,

		// but we could consume infinite chars....

		// We will, at worst, convert a single wchar_t to 4 external chars (bytes)

		return 4;

	}

	virtual int do_encoding() const _THROW0()

	{		

		return 0; // Variable length encodings

	}

	}; 

#endif