/*

* 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: 

*

*/

#include <e32std.h>

#include <charconv.h>

#include <convutils.h>

#include "jisx0201.h"

#include "jisx0208.h"

#include "shiftjis.h"

#include <convdata.h>

#include "charconv_tls.h"

#include "charconv_table_utilities.h"

// Lead byte ranges for 2-Byte Shift-JIS sequences

const TUint KSingleByteRangeFirstBlockEnd=0x80;

const TUint KSingleByteRangeSecondBlockStart=0xa0;

const TUint KSingleByteRangeSecondBlockEnd=0xdf;

const TUint KLeadByteMax = 0xfc;

//Trail byte ranges for 2-Byte Shift-JIS sequences

const TUint KTrailByteMin = 0x40 ;

const TUint KTrailByteMax = 0xFC ;

const TUint KTrailByteIllegal = 0x7F ;

const TUint8 KSJISLineFeed = 0x0a ;	// Shift-Jis value for Line Feed

const TUint8 KSJISCarriageReturn = 0x0d;	// Shift-Jis value for Carriage Return

const TUint16 KUnicodeLineFeed = 0x2028; // Unicode Line Feed

const TUint16 KUnicodeParagraphSeperator = 0x2029; // Unicode Paragraph seperator

const TUint16 KUnicodeCarriageReturn = KSJISCarriageReturn ;

/** 

 * Get the Shift-JIS replacement for Unicode characters which cannot be converted

 * 

 * @return const TDesC8& 8-bit descriptor containing the Shift-JIS data which will replace any untranslatable Unicode characters.

 * @since Internationalization_6.2

 * @internalTechnology

 */

EXPORT_C const TDesC8& CnvShiftJis::ReplacementForUnconvertibleUnicodeCharacters()

	{

	return ReplacementForUnconvertibleUnicodeCharacters_internal();

	}

/**

 * Converts text from Unicode to Shift-JIS 

 * 

 * @since Internationalization_6.2

 * @internalTechnology 

 */

EXPORT_C TInt CnvShiftJis::ConvertFromUnicode(CCnvCharacterSetConverter::TEndianness /* aDefaultEndiannessOfForeignCharacters */,

                                              const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, TDes8& aForeign,

                                              const TDesC16& aUnicode,

                                              CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)

	{

	return DoConvertFromUnicode(aReplacementForUnconvertibleUnicodeCharacters, 

	                            aForeign, aUnicode, aIndicesOfUnconvertibleCharacters) ;

	}

/**

 * Converts text from Unicode to Shift-JIS 

 * Note that CnvShiftJis does NOT support extensions through use of additional character sets,

 * instead multiple versions are built for the different (operator defined) implementations

 * of Shift-JIS which need to be supported and the correct one installed at ROM build time,

 * and this method is only supplied for purposes of interface compatibility. 

 * @since Internationalization_6.2

 * @internalTechnology

 */

EXPORT_C TInt CnvShiftJis::ConvertFromUnicode(CCnvCharacterSetConverter::TEndianness /* aDefaultEndiannessOfForeignCharacters */, 

                                              const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 

                                              TDes8& aForeign, const TDesC16& aUnicode, 

                                              CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters, 

                                              const TArray<CnvUtilities::SCharacterSet>& /* aArrayOfAdditionalCharacterSets */)

	{

	return DoConvertFromUnicode(aReplacementForUnconvertibleUnicodeCharacters, 

	                            aForeign, aUnicode, aIndicesOfUnconvertibleCharacters) ;

	}

EXPORT_C TInt CnvShiftJis::ConvertToUnicode(CCnvCharacterSetConverter::TEndianness /* aDefaultEndiannessOfForeignCharacters */,

                                            TDes16& aUnicode, const TDesC8& aForeign, TInt& aNumberOfUnconvertibleCharacters,

                                            TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)

	{

	return DoConvertToUnicode(aUnicode, aForeign, aNumberOfUnconvertibleCharacters, 

                              aIndexOfFirstByteOfFirstUnconvertibleCharacter) ;

	}

/**

 * Converts text from Shift-JIS to Unicode 

 * 

 * @since Internationalization_6.2

 * @internalTechnology

 */

EXPORT_C TInt CnvShiftJis::ConvertToUnicode(CCnvCharacterSetConverter::TEndianness /* aDefaultEndiannessOfForeignCharacters */, 

                                            TDes16& aUnicode, const TDesC8& aForeign, 

                                            TInt& aNumberOfUnconvertibleCharacters, 

                                            TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter, 

                                            const TArray<CnvUtilities::SMethod>& /* aArrayOfAdditionalMethods */)

	{

	return DoConvertToUnicode(aUnicode, aForeign, aNumberOfUnconvertibleCharacters, 

                              aIndexOfFirstByteOfFirstUnconvertibleCharacter) ;

	}

/**

This function actually does the work of converting Shift-JIS input to unicode output.

@param TDes16& aUnicode The output buffer

@param const TDesC8& aForeign The input buffer

@param TInt& aNumberOfUnconvertibleCharacters Number of input characters which were processed but couldn't be converted. 

@param TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter Locates first untranslatable character in input buffer

@return CCnvCharacterSetConverter::EErrorIllFormedInput if the input was invalid, otherwise the number of bytes in the input buffer which weren't be processed (e.g. due to output buffer overflow). 

@internalTechnology

*/

TInt CnvShiftJis::DoConvertToUnicode(TDes16& aUnicode, const TDesC8& aForeign, 

                                     TInt& aNumberOfUnconvertibleCharacters, 

                                     TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)

	{

	TUint foreignBytePointer = 0 ;

	TUint row ;

	TUint column ;

	TUint8 foreignCharByte ;

	TUint8 foreignCharStart ;

	TChar unicodeChar ;

	TBool finished = EFalse ;

	TInt charsConverted = 0 ;

	TUint16 unicodeUnmappedCharacter = getUnicodeUnmappedCharacter() ;

	TInt unicodeBufferLength = aUnicode.MaxLength() ;

	TInt foreignDataLength = aForeign.Length() ;

	aIndexOfFirstByteOfFirstUnconvertibleCharacter = -1 ;

	aNumberOfUnconvertibleCharacters = 0 ;

	// Check for valid input and output buffers

	if (( unicodeBufferLength == 0) || foreignDataLength == 0)

		{

		finished = ETrue ;		

		}

	// Reset output buffer	

	aUnicode.Zero() ;

	// Perform conversion		

	while (!finished)

		{

		foreignCharStart = foreignBytePointer ;

		foreignCharByte = aForeign[foreignBytePointer++] ;

		// Look for (and handle) CR/LF pairs in ShiftJis input stream.

		// It is a specific requirement from Symbian KK that CR/LF pairs

		// in the input stream be converted to Unicode LF characters 

		if((KSJISCarriageReturn == foreignCharByte) && (foreignBytePointer < foreignDataLength))

			{

			// check next byte

			if(KSJISLineFeed == aForeign[foreignBytePointer]) 

				{

				// CR code

				unicodeChar = KUnicodeLineFeed ;

				foreignBytePointer++ ;

				}

			else

				{					

				unicodeChar = KUnicodeCarriageReturn ;

				}

			}

		else

			{

			if (((foreignCharByte > KSingleByteRangeFirstBlockEnd) && 

			     (foreignCharByte < KSingleByteRangeSecondBlockStart)) ||

			    ((foreignCharByte > KSingleByteRangeSecondBlockEnd) &&

			     (foreignCharByte <= KLeadByteMax)))

				{

				if (foreignBytePointer < foreignDataLength)

					{

					// Potential 2 byte shiftJis character

					row = foreignCharByte ;

					column = aForeign[foreignBytePointer] ;

					if (((column <= KTrailByteMax) && (column >= KTrailByteMin)) && column != KTrailByteIllegal)

						{

						foreignBytePointer++ ;	

						unicodeChar = lookupUnicodeChar(row,column) ;	

						}

					else

						{

						unicodeChar = unicodeUnmappedCharacter ;

						}

					}

				else

					{

					// Only got the first byte of a 2 byte character

					// reset "read" pointer to beginning of character

					// and bail out!

					finished = ETrue ;

					foreignBytePointer-- ;

					continue ;

					}

				}

			else

				{

				//Probably a single byte shiftJis chracter

				row = 0 ;

				column = foreignCharByte ;

				unicodeChar = lookupUnicodeChar(row,column) ;

				}

			}

		// Check for unconvertible characters.

		if (unicodeChar == unicodeUnmappedCharacter)

			{

			if (aIndexOfFirstByteOfFirstUnconvertibleCharacter == -1)

				{

				aIndexOfFirstByteOfFirstUnconvertibleCharacter = foreignCharStart ;

				}

			aNumberOfUnconvertibleCharacters++ ;

			}

		// Append the converted (or not!) character to the output buffer

		aUnicode.Append(unicodeChar);

		charsConverted++ ;

		// Check for end of input buffer or output buffer full

		if ((charsConverted >= unicodeBufferLength) || (foreignBytePointer >= foreignDataLength))

			finished = ETrue ;

		}

	// Evaluate success of the operation and either return error code (currently just 

	// invalid input) or return number of un-processed characters in input buffer in

	// case of output buffer being filled before input fully consumed (0 means all

	// characters consumed)

	TInt returnValue ;

	if (foreignDataLength && !charsConverted)

		{

		// Input must contain at least one complete character to be considered valid Shift-JIS.

		returnValue = CCnvCharacterSetConverter::EErrorIllFormedInput ;

		}

	else

		{

		returnValue = foreignDataLength - foreignBytePointer;

		}

	return returnValue ;

	}

/**

This function actually does the work of converting converting unicode input to Shift-JIS  output.

@param const TDesC8& aReplacementForUnconvertibleUnicodeCharacters byte sequence to be be used as output for unicode characters which have no mapping defined.

@param TDes16& aUnicode The input buffer

@param const TDesC8& aForeign The output buffer

@return The number of unicode characters in the input buffer which weren't be processed (e.g. due to output buffer overflow). 

@internalTechnology

*/

TInt CnvShiftJis::DoConvertFromUnicode(const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, 

	                                   TDes8& aForeign, const TDesC16& aUnicode, 

	                                   CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)

	{

	TUint unicodePointer = 0 ;

	TUint row ;

	TUint column ;

	TUint8 foreignCharByte ;

	TUint16 foreignChar ;

	TUint16 unicodeChar ;

	TBool finished = EFalse ;

	TInt charsConverted = 0 ;

	TInt unicodeLength = aUnicode.Length() ;

	TInt foreignMaxLength = aForeign.MaxLength() ;

	TUint16 foreignUnmappedCharacter = getForeignUnmappedCharacter() ;

	CCnvCharacterSetConverter::TDowngradeForExoticLineTerminatingCharacters downgradeForExoticLineTerminatingCharacters = CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToCarriageReturnLineFeed;

	TBool downgradeExoticLineTerminatingCharacters	= EFalse ;

	// Check for valid input and output buffers

	if ((unicodeLength == 0) ||  foreignMaxLength == 0)

		{

		finished = ETrue ;		

		}

	// If we've been called from an instance of CCnvCharacterSetConverter we can retrieve its state

	// from Thread Local Storage. This really isn't very nice but there's no other way we can get

	// hold of settings like downgrade for unicode line termination characters without breaking

	// compatibility with the existing plug-in interface!

	CCnvCharacterSetConverter* currentCharacterSetConverter = (CCnvCharacterSetConverter*)TTlsData::CurrentCharacterSetConverter();

	if (currentCharacterSetConverter)

		{

		downgradeForExoticLineTerminatingCharacters = currentCharacterSetConverter->GetDowngradeForExoticLineTerminatingCharacters() ;

		downgradeExoticLineTerminatingCharacters = ETrue ;

		}

	// Reset output buffer

	aForeign.Zero();

	// Process input buffer

	while (!finished)

		{

		// Look up foreign Char

		unicodeChar = aUnicode[unicodePointer] ;

		// Check for any downgrade of Unicode line endings characters required if we've got

		// a Unicode Line-Feed or Paragraph-Seperator character to deal with. 

		if (downgradeExoticLineTerminatingCharacters && 

		    ((unicodeChar==KUnicodeLineFeed) || (unicodeChar==KUnicodeParagraphSeperator)))

			{

			if (downgradeForExoticLineTerminatingCharacters == CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToCarriageReturnLineFeed)

				{

				if (aForeign.Length() < (foreignMaxLength - 1))

					{

					aForeign.Append(KSJISCarriageReturn) ;

					aForeign.Append(KSJISLineFeed) ;

					charsConverted++ ;

					}

					else

					{

					// Foreign buffer full!

					finished = ETrue;

					}

				}

			else if (downgradeForExoticLineTerminatingCharacters == CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed)

				{

				if (aForeign.Length() < foreignMaxLength)

					{

					aForeign.Append(KSJISLineFeed) ;

					charsConverted++ ;

					}

					else

					{

					// Foreign buffer full!

					finished = ETrue;

					}

				}		

			}

		else

			{	

			row = unicodeChar / 256 ;

			column = unicodeChar % 256 ;		

			foreignChar = lookupForeignChar(row, column) ;		

			// Check for untranslatable character 

			if ((foreignChar == foreignUnmappedCharacter) &&

			    (aForeign.Length() < (foreignMaxLength - 1)))

				{

				aIndicesOfUnconvertibleCharacters.AppendIndex(unicodePointer) ;

				aForeign.Append(aReplacementForUnconvertibleUnicodeCharacters) ;

				}	

			else if ((foreignChar <= 0xFF) && (aForeign.Length() < foreignMaxLength))

				{

				// Single byte character

				foreignCharByte = (TUint8) foreignChar ;

				aForeign.Append(foreignCharByte) ;

				charsConverted++ ;

				}

			else if (aForeign.Length() < (foreignMaxLength - 1))

				{

				// Two byte character

				foreignCharByte = (TUint8) (foreignChar >> 8 ) ;

				aForeign.Append(foreignCharByte) ;

				foreignCharByte = (TUint8) (foreignChar & 0xFF) ;

				aForeign.Append(foreignCharByte) ;

				charsConverted++ ;

				}

			else

				{

				// Foreign buffer full!

				finished = ETrue;

				}

			}

		// Check for terminating condition (input buffer consumed or output buffer full)	

		if (!finished && (++unicodePointer >= unicodeLength))

			{

			finished = ETrue ;

			}

		}

	// Return number of input characters *not* processsed (will be zero unless output

	// buffer has been filled before all input consumed)	

	return unicodeLength - unicodePointer;

	}