diff -r 000000000000 -r bde4ae8d615e os/textandloc/charconvfw/charconvplugins/src/plugins/ucs2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/textandloc/charconvfw/charconvplugins/src/plugins/ucs2.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,278 @@ +/* +* 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 +#include +#include +#include "ucs2.h" +#include +#include + +class CUCS2ConverterImpl : public CCharacterSetConverterPluginInterface + { + +public: + virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters(); + + virtual TInt ConvertFromUnicode( + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, + const TDesC8& aReplacementForUnconvertibleUnicodeCharacters, + TDes8& aForeign, + const TDesC16& aUnicode, + CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters); + + virtual TInt ConvertToUnicode( + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, + TDes16& aUnicode, + const TDesC8& aForeign, + TInt& aState, + TInt& aNumberOfUnconvertibleCharacters, + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter); + + virtual TBool IsInThisCharacterSetL( + TBool& aSetToTrue, + TInt& aConfidenceLevel, + const TDesC8& aSample); + + static CUCS2ConverterImpl* NewL(); + virtual ~CUCS2ConverterImpl(); + +private: + CUCS2ConverterImpl(); + + }; + + + +// The following code has been copied and modified from the plugin computer generated code +// that is generated from the charconv/data/???.cpl && /???.txt files +// *** code begins *** +#define ARRAY_LENGTH(aArray) (sizeof(aArray)/sizeof((aArray)[0])) + +#pragma warning (disable: 4049) // compiler limit : terminating line number emission + +_LIT8(KLit8ReplacementForUnconvertibleUnicodeCharacters, "\xff\xfd"); + +GLDEF_C const TDesC8& ReplacementForUnconvertibleUnicodeCharacters_internal() + { + return KLit8ReplacementForUnconvertibleUnicodeCharacters; + } + +GLDEF_D const SCnvConversionData conversionData= + { + SCnvConversionData::EUnspecified, + {NULL,NULL}, + {NULL,NULL}, + {NULL,NULL}, + NULL, + NULL + }; + + +const TInt KByteOrderMark = 0xfeff; +const TInt KStateOffset = 0x1000; + + +const TDesC8& CUCS2ConverterImpl::ReplacementForUnconvertibleUnicodeCharacters() + { + return ReplacementForUnconvertibleUnicodeCharacters_internal(); + } + + +/** + * Takes a 16 bit UCS2 descriptor with or without BOM and translates it to an + * eight bit descriptor in Big Endian format. + * + * Note aDefaultEndiannessOfForeignCharacters is not used by this converter + * + * @param CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters + * @param const TDesC8& + * @param TDes8& aForeign + * @param const TDesC16& aUnicode + * @param CCnvCharacterSetConverter::TArrayOfAscendingIndices& + * + * returns number of converted characters +*/ +TInt CUCS2ConverterImpl::ConvertFromUnicode(CCnvCharacterSetConverter::TEndianness /*aDefaultEndiannessOfForeignCharacters*/, + const TDesC8& /*aReplacementForUnconvertibleUnicodeCharacters*/, + TDes8& aForeign, + const TDesC16& aUnicode, + CCnvCharacterSetConverter::TArrayOfAscendingIndices& /*aIndicesOfUnconvertibleCharacters*/) + { + TInt numberOfUnicodeCharacters =0; + TInt nextChar; + + // start at the begining of the output buffer + aForeign.Zero(); + + // while there is unicode data to convert and space in the output buffer + while ( (aForeign.Length() + 1 < aForeign.MaxLength()) && (numberOfUnicodeCharacters < aUnicode.Length()) ) + { + nextChar = aUnicode[numberOfUnicodeCharacters]; + + // Note - this always converts to EBigEndian + aForeign.Append((nextChar & 0xff00) >> 8); + aForeign.Append(nextChar & 0xff ); + + numberOfUnicodeCharacters++; + } + + // returns the number of unconverted characters left at the end of the input descriptor + return aUnicode.Length() - numberOfUnicodeCharacters; + } + +/** + * Takes an 8 bit descriptor with or without a BOM and translates it to unicode + * Input endiness is determined by Byte Order Markers (BOM) in the source text. + * If no BOM is present aDefaultEndiannessOfForeignCharacters is used. + * + * When the data is too large to fit in the output buffer, the endiness is saved in the state + * variable between conversions + * + * @param aDefaultEndiannessOfForeignCharacters Default endiness if no BOMs present in the source + * @param aUnicode Contains the converted text in the Unicode character set + * @param aForeign The non-Unicode source text to be converted + * @param aState Not used by this converter + * @param aNumberOfUnconvertibleCharacters Contains the number of bytes which could not be converted to unicode + * @param aIndexOfFirstByteOfFirstUnconvertibleCharacter The index of the first unconvertable byte or -1 if all converted. + * + * @return aNumberOfUnconvertibleCharacters The number of unconverted bytes left at the end of the input + * descriptor (e.g. because the output descriptor is not long enough to hold all the text), or one of the + * error values defined in TError. + * @internalTechnology + */ +TInt CUCS2ConverterImpl::ConvertToUnicode(CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters, + TDes16& aUnicode, + const TDesC8& aForeign, + TInt& aState, + TInt& aNumberOfUnconvertibleCharacters, + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter) + { + TInt numberOfBytesConverted = 0; + TInt numberOfUnicodeCharacters =0; + TChar nextChar; + + // work out what byte order to use + CCnvCharacterSetConverter::TEndianness byteOrderMark; + if ( aState==CCnvCharacterSetConverter::KStateDefault ) + { + // this is the first call so use the default or BOM for byte order + byteOrderMark = aDefaultEndiannessOfForeignCharacters; + } + else + { + // this is not the first call so use the saved byte order + byteOrderMark = STATIC_CAST( CCnvCharacterSetConverter::TEndianness, aState - KStateOffset ); + } + + if ( aForeign.Length() < 2) + { // too small to do anything with + return -1; + } + // If the state is KStateDefault (this is the first call) check for BOM markers + else if (aState==CCnvCharacterSetConverter::KStateDefault) + { + // is there a Little Endian BOM + if (aForeign[0]==0xff && aForeign[1]==0xfe ) + { + byteOrderMark = CCnvCharacterSetConverter::ELittleEndian; + } + else if (aForeign[0]==0xfe && aForeign[1]==0xff ) + { + byteOrderMark = CCnvCharacterSetConverter::EBigEndian; + } + // remember the detected state + aState = byteOrderMark + KStateOffset; + } + + // start at begining of the output buffer provided + aUnicode.Zero(); + + // while there is at least 2 bytes of data to convert and space in the output buffer + while ( (numberOfBytesConverted+1 < aForeign.Size()) && (numberOfUnicodeCharacters < aUnicode.MaxLength()) ) + { + if (byteOrderMark == CCnvCharacterSetConverter::ELittleEndian ) + { + // ELittleEndian 0x??00 + nextChar = aForeign[numberOfBytesConverted] + ( aForeign[numberOfBytesConverted+1] << 8); + } + else + { + // EBigEndian 0x00?? + nextChar = ( aForeign[numberOfBytesConverted] <<8 ) + aForeign[numberOfBytesConverted+1]; + } + + // save the unicode character extracted unless it's a BOM + if ( nextChar != KByteOrderMark ) + { + aUnicode.Append( nextChar ); + numberOfUnicodeCharacters++; + } + + numberOfBytesConverted+=2; + } + + // there are no uncovertable characters with UCS2, + aNumberOfUnconvertibleCharacters = 0; + // a negative value indicates that all characters converted + aIndexOfFirstByteOfFirstUnconvertibleCharacter = -1; + + // returns the number of unconverted bytes left at the end of the input descriptor + // Note there could be 1 byte left over if an odd number of bytes provided for conversion + return aForeign.Size() - numberOfBytesConverted; + } + + +/** + * This converter does not support autodetect so always returns a confidence value of 0. + * @internalTechnology + */ +TBool CUCS2ConverterImpl::IsInThisCharacterSetL(TBool& aSetToTrue, TInt& aConfidenceLevel, const TDesC8&) + { + aSetToTrue=ETrue; + aConfidenceLevel=0; + return EFalse; + } + +CUCS2ConverterImpl* CUCS2ConverterImpl::NewL() + { + CUCS2ConverterImpl* self = new(ELeave) CUCS2ConverterImpl(); + return self; + } + +CUCS2ConverterImpl::~CUCS2ConverterImpl() + { + } + +CUCS2ConverterImpl::CUCS2ConverterImpl() + { + } + +const TImplementationProxy ImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x101FF492, CUCS2ConverterImpl::NewL) + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); + + return ImplementationTable; + } + +