/*

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

* Ported from us_ucmp.cpp.

* Implementation of the Standard Compression Scheme for Unicode.

* This code is compiled only in the Unicode build.

*

*/

#include "ucmp.h"

#include <stdexcept>

#include "deserialiser.h"

#include "serialiser.h"

namespace {

const int KErrNotFound = -1;

}

const TUint32 TUnicodeCompressionState::iStaticWindow[EStaticWindows] =

	{

	0x0000,		// tags

	0x0080,		// Latin-1 supplement

	0x0100,		// Latin Extended-A

	0x0300,		// Combining Diacritics

	0x2000,		// General Punctuation

	0x2080,		// Currency Symbols

	0x2100,		// Letterlike Symbols and Number Forms

	0x3000		// CJK Symbols and Punctuation

	};

const TUint32 TUnicodeCompressionState::iDynamicWindowDefault[EDynamicWindows] =

	{

	0x0080,		// Latin-1 supplement

	0x00C0,		// parts of Latin-1 supplement and Latin Extended-A

	0x0400,		// Cyrillic

	0x0600,		// Arabic

	0x0900,		// Devanagari

	0x3040,		// Hiragana

	0x30A0,		// Katakana

	0xFF00		// Fullwidth ASCII

	};

const TUint16 TUnicodeCompressionState::iSpecialBase[ESpecialBases] =

	{

	0x00C0,		// Latin 1 letters (not symbols) and some of Extended-A

	0x0250,		// IPA extensions

	0x0370,		// Greek

	0x0530,		// Armenian

	0x3040,		// Hiragana

	0x30A0,		// Katakana

	0xFF60		// Halfwidth katakana

	};

// Single-byte mode tag values

const TUint8 SQ0 = 0x01;	// <byte>				quote from window 0

const TUint8 SDX = 0x0B;	// <hbyte> <lbyte>		define window in expansion area

const TUint8 SQU = 0x0E;	// <hbyte> <lbyte>		quote Unicode value

const TUint8 SCU = 0x0F;	//						switch to Unicode mode

const TUint8 SC0 = 0x10;	//						select dynamic window 0

const TUint8 SD0 = 0x18;	// <byte>				set dynamic window 0 index to <byte> and select it

// Unicode mode tag values

const TUint8 UC0 = 0xE0;	//						select dynamic window 0 and switch to single-byte mode

const TUint8 UD0 = 0xE8;	// <byte>				set dynamic window 0 index to <byte>, select it and switch to

							//						single-byte mode

const TUint8 UQU = 0xF0;	// <hbyte>, <lbyte>		quote Unicode value

const TUint8 UDX = 0xF1;	// <hbyte>, <lbyte>		define window in expansion area and switch to single-byte mode

TUnicodeCompressionState::TUnicodeCompressionState():

	iUnicodeWords(0),

	iMaxUnicodeWords(0),

	iCompressedBytes(0),

	iMaxCompressedBytes(0)

	{

	Reset();

	}

void TUnicodeCompressionState::Reset()

	{

	iUnicodeMode = false;

	iActiveWindowBase = 0x0080;

	for (int i = 0; i < EDynamicWindows; i++)

		iDynamicWindow[i] = iDynamicWindowDefault[i];

	}

// Return the index of the static window that contains this code, if any, or -1 if there is none.

TInt TUnicodeCompressionState::StaticWindowIndex(TUint16 aCode)

	{

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

		if (aCode >= iStaticWindow[i] && aCode < iStaticWindow[i] + 128)

			return i;

	return -1;

	}

/*

If aCode can be accommodated in one of the legal dynamic windows, return the index of that window

in the offset table. If not return KErrNotFound.

*/

TInt TUnicodeCompressionState::DynamicWindowOffsetIndex(TUint16 aCode)

	{

	if (aCode < 0x0080)

		return KErrNotFound;

	if (aCode >= 0x3400 && aCode <= 0xDFFF)

		return KErrNotFound;

	/*

	Prefer sections that cross half-->WriteUint8L(block boundaries. These are better adapted to actual text.

	They are represented by offset indices 0xf9..0xff.

	*/

	for (int i = 0; i < ESpecialBases; i++)

		if (aCode >= iSpecialBase[i] && aCode < iSpecialBase[i] + 128)

			return 0xF9 + i;

	/*

	Offset indices 0x01..0x67 represent half blocks from 0x0080 to 0x3380 and

	0x68..0xA7 represent half blocks from 0xE000 to 0xFF80.

	*/

	if (aCode >= 0xE000)

		aCode -= 0xAC00;

	return aCode / 0x80;

	}

// Return the base of the window represented by offset index <n>. Return 0 if the offset index is illegal.

TUint32 TUnicodeCompressionState::DynamicWindowBase(TInt aOffsetIndex)

	{

	if (aOffsetIndex >= 0xF9 && aOffsetIndex <= 0xFF)

		{

		/*->WriteUint8L(

		WARNING: don't optimise the following two lines by replacing them with

		'return iSpecialBase[aOffsetIndex - 0xF9];'. To do so would re-introduce a defect

		in ARM builds caused by optimisation and consequent erroneous fixing up

		of the array base: see defect EDNGASR-4AGJQX in ER5U defects.

		*/

		int special_base_index = aOffsetIndex - 0xF9;

		return iSpecialBase[special_base_index];

		}

	if (aOffsetIndex >= 0x01 && aOffsetIndex <= 0x67)

		return aOffsetIndex * 0x80;

	if (aOffsetIndex >= 0x68 && aOffsetIndex <= 0xA7)

		return aOffsetIndex * 0x80 + 0xAC00;

	return 0;

	}

TBool TUnicodeCompressionState::EncodeAsIs(TUint16 aCode)

	{

	return aCode == 0x0000 || aCode == 0x0009 || aCode == 0x000A || aCode == 0x000D ||

		   (aCode >= 0x0020 && aCode <= 0x007F);

	}

void TUnicodeCompressionState::Panic(TPanic /*aPanic*/)

	{

	throw std::runtime_error("ucmp");

	}

 TUnicodeCompressor::TUnicodeCompressor():

	iInputBufferStart(0),

	iInputBufferSize(0),

	iOutputBufferStart(0),

	iOutputBufferSize(0),

	iDynamicWindowIndex(0),

	iOutputStream(NULL),

	iOutputPointer(NULL),

	iInput(NULL)

	{

	}

 void TUnicodeCompressor::CompressL(Serialiser& aOutput,MUnicodeSource& aInput,

											TInt aMaxOutputBytes,TInt aMaxInputWords,

											TInt* aOutputBytes,TInt* aInputWords)

	{

	DoCompressL(&aOutput,NULL,&aInput,aMaxOutputBytes,aMaxInputWords,aOutputBytes,aInputWords);

	}

 void TUnicodeCompressor::CompressL(TUint8* aOutput,MUnicodeSource& aInput,

											TInt aMaxOutputBytes,TInt aMaxInputWords,

											TInt* aOutputBytes,TInt* aInputWords)

	{

	DoCompressL(NULL,aOutput,&aInput,aMaxOutputBytes,aMaxInputWords,aOutputBytes,aInputWords);

	}

 TInt TUnicodeCompressor::FlushL(Serialiser& aOutput,TInt aMaxOutputBytes,TInt& aOutputBytes)

	{

	DoCompressL(&aOutput,NULL,NULL,aMaxOutputBytes,0,&aOutputBytes,NULL);

	return iOutputBufferSize;

	}

 TInt TUnicodeCompressor::FlushL(TUint8* aOutput,TInt aMaxOutputBytes,TInt& aOutputBytes)

	{

	DoCompressL(NULL,aOutput,NULL,aMaxOutputBytes,0,&aOutputBytes,NULL);

	return iOutputBufferSize;

	}

 TInt TUnicodeCompressor::CompressedSizeL(MUnicodeSource& aInput,TInt aInputWords)

	{

	TInt bytes;

	TUnicodeCompressor c;

	c.DoCompressL(NULL,NULL,&aInput,KMaxTInt,aInputWords,&bytes,NULL);

	return bytes;

	}

// Compress until input or output is exhausted or an exception occurs.

void TUnicodeCompressor::DoCompressL(Serialiser* aOutputStream,TUint8* aOutputPointer,MUnicodeSource* aInput,

									 TInt aMaxOutputBytes,TInt aMaxInputWords,

									 TInt* aOutputBytes,TInt* aInputWords)

	{

	iOutputStream = aOutputStream;

	iOutputPointer = aOutputPointer;

	iInput = aInput;

	iMaxCompressedBytes = aMaxOutputBytes;

	iMaxUnicodeWords = aMaxInputWords;

	iCompressedBytes = iUnicodeWords = 0;

	FlushOutputBufferL();

	if (iInput)

		{

		while (iUnicodeWords < iMaxUnicodeWords && iCompressedBytes < iMaxCompressedBytes)

			{

			TUint16 x = iInput->ReadUnicodeValueL();

			TAction action(x);

			iInputBuffer[(iInputBufferStart + iInputBufferSize) % EMaxInputBufferSize] = action;

			iInputBufferSize++;

			iUnicodeWords++;

			if (iInputBufferSize == EMaxInputBufferSize)

				WriteRunL();

			}

		}

	FlushInputBufferL();

	if (aOutputBytes)

		*aOutputBytes = iCompressedBytes;

	if (aInputWords)

		*aInputWords = iUnicodeWords;

	}

TUnicodeCompressor::TAction::TAction(TUint16 aCode):

	iCode(aCode)

	{

	if (TUnicodeCompressionState::EncodeAsIs(aCode))

		iTreatment = EPlainASCII;

	else

		{

		iTreatment = TUnicodeCompressionState::DynamicWindowOffsetIndex(aCode);

		if (iTreatment == -1)

			{

			iTreatment = TUnicodeCompressionState::StaticWindowIndex(aCode);

			if (iTreatment == -1)

				iTreatment = EPlainUnicode;

			else

				iTreatment += EFirstStatic;

			}

		}

	}

void TUnicodeCompressor::WriteCharacterFromBuffer()

	{

	const TAction& action = iInputBuffer[iInputBufferStart];

	iInputBufferSize--;

	iInputBufferStart = (iInputBufferStart + 1) % EMaxInputBufferSize;

	WriteCharacter(action);

	}

void TUnicodeCompressor::FlushInputBufferL()

	{

	while (iInputBufferSize > 0 && iCompressedBytes < iMaxCompressedBytes)

		WriteRunL();

	}

void TUnicodeCompressor::WriteRunL()

	{

	// Write out any leading characters that can be passed through.

	if (!iUnicodeMode)

		while (iInputBufferSize > 0)

			{

			const TAction& action = iInputBuffer[iInputBufferStart];

			if (action.iTreatment == TAction::EPlainASCII ||

				(action.iCode >= iActiveWindowBase && action.iCode < iActiveWindowBase + 128))

				WriteCharacterFromBuffer();

			else

				break;

			}

	// Write a run of characters that cannot be passed through.

	int i;

	if (iInputBufferSize > 0)

		{

		/*

		Find a run of characters with the same treatment and select that treatment

		if the run has more than one character.

		*/

		int treatment = iInputBuffer[iInputBufferStart].iTreatment;

		int next_treatment = treatment;

		int run_size = 1;

		for (i = 1; i < iInputBufferSize; i++)

			{

			int index = (iInputBufferStart + i) % EMaxInputBufferSize;

			next_treatment = iInputBuffer[index].iTreatment;

			if (next_treatment != treatment)

				break;

			run_size++;

			}

		if (run_size > 1)

			SelectTreatment(treatment);

		for (i = 0; i < run_size; i++)

			WriteCharacterFromBuffer();

		}

	FlushOutputBufferL();

	}

void TUnicodeCompressor::FlushOutputBufferL()

	{

	while (iOutputBufferSize > 0 &&	iCompressedBytes < iMaxCompressedBytes)

		{

		TUint8 byte = iOutputBuffer[iOutputBufferStart];

		if (iOutputPointer)

			*iOutputPointer++ = byte;

		else if (iOutputStream)

			*iOutputStream << byte;

		iCompressedBytes++;

		iOutputBufferSize--;

		iOutputBufferStart = (iOutputBufferStart + 1) % EMaxOutputBufferSize;

		}

	}

void TUnicodeCompressor::SelectTreatment(TInt aTreatment)

	{

	if (aTreatment == TAction::EPlainUnicode)

		{

		// Switch to Unicode mode if not there already.

		if (!iUnicodeMode)

			{

			WriteByte(SCU);

			iUnicodeMode = true;

			}

		return;

		}

	if (aTreatment == TAction::EPlainASCII)

		{

		// Switch to single-byte mode, using the current dynamic window, if not there already.

		if (iUnicodeMode)

			{

			WriteByte(UC0 + iDynamicWindowIndex);

			iUnicodeMode = false;

			}

		return;

		}

	if (aTreatment >= TAction::EFirstDynamic && aTreatment <= TAction::ELastDynamic)

		{

		TUint32 base = DynamicWindowBase(aTreatment);

		// Switch to the appropriate dynamic window if it is available; if not, redefine and select dynamic window 4.

		for (int i = 0; i < EDynamicWindows; i++)

			if (base == iDynamicWindow[i])

				{

				if (iUnicodeMode)

					WriteByte(UC0 + i);

				else if (i != iDynamicWindowIndex)

					WriteByte(SC0 + i);

				iUnicodeMode = false;

				iDynamicWindowIndex = i;

				iActiveWindowBase = base;

				return;

				}

		if (iUnicodeMode)

			WriteByte(UD0 + 4);

		else

			WriteByte(SD0 + 4);

		iDynamicWindowIndex = 4;

		iUnicodeMode = false;

		WriteByte(aTreatment);

		iDynamicWindow[4] = base;

		iActiveWindowBase = base;

		return;

		}

	}

// Write a character without changing mode or window.

void TUnicodeCompressor::WriteCharacter(const TAction& aAction)

	{

	if (iUnicodeMode)

		WriteUCharacter(aAction.iCode);

	else

		WriteSCharacter(aAction);

	}

void TUnicodeCompressor::WriteUCharacter(TUint16 aCode)

	{

	// Emit the 'quote Unicode' tag if the character would conflict with a tag.

	if (aCode >= 0xE000 && aCode <= 0xF2FF)

		WriteByte(UQU);

	// Write the Unicode value big-end first.

	WriteByte((aCode >> 8) & 0xFF);

	WriteByte(aCode & 0xFF);

	}

void TUnicodeCompressor::WriteByte(TUint32 aByte)

	{

	if (iOutputBufferSize >= EMaxOutputBufferSize)

		Panic(EOutputBufferOverflow);

	iOutputBuffer[(iOutputBufferStart + iOutputBufferSize) % EMaxOutputBufferSize] = (TUint8)aByte;

	iOutputBufferSize++;

	}

void TUnicodeCompressor::WriteSCharacter(const TAction& aAction)

	{

	// Characters in the range 0x0020..0x007F, plus nul, tab, cr, and lf, can be emitted as their low bytes.

	if (aAction.iTreatment == TAction::EPlainASCII)

		{

		WriteByte(aAction.iCode);

		return;

		}

	// Characters in a static window can be written using SQ<n> plus a byte in the range 0x00-0x7F

	if (aAction.iTreatment >= TAction::EFirstStatic && aAction.iTreatment <= TAction::ELastStatic)

		{

		int window = aAction.iTreatment - TAction::EFirstStatic;

		WriteByte(SQ0 + window);

		WriteByte(aAction.iCode);

		return;

		}

	// Characters in the current dynamic window can be written as a byte in the range 0x80-0xFF.

	if (aAction.iCode >= iActiveWindowBase && aAction.iCode < iActiveWindowBase + 128)

		{

		WriteByte(aAction.iCode - iActiveWindowBase + 0x80);

		return;

		}

	// Characters in another dynamic window can be written using SQ<n> plus a byte in the range 0x80-0xFF

	int i;

	for (i = 0; i < EDynamicWindows; i++)

		if (aAction.iCode >= iDynamicWindow[i] && aAction.iCode < iDynamicWindow[i] + 128)

			{

			WriteByte(SQ0 + i);

			WriteByte(aAction.iCode - iDynamicWindow[i] + 0x80);

			return;

			}

	// Other characters can be quoted.

	WriteByte(SQU);

	WriteByte((aAction.iCode >> 8) & 0xFF);

	WriteByte(aAction.iCode & 0xFF);

	return;

	}

 TUnicodeExpander::TUnicodeExpander():

	iInputBufferStart(0),

	iInputBufferSize(0),

	iOutputBufferStart(0),

	iOutputBufferSize(0),

	iOutput(NULL),

	iInputStream(NULL),

	iInputPointer(NULL)

	{

	}

 void TUnicodeExpander::ExpandL(MUnicodeSink& aOutput,Deserialiser& aInput,

										TInt aMaxOutputWords,TInt aMaxInputBytes,

										TInt* aOutputWords,TInt* aInputBytes)

	{

	DoExpandL(&aOutput,&aInput,NULL,aMaxOutputWords,aMaxInputBytes,aOutputWords,aInputBytes);

	}

 void TUnicodeExpander::ExpandL(MUnicodeSink& aOutput,const TUint8* aInput,

										TInt aMaxOutputWords,TInt aMaxInputBytes,

										TInt* aOutputWords,TInt* aInputBytes)

	{

	DoExpandL(&aOutput,NULL,aInput,aMaxOutputWords,aMaxInputBytes,aOutputWords,aInputBytes);

	}

 TInt TUnicodeExpander::FlushL(MUnicodeSink& aOutput,TInt aMaxOutputWords,TInt& aOutputWords)

	{

	DoExpandL(&aOutput,NULL,NULL,aMaxOutputWords,0,&aOutputWords,NULL);

	return iOutputBufferSize;

	}

 TInt TUnicodeExpander::ExpandedSizeL(Deserialiser& aInput,TInt aInputBytes)

	{

	TInt words;

	TUnicodeExpander e;

	e.DoExpandL(NULL,&aInput,NULL,KMaxTInt,aInputBytes,&words,NULL);

	return words;

	}

 TInt TUnicodeExpander::ExpandedSizeL(const TUint8* aInput,TInt aInputBytes)

	{

	TInt words;

	TUnicodeExpander e;

	e.DoExpandL(NULL,NULL,aInput,KMaxTInt,aInputBytes,&words,NULL);

	return words;

	}

// Expand until input or output is exhausted or an exception occurs.

void TUnicodeExpander::DoExpandL(MUnicodeSink* aOutput,Deserialiser* aInputStream,const TUint8* aInputPointer,

								 TInt aMaxOutputWords,TInt aMaxInputBytes,

								 TInt* aOutputWords,TInt* aInputBytes)

	{

	iOutput = aOutput;

	iInputStream = aInputStream;

	iInputPointer = aInputPointer;

	iMaxUnicodeWords = aMaxOutputWords;

	iMaxCompressedBytes = aMaxInputBytes;

	iUnicodeWords = iCompressedBytes = 0;

	iInputBufferStart = 0;

	FlushOutputBufferL();

	if (iInputPointer || iInputStream)

		{

		while (iUnicodeWords + iOutputBufferSize < iMaxUnicodeWords && iCompressedBytes < iMaxCompressedBytes)

			HandleByteL();

		}

	if (aOutputWords)

		*aOutputWords = iUnicodeWords;

	if (aInputBytes)