1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/textandloc/charconvfw/charconvplugins/src/plugins/iscii.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1709 @@
1.4 +/*
1.5 +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
1.6 +* All rights reserved.
1.7 +* This component and the accompanying materials are made available
1.8 +* under the terms of "Eclipse Public License v1.0"
1.9 +* which accompanies this distribution, and is available
1.10 +* at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.11 +*
1.12 +* Initial Contributors:
1.13 +* Nokia Corporation - initial contribution.
1.14 +*
1.15 +* Contributors:
1.16 +*
1.17 +* Description: Implements the characterconversion plug-in
1.18 +* for ISCII characterset.
1.19 +*
1.20 +*/
1.21 +
1.22 +
1.23 +
1.24 +
1.25 +
1.26 +#include <e32std.h>
1.27 +#include <charconv.h>
1.28 +#include <convgeneratedcpp.h>
1.29 +#include <convutils.h>
1.30 +
1.31 +//The maximum length of any intermediate buffer allocated for conversion.
1.32 +const TInt KMaximumLengthOfIntermediateBuffer=5;
1.33 +//The ISCII ATR code point, used for ISCII script switching mechanism.
1.34 +const TUint KControlCharacterEscape=0xef;
1.35 +//The number of Indic scripts supported by the plug-in.
1.36 +//ISCII in general addresses all the Indic character sets.
1.37 +const TUint KNumberOfIndicCharactersetsSupported = 1;
1.38 +//The common reason for panic for all panics raised by the iscii plug-in
1.39 +_LIT16(KPanicReason,"ISCII Plug-in Panic");
1.40 +//The escape sequence for ISCII (ATR) is 0xEF and immidiate byte following
1.41 +//that is the script selection code for Devanagari.
1.42 +_LIT8(KEscapeSequenceDevanagari,"\xef\x42");
1.43 +//The sequence for Explicit Halant, in unicode it gets converted to VIRAMA+ZWNJ
1.44 +_LIT8(KExplicitHalant,"\xe8\xe8");
1.45 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.46 +//sequence is converted to intermediate unused iscii code point.
1.47 +_LIT8(KReplacementForExplicitHalant,"\xe8\xfc");
1.48 +//The sequence for Soft Halant, in unicode it gets converted to VIRAMA+ZWJ
1.49 +_LIT8(KSoftHalant,"\xe8\xe9");
1.50 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.51 +//sequence is converted to intermediate unused iscii code point.
1.52 +_LIT8(KReplacementForSoftHalant,"\xe8\xfd");
1.53 +//Devanagari character Om
1.54 +_LIT8(KOm,"\xa1\xe9");
1.55 +////For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.56 +//sequence is converted to intermediate unused iscii code point.
1.57 +_LIT8(KReplacementForOm,"\xfe");
1.58 +//Devanagari character Avagraha
1.59 +_LIT8(KAvagraha,"\xea\xe9");
1.60 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.61 +//sequence is converted to intermediate unused iscii code point.
1.62 +_LIT8(KReplacementForAvagraha,"\xff");
1.63 +
1.64 +//Devanagari character VOCALIC RR
1.65 +_LIT8(KVocalicRr,"\xaa\xe9");
1.66 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.67 +//sequence is converted to intermediate unused iscii code point.
1.68 +_LIT8(KReplacementForVocalicRr,"\x80");
1.69 +//Devanagari character VOCALIC LL
1.70 +_LIT8(KVocalicLl,"\xa7\xe9");
1.71 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.72 +//sequence is converted to intermediate unused iscii code point.
1.73 +_LIT8(KReplacementForVocalicLl,"\x81");
1.74 +//Devanagari character VOCALIC L SIGN
1.75 +_LIT8(KVocalicLSign,"\xdb\xe9");
1.76 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.77 +//sequence is converted to intermediate unused iscii code point.
1.78 +_LIT8(KReplacementForVocalicLSign,"\x82");
1.79 +//Devanagari character VOCALIC LL SIGN
1.80 +_LIT8(KVocalicLlSign,"\xdc\xe9");
1.81 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.82 +//sequence is converted to intermediate unused iscii code point.
1.83 +_LIT8(KReplacementForVocalicLlSign,"\x83");
1.84 +//Devanagari character VOCALIC L
1.85 +_LIT8(KVocalicL,"\xa6\xe9");
1.86 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.87 +//sequence is converted to intermediate unused iscii code point.
1.88 +_LIT8(KReplacementForVocalicL,"\x84");
1.89 +//Devanagari character VOCALIC RR SIGN
1.90 +_LIT8(KVocalicRrSign,"\xdf\xe9");
1.91 +//For supportiing ISCII to Unicode conversion of multi byte ISCII sequences, the
1.92 +//sequence is converted to intermediate unused iscii code point.
1.93 +_LIT8(KReplacementForVocalicRrSign,"\x85");
1.94 +
1.95 +//Unconvertible ISCII character
1.96 +_LIT8(KIsciiUnconvertibleCharacter,"\xeb");
1.97 +
1.98 +enum TPanic
1.99 +{
1.100 + //The panic raised by ConvertToUnicodeFromModalForeign_Internal() if the input
1.101 + //conversion flag is CCnvCharacterSetConverter::EInputConversionFlagStopAtFirstUnconvertibleCharacter
1.102 + EPanicBadInputConversionFlags=1,
1.103 + //Panic raised if the buffer does not start with the escape sequence 0xEF
1.104 + EPanicBadRemainderOfForeign,
1.105 + //Panic is raised if the length of the search buffer is greater than the length of the
1.106 + //replacement buffer
1.107 + EPanicBadReplacementBuffer,
1.108 + //If the offset of start of the escape sequence is not an unsigned number.
1.109 + EPanicBadStartOfNextEscapeSequence
1.110 +};
1.111 +
1.112 +//The dummy datastructure for the dummy conversion data i.e. used for conversion if the
1.113 +//script selection code is not supported.
1.114 +#define ARRAY_LENGTH(aArray) (sizeof(aArray)/sizeof((aArray)[0]))
1.115 +
1.116 +LOCAL_D const SCnvConversionData::SOneDirectionData::SRange::UData::SKeyedTable1616::SEntry keyedTable1616_foreignToUnicode_1[]=
1.117 + {
1.118 + {
1.119 + 0xa0,
1.120 + 0xfffd
1.121 + }
1.122 + };
1.123 +
1.124 +LOCAL_D const SCnvConversionData::SOneDirectionData::SRange::UData::SKeyedTable1616::SEntry keyedTable1616_unicodeToForeign_1[]=
1.125 + {
1.126 + {
1.127 + 0xfffd,
1.128 + 0xa0
1.129 + }
1.130 + };
1.131 +
1.132 +LOCAL_D const SCnvConversionData::SVariableByteData::SRange foreignVariableByteDataRanges[]=
1.133 + {
1.134 + {
1.135 + 0x00,
1.136 + 0xff,
1.137 + 0,
1.138 + 0
1.139 + }
1.140 + };
1.141 +
1.142 +LOCAL_D const SCnvConversionData::SOneDirectionData::SRange foreignToUnicodeDataRanges[]=
1.143 + {
1.144 + {
1.145 + 0x00,
1.146 + 0x7f,
1.147 + SCnvConversionData::SOneDirectionData::SRange::EDirect,
1.148 + 0,
1.149 + 0,
1.150 + {
1.151 + 0
1.152 + }
1.153 + },
1.154 + {
1.155 + 0xa0,
1.156 + 0xff,
1.157 + SCnvConversionData::SOneDirectionData::SRange::EKeyedTable1616,
1.158 + 0,
1.159 + 0,
1.160 + {
1.161 + UData_SKeyedTable1616(keyedTable1616_foreignToUnicode_1)
1.162 + }
1.163 + }
1.164 + };
1.165 +
1.166 +LOCAL_D const SCnvConversionData::SOneDirectionData::SRange unicodeToForeignDataRanges[]=
1.167 + {
1.168 + {
1.169 + 0x0000,
1.170 + 0x007f,
1.171 + SCnvConversionData::SOneDirectionData::SRange::EDirect,
1.172 + 1,
1.173 + 0,
1.174 + {
1.175 + 0
1.176 + }
1.177 + },
1.178 + {
1.179 + 0x00a0,
1.180 + 0xffff,
1.181 + SCnvConversionData::SOneDirectionData::SRange::EKeyedTable1616,
1.182 + 1,
1.183 + 0,
1.184 + {
1.185 + UData_SKeyedTable1616(keyedTable1616_unicodeToForeign_1)
1.186 + }
1.187 + }
1.188 + };
1.189 +
1.190 +//The dummy conversion data to be used for conversion if the iscii code sequence is not
1.191 +//Devanagari (i.e. the script selection code is not 0x42 and something else.
1.192 +//In this case the ISCII characters are converted to unconvertible characters.
1.193 +
1.194 +LOCAL_D const SCnvConversionData conversionDataDummy=
1.195 + {
1.196 + SCnvConversionData::EFixedBigEndian,
1.197 + {
1.198 + ARRAY_LENGTH(foreignVariableByteDataRanges),
1.199 + foreignVariableByteDataRanges
1.200 + },
1.201 + {
1.202 + ARRAY_LENGTH(foreignToUnicodeDataRanges),
1.203 + foreignToUnicodeDataRanges
1.204 + },
1.205 + {
1.206 + ARRAY_LENGTH(unicodeToForeignDataRanges),
1.207 + unicodeToForeignDataRanges
1.208 + },
1.209 + NULL,
1.210 + NULL
1.211 + };
1.212 +
1.213 +
1.214 +
1.215 +#ifdef EKA2
1.216 +
1.217 +///////////////////////////////////////////////////////////////
1.218 +// 3.1 Code
1.219 +
1.220 +// INCLUDES
1.221 +#include <ecom/implementationproxy.h>
1.222 +#include <charactersetconverter.h>
1.223 +
1.224 +
1.225 +/**
1.226 +* The character conversion plug-in implementation for Iscii.
1.227 +*
1.228 +* @lib ecom.lib
1.229 +* @since Series 60 3.1
1.230 +*/
1.231 +
1.232 +class CIsciiImplementation : public CCharacterSetConverterPluginInterface
1.233 +{
1.234 + public:
1.235 + //From CCharacterSetConverterPluginInterface
1.236 + virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters();
1.237 +
1.238 + //From CCharacterSetConverterPluginInterface
1.239 + virtual TInt ConvertFromUnicode(
1.240 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.241 + const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,
1.242 + TDes8& aForeign,
1.243 + const TDesC16& aUnicode,
1.244 + CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters );
1.245 +
1.246 + //From CCharacterSetConverterPluginInterface
1.247 + virtual TInt ConvertToUnicode(
1.248 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.249 + TDes16& aUnicode,
1.250 + const TDesC8& aForeign,
1.251 + TInt&,
1.252 + TInt& aNumberOfUnconvertibleCharacters,
1.253 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter );
1.254 +
1.255 + //From CCharacterSetConverterPluginInterface
1.256 + virtual TBool IsInThisCharacterSetL(
1.257 + TBool& aSetToTrue,
1.258 + TInt& aConfidenceLevel,
1.259 + const TDesC8& );
1.260 +
1.261 + static CIsciiImplementation* NewL();
1.262 +
1.263 + virtual ~CIsciiImplementation();
1.264 + private:
1.265 + CIsciiImplementation();
1.266 +};
1.267 +
1.268 +//Checks if a descriptor starts with another descriptor at the begining.
1.269 +LOCAL_C TBool IsStartOf(const TDesC8& aEscapeSequence, const TDesC8& aBuffer)
1.270 +{
1.271 + const TInt lengthOfStart=aEscapeSequence.Length();
1.272 + return (aBuffer.Length()>=lengthOfStart) && (aBuffer.Left(lengthOfStart)==aEscapeSequence);
1.273 +}
1.274 +// -----------------------------------------------------------------------------
1.275 +// MatchesEscapeSequence()
1.276 +//If the remainder of the foreign text starts with the passed escapesequence, modifies the remainder of the foreign text
1.277 +//and sets the homogeneous run buffer that uses the same conversion data.
1.278 +//The homogeneous run buffer is the buffer that will use a single conversion data, it doesn't contain the attribute code
1.279 +// neither it contains the script switching code.
1.280 +//The aRemainderOfForeign buffer
1.281 +
1.282 +// Returns: ETrue: If the sequence contains the escape sequence
1.283 +// EFalse: If the sequence does not contain the escape sequence
1.284 +//
1.285 +// -----------------------------------------------------------------------------
1.286 +//
1.287 +LOCAL_C TBool MatchesEscapeSequence(TInt& aNumberOfForeignBytesConsumed, TPtrC8& aHomogeneousRun,
1.288 + TPtrC8& aRemainderOfForeign, const TDesC8& aEscapeSequence)
1.289 +{
1.290 + const TInt lengthOfEscapeSequence=aEscapeSequence.Length();
1.291 + if (IsStartOf(aEscapeSequence, aRemainderOfForeign))
1.292 + {
1.293 + aRemainderOfForeign.Set(aRemainderOfForeign.Mid(lengthOfEscapeSequence));
1.294 + const TInt startOfNextEscapeSequence=aRemainderOfForeign.Locate(KControlCharacterEscape);
1.295 + if (startOfNextEscapeSequence==KErrNotFound)
1.296 + {
1.297 + aHomogeneousRun.Set(aRemainderOfForeign);
1.298 + aRemainderOfForeign.Set(NULL, 0);
1.299 + }
1.300 + else
1.301 + {
1.302 + aHomogeneousRun.Set(aRemainderOfForeign.Left(startOfNextEscapeSequence));
1.303 + aRemainderOfForeign.Set(aRemainderOfForeign.Mid(startOfNextEscapeSequence));
1.304 + }
1.305 + aNumberOfForeignBytesConsumed+=lengthOfEscapeSequence;
1.306 + return ETrue;
1.307 + }
1.308 + return EFalse;
1.309 +}
1.310 +
1.311 +// -----------------------------------------------------------------------------
1.312 +// NextHomogeneousForeignRun()
1.313 +//Matches the escape sequence of each of the elements of the SState array with the remainder of
1.314 +//foreign text and if the escape sequence matches with the start of remainder of the foreign text,
1.315 +//then the conversion data is set to the conversion data corresponding to the escape sequence
1.316 +//Also the homogeneous foreign text for conversion with the same escape sequence is set.
1.317 +
1.318 +// Returns: ETrue: If length of the remainder of foreign buffer is nonzero.
1.319 +// EFalse: If length of the remainder of foreign buffer is zero.
1.320 +//
1.321 +// -----------------------------------------------------------------------------
1.322 +//
1.323 +
1.324 +
1.325 +LOCAL_C TBool NextHomogeneousForeignRun(const SCnvConversionData*& aConversionData, TInt& aNumberOfForeignBytesConsumed, TPtrC8& aHomogeneousRun, TPtrC8& aRemainderOfForeign, const TArray<CnvUtilities::SState>& aArrayOfStates, TUint& aOutputConversionFlags)
1.326 +{
1.327 + TBool returnValue = EFalse;
1.328 + TBool foundState = EFalse;
1.329 + __ASSERT_DEBUG((aRemainderOfForeign.Length()==0) || (aRemainderOfForeign[0]==KControlCharacterEscape), User::Panic(KPanicReason,EPanicBadRemainderOfForeign));
1.330 + if (aRemainderOfForeign.Length()==0)
1.331 + {
1.332 + return returnValue;
1.333 + }
1.334 + const TInt numberOfStates=aArrayOfStates.Count();
1.335 + TInt i;
1.336 + for (i=0; i<numberOfStates; ++i)
1.337 + {
1.338 + const CnvUtilities::SState& state=aArrayOfStates[i];
1.339 + if (MatchesEscapeSequence(aNumberOfForeignBytesConsumed, aHomogeneousRun, aRemainderOfForeign, *state.iEscapeSequence))
1.340 + {
1.341 + aConversionData=state.iConversionData;
1.342 + foundState = ETrue;
1.343 + }
1.344 + }
1.345 + if(!foundState)
1.346 + {
1.347 + for (i=0; i<numberOfStates; ++i)
1.348 + {
1.349 + if (IsStartOf(aRemainderOfForeign, *aArrayOfStates[i].iEscapeSequence))
1.350 + {
1.351 + // aRemainderOfForeign ends with a truncated escape sequence, so ConvertToUnicode cannot convert any more
1.352 + aOutputConversionFlags|=CCnvCharacterSetConverter::EOutputConversionFlagInputIsTruncated;
1.353 + break;
1.354 + }
1.355 + }
1.356 +
1.357 + MatchesEscapeSequence(aNumberOfForeignBytesConsumed,aHomogeneousRun,aRemainderOfForeign,aRemainderOfForeign.Left(2));
1.358 + aConversionData = &conversionDataDummy;
1.359 + returnValue = ETrue;
1.360 + }
1.361 + if (aHomogeneousRun.Length()>0)
1.362 + {
1.363 + returnValue = ETrue;
1.364 + }
1.365 + return returnValue;
1.366 +}
1.367 +// -----------------------------------------------------------------------------
1.368 +// ConvertFromUnicodeIntermediateBufferInPlace()
1.369 +//Default implementation for conversion to the intermediate buffer
1.370 +//It modifies the unicode buffer before it is converted back to iscii.
1.371 +//The current implementation of iscii plug-in doesn't require any
1.372 +//modification to the default implementation
1.373 +// Returns: Nothing
1.374 +//
1.375 +// -----------------------------------------------------------------------------
1.376 +//
1.377 +
1.378 +
1.379 +LOCAL_C void ConvertFromUnicodeIntermediateBufferInPlace(TInt aStartPositionInDescriptor, TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
1.380 +{
1.381 + CnvUtilities::ConvertFromIntermediateBufferInPlace(aStartPositionInDescriptor, aDescriptor, aNumberOfCharactersThatDroppedOut, KEscapeSequenceDevanagari, 1);
1.382 +}
1.383 +
1.384 +// -----------------------------------------------------------------------------
1.385 +// DoFindAndModifyBuffer()
1.386 +//Modifies the iscii buffer by replacing the search buffer with the replacement buffer.
1.387 +//Introduced for handling multibyte iscii sequence.
1.388 +//Takes the search buffer array and the replacement buffer arrays as input to it and replaces all
1.389 +//the occurances of the search buffer with the corresponding replace buffer.
1.390 +// Returns: Nothing
1.391 +//
1.392 +// -----------------------------------------------------------------------------
1.393 +//
1.394 +
1.395 +LOCAL_C void DoFindAndModifyBuffer(TDes8& aModifyBuffer,const TDesC8& aSearchBuffer,const TDesC8& aReplaceBuffer)
1.396 +{
1.397 + FOREVER
1.398 + {
1.399 + TInt offset;
1.400 + __ASSERT_ALWAYS((aSearchBuffer.Length()>= aReplaceBuffer.Length()),User::Panic(KPanicReason,EPanicBadReplacementBuffer));
1.401 + if((offset = aModifyBuffer.Find(aSearchBuffer)) != KErrNotFound)
1.402 + {
1.403 + TUint8 *pointerToBuffer = const_cast<TUint8*> (aModifyBuffer.Ptr());
1.404 + Mem::Copy(pointerToBuffer+offset,aReplaceBuffer.Ptr(),aReplaceBuffer.Length());
1.405 + Mem::Copy(pointerToBuffer+offset+aReplaceBuffer.Length(),pointerToBuffer+offset+aSearchBuffer.Length(),aModifyBuffer.Length()-aSearchBuffer.Length()-offset);
1.406 + aModifyBuffer.SetLength(aModifyBuffer.Length() - aSearchBuffer.Length() + aReplaceBuffer.Length());
1.407 + }
1.408 + else
1.409 + break;
1.410 + }
1.411 +
1.412 +}
1.413 +
1.414 +// -----------------------------------------------------------------------------
1.415 +// FindAndModifyBuffer()
1.416 +//Modifies the iscii buffer by replacing the search buffer with the replacement buffer.
1.417 +//Calls DoFindAndModifyBuffer() and supplies the search buffer and replacement buffer.
1.418 +//Introduced for handling multibyte iscii sequence.
1.419 +// Returns: Nothing
1.420 +//
1.421 +// -----------------------------------------------------------------------------
1.422 +//
1.423 +
1.424 +LOCAL_C void FindAndModifyBuffer(TDes8& aModifyBuffer)
1.425 +{
1.426 + TInt ret = KErrNone;
1.427 + RArray<TPtrC8> searchBuffer;
1.428 + RArray<TPtrC8> replaceBuffer;
1.429 +
1.430 + //If the passed buffer contains the replacement buffer,
1.431 + //Then it should not get converted to respective Unicode
1.432 + //buffer rather it should get converted to replacement for
1.433 + //unconvertible character.
1.434 +
1.435 + ret |= searchBuffer.Append(KReplacementForExplicitHalant().Right(1));
1.436 + ret |= searchBuffer.Append(KReplacementForSoftHalant().Right(1));
1.437 + ret |= searchBuffer.Append(KReplacementForOm().Right(1));
1.438 + ret |= searchBuffer.Append(KReplacementForAvagraha().Right(1));
1.439 +
1.440 + ret |= searchBuffer.Append(KReplacementForVocalicRr().Right(1));
1.441 + ret |= searchBuffer.Append(KReplacementForVocalicLl().Right(1));
1.442 + ret |= searchBuffer.Append(KReplacementForVocalicLSign().Right(1));
1.443 + ret |= searchBuffer.Append(KReplacementForVocalicLlSign().Right(1));
1.444 + ret |= searchBuffer.Append(KReplacementForVocalicL().Right(1));
1.445 + ret |= searchBuffer.Append(KReplacementForVocalicRrSign().Right(1));
1.446 +
1.447 + //All normal search buffers
1.448 + ret |= searchBuffer.Append(KExplicitHalant().Mid(0));
1.449 + ret |= searchBuffer.Append(KSoftHalant().Mid(0));
1.450 + ret |= searchBuffer.Append(KOm().Mid(0));
1.451 + ret |= searchBuffer.Append(KAvagraha().Mid(0));
1.452 +
1.453 + ret |= searchBuffer.Append(KVocalicRr().Mid(0));
1.454 + ret |= searchBuffer.Append(KVocalicLl().Mid(0));
1.455 + ret |= searchBuffer.Append(KVocalicLSign().Mid(0));
1.456 + ret |= searchBuffer.Append(KVocalicLlSign().Mid(0));
1.457 + ret |= searchBuffer.Append(KVocalicL().Mid(0));
1.458 + ret |= searchBuffer.Append(KVocalicRrSign().Mid(0));
1.459 +
1.460 + //The replacement buffer for the odd cases to restrict the
1.461 + //replacement buffers not to get converted to the corresponding
1.462 + //unicode buffer
1.463 +
1.464 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.465 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.466 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.467 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.468 +
1.469 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.470 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.471 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.472 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.473 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.474 + ret |= replaceBuffer.Append(KIsciiUnconvertibleCharacter().Mid(0));
1.475 +
1.476 + //All normal replace buffers
1.477 + ret |= replaceBuffer.Append(KReplacementForExplicitHalant().Mid(0));
1.478 + ret |= replaceBuffer.Append(KReplacementForSoftHalant().Mid(0));
1.479 + ret |= replaceBuffer.Append(KReplacementForOm().Mid(0));
1.480 + ret |= replaceBuffer.Append(KReplacementForAvagraha().Mid(0));
1.481 +
1.482 +
1.483 + ret |= replaceBuffer.Append(KReplacementForVocalicRr().Mid(0));
1.484 + ret |= replaceBuffer.Append(KReplacementForVocalicLl().Mid(0));
1.485 + ret |= replaceBuffer.Append(KReplacementForVocalicLSign().Mid(0));
1.486 + ret |= replaceBuffer.Append(KReplacementForVocalicLlSign().Mid(0));
1.487 + ret |= replaceBuffer.Append(KReplacementForVocalicL().Mid(0));
1.488 + ret |= replaceBuffer.Append(KReplacementForVocalicRrSign().Mid(0));
1.489 +
1.490 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.491 +
1.492 + for(TInt counter=0;counter<searchBuffer.Count();counter++)
1.493 + {
1.494 + DoFindAndModifyBuffer(aModifyBuffer,searchBuffer[counter],replaceBuffer[counter]);
1.495 + }
1.496 + searchBuffer.Reset();
1.497 + replaceBuffer.Reset();
1.498 +
1.499 +}
1.500 +
1.501 +// -----------------------------------------------------------------------------
1.502 +// DoNormalizeReturnValue()
1.503 +//Modifies the return value(Number of bytes did not get converted) according to the modified
1.504 +//intermediate buffer. Takes the modified intermediate buffer, return value, search and replace
1.505 +//buffers. Searches for the replace buffer in the intermediate buffer and if found, it looks for
1.506 +//the actual buffer corresponding to the replace buffer and adds the difference of the lengths
1.507 +//of the actual to replace buffer to the return value.
1.508 +// Returns: Nothing
1.509 +//
1.510 +// -----------------------------------------------------------------------------
1.511 +//
1.512 +
1.513 +LOCAL_C void DoNormalizeReturnValue(TUint& aReturnValue,const TDesC8& aBuffer,RArray<TPtrC8>& anArrayOfSearches,RArray<TPtrC8>& anArrayOfReplaces)
1.514 +{
1.515 + TPtr8 buffer(const_cast<TUint8*>(aBuffer.Ptr()),aBuffer.Length(),aBuffer.Length());
1.516 + TUint count = anArrayOfSearches.Count();
1.517 + FOREVER
1.518 + {
1.519 + TBool flag = EFalse;
1.520 + for(TUint i=0;i<count;i++)
1.521 + {
1.522 + TPtrC8 searchBufferForComparison(buffer.Right(anArrayOfReplaces[i].Length()));
1.523 + TInt returnCompare = searchBufferForComparison.Compare(anArrayOfReplaces[i]);
1.524 + if(returnCompare == 0)
1.525 + {
1.526 + flag =ETrue;
1.527 + aReturnValue += (anArrayOfSearches[i].Length() - anArrayOfReplaces[i].Length());
1.528 + buffer=buffer.MidTPtr(0,buffer.Length()-anArrayOfReplaces[i].Length());
1.529 + break;
1.530 + }
1.531 + }
1.532 +
1.533 + if(buffer.Length() == 0)
1.534 + {
1.535 + break;
1.536 + }
1.537 +
1.538 + if(!flag)
1.539 + {
1.540 + buffer=buffer.MidTPtr(0,buffer.Length()-1);
1.541 + }
1.542 + }
1.543 +
1.544 +}
1.545 +
1.546 +// -----------------------------------------------------------------------------
1.547 +// NormalizeReturnValue()
1.548 +//Modifies the return value(Number of bytes did not get converted) according to the
1.549 +//replacements done to the iscii buffer before conversion.
1.550 +//Internally calls DoNormalizeReturnValue() by suppling the search and replacement
1.551 +//buffers.
1.552 +
1.553 +// Returns: Nothing
1.554 +//
1.555 +// -----------------------------------------------------------------------------
1.556 +//
1.557 +
1.558 +LOCAL_C void NormalizeReturnValue(TUint& aReturnValue,const TDesC8& aBuffer)
1.559 +{
1.560 + TInt ret = KErrNone;
1.561 + RArray<TPtrC8> searchBuffer;
1.562 + RArray<TPtrC8> replaceBuffer;
1.563 +
1.564 + ret |= searchBuffer.Append(KExplicitHalant().Mid(0));
1.565 + ret |= searchBuffer.Append(KSoftHalant().Mid(0));
1.566 + ret |= searchBuffer.Append(KOm().Mid(0));
1.567 + ret |= searchBuffer.Append(KAvagraha().Mid(0));
1.568 +
1.569 + ret |= searchBuffer.Append(KVocalicRr().Mid(0));
1.570 + ret |= searchBuffer.Append(KVocalicLl().Mid(0));
1.571 + ret |= searchBuffer.Append(KVocalicLSign().Mid(0));
1.572 + ret |= searchBuffer.Append(KVocalicLlSign().Mid(0));
1.573 + ret |= searchBuffer.Append(KVocalicL().Mid(0));
1.574 + ret |= searchBuffer.Append(KVocalicRrSign().Mid(0));
1.575 +
1.576 + ret |= replaceBuffer.Append(KReplacementForExplicitHalant().Mid(0));
1.577 + ret |= replaceBuffer.Append(KReplacementForSoftHalant().Mid(0));
1.578 + ret |= replaceBuffer.Append(KReplacementForOm().Mid(0));
1.579 + ret |= replaceBuffer.Append(KReplacementForAvagraha().Mid(0));
1.580 +
1.581 + ret |= replaceBuffer.Append(KReplacementForVocalicRr().Mid(0));
1.582 + ret |= replaceBuffer.Append(KReplacementForVocalicLl().Mid(0));
1.583 + ret |= replaceBuffer.Append(KReplacementForVocalicLSign().Mid(0));
1.584 + ret |= replaceBuffer.Append(KReplacementForVocalicLlSign().Mid(0));
1.585 + ret |= replaceBuffer.Append(KReplacementForVocalicL().Mid(0));
1.586 + ret |= replaceBuffer.Append(KReplacementForVocalicRrSign().Mid(0));
1.587 +
1.588 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.589 +
1.590 + DoNormalizeReturnValue(aReturnValue,aBuffer,searchBuffer,replaceBuffer);
1.591 + searchBuffer.Reset();
1.592 + replaceBuffer.Reset();
1.593 +}
1.594 +
1.595 +// -----------------------------------------------------------------------------
1.596 +// HandleHomogeneousRun()
1.597 +//Handles a homogeneous foreign buffer and converts the foreign buffer to unicode
1.598 +//On return the aUnicode argument contains the converted unicode data.
1.599 +//Also it sets the return value, returned from the conversion. The return value also
1.600 +//takes into account if there is any buffer modification done before passing it to
1.601 +//CCnvCharacterSetConverter::DoConvertToUnicode()
1.602 +//buffers.
1.603 +
1.604 +// Returns: Nothing
1.605 +//
1.606 +// -----------------------------------------------------------------------------
1.607 +//
1.608 +
1.609 +LOCAL_C void HandleHomogeneousRun(const SCnvConversionData*& aConversionData,
1.610 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.611 + TDes16& aUnicode,
1.612 + const TDesC8& aHomogeneousForeign,
1.613 + TInt& aNumberOfUnconvertibleCharacters,
1.614 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter,
1.615 + TUint& aOutputConversionFlags,
1.616 + TUint aInputConversionFlags,TInt& aNumberOfForeignBytesConsumed,
1.617 + TInt& aReturnValue)
1.618 +{
1.619 + TInt numberOfUnconvertibleCharacters;
1.620 + TInt indexOfFirstByteOfFirstUnconvertibleCharacter;
1.621 + TUint noOfConsumedBytes = 0;
1.622 + if(aConversionData == NULL)
1.623 + {
1.624 + aReturnValue = CCnvCharacterSetConverter::EErrorIllFormedInput;
1.625 + return;
1.626 + }
1.627 + aReturnValue = CCnvCharacterSetConverter::DoConvertToUnicode(*aConversionData,aDefaultEndiannessOfForeignCharacters,
1.628 + aUnicode,aHomogeneousForeign,numberOfUnconvertibleCharacters,
1.629 + indexOfFirstByteOfFirstUnconvertibleCharacter,aOutputConversionFlags,
1.630 +
1.631 + //The numberOfUnconvertibleCharacters and indexOfFirstByteOfFirstUnconvertibleCharacter are the values with
1.632 + //respect to the intermediate iscii buffer and original values aIndexOfFirstByteOfFirstUnconvertibleCharacter and
1.633 + //aNumberOfUnconvertibleCharacters need to be adjusted accordingly.
1.634 +
1.635 + aInputConversionFlags);
1.636 + if(numberOfUnconvertibleCharacters>0)
1.637 + {
1.638 + if(aNumberOfUnconvertibleCharacters == 0)
1.639 + {
1.640 + aIndexOfFirstByteOfFirstUnconvertibleCharacter = aNumberOfForeignBytesConsumed + indexOfFirstByteOfFirstUnconvertibleCharacter;
1.641 + }
1.642 + aNumberOfUnconvertibleCharacters+=numberOfUnconvertibleCharacters;
1.643 + }
1.644 + noOfConsumedBytes = aHomogeneousForeign.Length();
1.645 + //To Check whether it is really required.
1.646 + NormalizeReturnValue(noOfConsumedBytes,aHomogeneousForeign);
1.647 + aNumberOfForeignBytesConsumed+=noOfConsumedBytes;
1.648 + if(aReturnValue>0)
1.649 + {
1.650 + TUint normalizedReturnValue = aReturnValue;
1.651 +
1.652 + //There original iscii buffer copied to an intermediate iscii buffer and then modified
1.653 + //and is then passed for conversion. Now, after conversion, the return value needs to
1.654 + //be adjusted according to the original buffer. NormalizeReturnValue() does the
1.655 + //same thing.
1.656 +
1.657 + NormalizeReturnValue(normalizedReturnValue,aHomogeneousForeign);
1.658 + aNumberOfForeignBytesConsumed-=normalizedReturnValue;
1.659 + aReturnValue=normalizedReturnValue;
1.660 + }
1.661 +
1.662 + //The HandleHomogeneousRun() method is called in a loop and once there is some
1.663 + //iscii codes converted to unicode, the ConvertToUnicode() should not return
1.664 + //CCnvCharacterSetConverter::EErrorIllFormedInput even though the conversion
1.665 + //method does not convert any of the iscii codes ppassed. To ensure that once the
1.666 + //first non-zero number of iscii codes are converted, the internal input conversion
1.667 + //flag is set to EInputConversionFlagAllowTruncatedInputNotEvenPartlyConsumable.
1.668 +
1.669 + if(aNumberOfForeignBytesConsumed>0)
1.670 + {
1.671 + aInputConversionFlags|=CCnvCharacterSetConverter::EInputConversionFlagAllowTruncatedInputNotEvenPartlyConsumable;
1.672 + }
1.673 + return;
1.674 +}
1.675 +
1.676 +// -----------------------------------------------------------------------------
1.677 +// IsTruncatedDoubleByteIsciiSequence()
1.678 +//Checks if anIsciiBuffer is a part of multi byte iscii sequence truncated in the middle.
1.679 +//If it is a truncated sequence, then returns ETrue else returns EFalse.
1.680 +//
1.681 +// Returns: ETrue: If the intermediate input iscii buffer is truncated
1.682 +// EFalse: If the intermediate input iscii buffer is not truncated
1.683 +//
1.684 +// -----------------------------------------------------------------------------
1.685 +//
1.686 +
1.687 +LOCAL_C TBool IsTruncatedDoubleByteIsciiSequence(const TDesC8& anIsciiBuffer)
1.688 +{
1.689 + RArray<TPtrC8> searchBuffer;
1.690 + if(anIsciiBuffer.Length () == 0)
1.691 + return EFalse;
1.692 + if(anIsciiBuffer[anIsciiBuffer.Length()-1] == 0xEF)
1.693 + return ETrue;
1.694 +
1.695 + TInt appendret = KErrNone;
1.696 + appendret |= searchBuffer.Append(KSoftHalant().Mid(0));
1.697 + appendret |= searchBuffer.Append(KOm().Mid(0));
1.698 + appendret |= searchBuffer.Append(KAvagraha().Mid(0));
1.699 + appendret |= searchBuffer.Append(KExplicitHalant().Mid(0));
1.700 + __ASSERT_DEBUG(!appendret, User::Panic(_L("RArray append failure"), appendret));
1.701 +
1.702 + TBool ret = EFalse;
1.703 + TBool isNotTruncated =EFalse;
1.704 +
1.705 + //First check if the intermediate iscii buffer is ending with a complete multi byte sequence.
1.706 + //If it ends with a complete multi byte sequence, no need to check if the last character of
1.707 + //intermediate iscii is same as first character of multi byte iscii sequence. And return EFalse.
1.708 + for(TUint counter = 0;counter<searchBuffer.Count();counter++)
1.709 + {
1.710 + if(searchBuffer[counter].Compare(anIsciiBuffer.Right(searchBuffer[counter].Length())) == 0)
1.711 + {
1.712 + isNotTruncated = ETrue;
1.713 + break;
1.714 + }
1.715 + }
1.716 + //If the intermediate iscii buffer is not ending with a complete multi byte sequence, and the
1.717 + //last code of the iscii buffer is a part of the multibyte sequence, then the iscii buffer is a
1.718 + //truncated sequence and in that case return ETrue.
1.719 +
1.720 + for(TUint counter = 0;counter<searchBuffer.Count();counter++)
1.721 + {
1.722 + if(isNotTruncated)
1.723 + break;
1.724 + else if( (anIsciiBuffer[anIsciiBuffer.Length()-1] == searchBuffer[counter][0]))
1.725 + {
1.726 + ret =ETrue;
1.727 + break;
1.728 + }
1.729 + }
1.730 + searchBuffer.Reset();
1.731 + return ret;
1.732 +}
1.733 +
1.734 +// -----------------------------------------------------------------------------
1.735 +// ReplacementForUnconvertibleUnicodeCharacters()
1.736 +//Returns the replacement character for unconvertible unicode character.
1.737 +//In the current implementation it is 0x1a (ASCII Substitute character)
1.738 +//The default implementation calls ReplacementForUnconvertibleUnicodeCharacters_internal()
1.739 +//in turn which is generated by cnvtool.
1.740 +//
1.741 +// Returns: Replacemt for unconvertible unicode characters (0x1a)
1.742 +//
1.743 +// -----------------------------------------------------------------------------
1.744 +//
1.745 +
1.746 +const TDesC8& CIsciiImplementation::ReplacementForUnconvertibleUnicodeCharacters()
1.747 + {
1.748 + return ReplacementForUnconvertibleUnicodeCharacters_internal();
1.749 + }
1.750 +
1.751 +// -----------------------------------------------------------------------------
1.752 +// ConvertFromUnicode()
1.753 +//The main conversion function for converting from unicode to iscii
1.754 +//Loaded and called by the character conversion framework.
1.755 +//In turn calls CnvUtilities::ConvertFromUnicode() which is Symbian provide
1.756 +//utility method for converting unicode to modal character codes.
1.757 +//
1.758 +// Returns: The numbet of unicode codes it could not convert.
1.759 +//
1.760 +// -----------------------------------------------------------------------------
1.761 +//
1.762 +
1.763 +TInt CIsciiImplementation::ConvertFromUnicode(
1.764 + CCnvCharacterSetConverter::TEndianness
1.765 + aDefaultEndiannessOfForeignCharacters,
1.766 + const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,
1.767 + TDes8& aForeign,
1.768 + const TDesC16& aUnicode,
1.769 + CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters )
1.770 + {
1.771 + TFixedArray<CnvUtilities::SCharacterSet,KNumberOfIndicCharactersetsSupported> aArrayOfCharacterSets;
1.772 + aArrayOfCharacterSets[0].iConversionData = &conversionData;
1.773 + aArrayOfCharacterSets[0].iConvertFromIntermediateBufferInPlace = ConvertFromUnicodeIntermediateBufferInPlace;
1.774 + aArrayOfCharacterSets[0].iEscapeSequence = &KEscapeSequenceDevanagari();
1.775 +
1.776 + return CnvUtilities::ConvertFromUnicode(
1.777 + aDefaultEndiannessOfForeignCharacters,
1.778 + aReplacementForUnconvertibleUnicodeCharacters,
1.779 + aForeign,
1.780 + aUnicode,
1.781 + aIndicesOfUnconvertibleCharacters,
1.782 + aArrayOfCharacterSets.Array());
1.783 + }
1.784 +
1.785 +// -----------------------------------------------------------------------------
1.786 +// ConvertToUnicode()
1.787 +//The main conversion function for converting from iscii to unicode
1.788 +//Loaded and called by the character conversion framework.
1.789 +//To support some of the iscii characters, the input forign buffer is
1.790 +//copied to an intermediate buffer and then is then modified and
1.791 +//CCnvCharactersetConverter::DoConvertToUnicode() is called with
1.792 +//the modified buffer. For extensibility of iscii to other Indic languages
1.793 +//it uses CnvUtilities::SState datastructure. CnvUtilities::SState is a
1.794 +//Symbian defined class for modal charactersets. The escape sequence
1.795 +//is specified to ATR followed by the script selection code and the conversion
1.796 +//data is specified to be the conversion for the particular script. For the time
1.797 +//being only Devanagari with script selection code 0x42 is supported. If
1.798 +//any of the other script codes are used the conversion leads to unconvertible
1.799 +//character i.e. 0xFFFD.
1.800 +// Returns: The numbet of iscii codes it could not convert.
1.801 +//
1.802 +// -----------------------------------------------------------------------------
1.803 +//
1.804 +
1.805 +TInt CIsciiImplementation::ConvertToUnicode(
1.806 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.807 + TDes16& aUnicode,
1.808 + const TDesC8& aForeign,
1.809 + TInt& aState,
1.810 + TInt& aNumberOfUnconvertibleCharacters,
1.811 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter )
1.812 + {
1.813 + aNumberOfUnconvertibleCharacters = 0;
1.814 + TUint aOutputConversionFlags = CCnvCharacterSetConverter::KStateDefault;
1.815 + aIndexOfFirstByteOfFirstUnconvertibleCharacter=-1;
1.816 + TUint internalInputConversionFlags = 0;
1.817 + TInt numberOfForeignBytesConsumed=0;
1.818 + TPtrC8 remainderOfForeign(aForeign);
1.819 + TInt returnValue;
1.820 + TBool flag = EFalse;
1.821 + TBool isSkipMatchSequence = EFalse;
1.822 + const SCnvConversionData* convData;
1.823 + //Set the iscii conversion data and escape sequence for Devanagari.
1.824 + TFixedArray<CnvUtilities::SState,KNumberOfIndicCharactersetsSupported> modals;
1.825 + modals[0].iConversionData = &conversionData;
1.826 + modals[0].iEscapeSequence = &KEscapeSequenceDevanagari();
1.827 +
1.828 + aUnicode.SetLength(0);
1.829 +
1.830 + //The internal input conversion flag for conversion is set to CCnvCharacterSetConverter::EInputConversionFlagAppend
1.831 + //so that for each conversion in the conversion loop, the generated conversion buffer is appened to the aUnicode buffer.
1.832 + internalInputConversionFlags |= CCnvCharacterSetConverter::EInputConversionFlagAppend;
1.833 + if (aForeign.Length()==0)
1.834 + {
1.835 + return 0;
1.836 + }
1.837 + //Get the conversion data from the previous call else the conversion data is set to the default
1.838 + //conversion data, i.e. Devanagari.
1.839 + convData=(aState!=CCnvCharacterSetConverter::KStateDefault)? REINTERPRET_CAST(const SCnvConversionData*, aState): modals[0].iConversionData;
1.840 + FOREVER
1.841 + {
1.842 + TBuf8<KMaximumLengthOfIntermediateBuffer> intermediateBuffer;
1.843 + TUint numberOfForeignBytesConsumedThisTime = 0;
1.844 + if((remainderOfForeign.Length() >=KMaximumLengthOfIntermediateBuffer) && (aUnicode.MaxLength()-aUnicode.Length() >=KMaximumLengthOfIntermediateBuffer))
1.845 + {
1.846 + numberOfForeignBytesConsumedThisTime = KMaximumLengthOfIntermediateBuffer;
1.847 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.848 + //If the intermediate buffer is a part of truncated buffer sequence but the
1.849 + //actual input buffer is not truncated then truncated sequence is not converted.
1.850 + //The intermediate buffer is modified so as not to contain the truncated sequence.
1.851 +
1.852 + flag = IsTruncatedDoubleByteIsciiSequence(intermediateBuffer);
1.853 + if(flag)
1.854 + {
1.855 + numberOfForeignBytesConsumedThisTime --;
1.856 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.857 + }
1.858 +
1.859 + }
1.860 + else
1.861 + {
1.862 + flag = IsTruncatedDoubleByteIsciiSequence(remainderOfForeign.Left(aUnicode.MaxLength()-aUnicode.Length()));
1.863 + if(!flag)
1.864 + {
1.865 + numberOfForeignBytesConsumedThisTime = aUnicode.MaxLength()-aUnicode.Length();
1.866 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.867 + }
1.868 + else
1.869 + {
1.870 + if(aForeign.Length()>(numberOfForeignBytesConsumed+aUnicode.Length()))
1.871 + {
1.872 + numberOfForeignBytesConsumedThisTime = aUnicode.MaxLength()-aUnicode.Length()-1;
1.873 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.874 + break;
1.875 + }
1.876 + else
1.877 + {
1.878 + numberOfForeignBytesConsumedThisTime = aUnicode.MaxLength()-aUnicode.Length();
1.879 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.880 + }
1.881 + }
1.882 + }
1.883 +
1.884 + //The input intermediate iscii buffer is modified with the search and replace
1.885 + //buffers. It is required for supporting multibyte iscii sequences.
1.886 + FindAndModifyBuffer(intermediateBuffer);
1.887 + TPtrC8 remainderOfForeignInternal(intermediateBuffer);
1.888 + TPtrC8 homogeneousRun;
1.889 + const TInt startOfNextEscapeSequence=intermediateBuffer.Locate(KControlCharacterEscape);
1.890 + if (startOfNextEscapeSequence!=0)
1.891 + {
1.892 + if (startOfNextEscapeSequence==KErrNotFound)
1.893 + {
1.894 + homogeneousRun.Set(remainderOfForeignInternal);
1.895 + remainderOfForeignInternal.Set(NULL, 0);
1.896 + }
1.897 + else
1.898 + {
1.899 + __ASSERT_DEBUG(startOfNextEscapeSequence>0, User::Panic(KPanicReason,EPanicBadStartOfNextEscapeSequence));
1.900 + homogeneousRun.Set(remainderOfForeignInternal.Left(startOfNextEscapeSequence));
1.901 + remainderOfForeignInternal.Set(remainderOfForeignInternal.Mid(startOfNextEscapeSequence));
1.902 + }
1.903 + isSkipMatchSequence = ETrue;
1.904 + }
1.905 + FOREVER
1.906 + {
1.907 + if(!isSkipMatchSequence)
1.908 + {
1.909 + if (!NextHomogeneousForeignRun(convData, numberOfForeignBytesConsumed, homogeneousRun,
1.910 + remainderOfForeignInternal, modals.Array(), aOutputConversionFlags))
1.911 + {
1.912 + break;
1.913 + }
1.914 + }
1.915 + HandleHomogeneousRun( convData, aDefaultEndiannessOfForeignCharacters, aUnicode, homogeneousRun, aNumberOfUnconvertibleCharacters,
1.916 + aIndexOfFirstByteOfFirstUnconvertibleCharacter,aOutputConversionFlags,internalInputConversionFlags,
1.917 + numberOfForeignBytesConsumed,returnValue);
1.918 + if(returnValue<0)
1.919 + {
1.920 + return returnValue;
1.921 + }
1.922 + isSkipMatchSequence = EFalse;
1.923 + }
1.924 + if(returnValue > 0)
1.925 + break;
1.926 + if ((!flag && (numberOfForeignBytesConsumedThisTime != KMaximumLengthOfIntermediateBuffer)) || (flag && (numberOfForeignBytesConsumedThisTime != (KMaximumLengthOfIntermediateBuffer-1) )))
1.927 + break;
1.928 + remainderOfForeign.Set(aForeign.Mid(numberOfForeignBytesConsumed));
1.929 + }
1.930 + //If the number of iscii bytes consumed by the conversion is zero also the output conversion
1.931 + //flag is not set to EOutputConversionFlagInputIsTruncated, then return EErrorIllFormedInput.
1.932 + if ((numberOfForeignBytesConsumed==0) && (aOutputConversionFlags&CCnvCharacterSetConverter::EOutputConversionFlagInputIsTruncated))
1.933 + {
1.934 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.935 + }
1.936 + //Set the conversion data sothat next time when ConvertToUnicode() is called,
1.937 + //will use the previous conversion data.
1.938 + aState=REINTERPRET_CAST(TInt, convData);
1.939 + return aForeign.Length()-numberOfForeignBytesConsumed;
1.940 + }
1.941 +
1.942 +// -----------------------------------------------------------------------------
1.943 +// IsInThisCharacterSetL()
1.944 +//The method tells how probable it is that a sample piece of text is encoded in this character set.
1.945 +//On return aConfidenceLevel, indicates how confident the function is about its return value. For
1.946 +//iscii it is the default implementation and it does not implement the autodetect functionality.
1.947 +//Loaded and called by the character conversion framework.
1.948 +//
1.949 +// Returns: EFalse: To tell CCnvCharacterSetConverter::AutoDetectCharacterSetL() that the plug-in DLL
1.950 +// is not implementing a function of this signature and is therefore empty.
1.951 +//
1.952 +// -----------------------------------------------------------------------------
1.953 +//
1.954 +
1.955 +
1.956 +//Default implementation for IsInThisCharacterSetL()
1.957 +
1.958 +TBool CIsciiImplementation::IsInThisCharacterSetL(
1.959 + TBool& aSetToTrue,
1.960 + TInt& aConfidenceLevel,
1.961 + const TDesC8& )
1.962 + {
1.963 + aSetToTrue = EFalse;
1.964 + aConfidenceLevel = 0;
1.965 + return EFalse;
1.966 + }
1.967 +
1.968 +// -----------------------------------------------------------------------------
1.969 +// NewL()
1.970 +//Factory function for CIsciiImplementation(). Instantiates a CIsciiImplementation object on heap
1.971 +//and returns the pointer to it.
1.972 +//
1.973 +// Returns: CIsciiImplementation*
1.974 +//
1.975 +// -----------------------------------------------------------------------------
1.976 +//
1.977 +
1.978 +CIsciiImplementation* CIsciiImplementation::NewL()
1.979 + {
1.980 + CIsciiImplementation* self = new(ELeave) CIsciiImplementation;
1.981 + return self;
1.982 + }
1.983 +
1.984 +// -----------------------------------------------------------------------------
1.985 +// CIsciiImplementation()
1.986 +//default constructor, does nothing
1.987 +//
1.988 +// Returns: Nothing
1.989 +//
1.990 +// -----------------------------------------------------------------------------
1.991 +//
1.992 +CIsciiImplementation::CIsciiImplementation()
1.993 + {
1.994 + }
1.995 +
1.996 +// -----------------------------------------------------------------------------
1.997 +// ~CIsciiImplementation()
1.998 +//default desstructor, does nothing
1.999 +//
1.1000 +// Returns: Nothing
1.1001 +//
1.1002 +// -----------------------------------------------------------------------------
1.1003 +//
1.1004 +
1.1005 +CIsciiImplementation::~CIsciiImplementation()
1.1006 + {
1.1007 + }
1.1008 +
1.1009 +// ECOM CREATION FUNCTION
1.1010 +const TImplementationProxy ImplementationTable[] =
1.1011 + {
1.1012 + // Used also in 0x1027508E.rss ( implementation_uid )
1.1013 + IMPLEMENTATION_PROXY_ENTRY( 0x1027508E, CIsciiImplementation::NewL )
1.1014 + };
1.1015 +
1.1016 +// -----------------------------------------------------------------------------
1.1017 +// ImplementationGroupProxy()
1.1018 +//Returns a pointer to TImplementationProxy object which contains the implementation uid vs factory
1.1019 +//function table. Also on return sets the aTableCount to the number of entries in the table.
1.1020 +//
1.1021 +// Returns: TImplementationProxy*
1.1022 +//
1.1023 +// -----------------------------------------------------------------------------
1.1024 +//
1.1025 +EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
1.1026 + {
1.1027 + aTableCount = sizeof( ImplementationTable ) / sizeof(TImplementationProxy);
1.1028 + return ImplementationTable;
1.1029 + }
1.1030 +#else
1.1031 +
1.1032 +#include <convplug.h>
1.1033 +
1.1034 +#ifndef EKA2
1.1035 +// -----------------------------------------------------------------------------
1.1036 +// E32Dll()
1.1037 +//For EKA1 this is the entry point for the DLL.
1.1038 +//
1.1039 +// Returns: KErrNone
1.1040 +//
1.1041 +// -----------------------------------------------------------------------------
1.1042 +//
1.1043 +GLDEF_C TInt E32Dll(TDllReason)
1.1044 +{
1.1045 + return KErrNone;
1.1046 +}
1.1047 +#endif
1.1048 +
1.1049 +//Checks if a descriptor starts with another descriptor at the begining.
1.1050 +LOCAL_C TBool IsStartOf(const TDesC8& aEscapeSequence, const TDesC8& aBuffer)
1.1051 +{
1.1052 + const TInt lengthOfStart=aEscapeSequence.Length();
1.1053 + return (aBuffer.Length()>=lengthOfStart) && (aBuffer.Left(lengthOfStart)==aEscapeSequence);
1.1054 +}
1.1055 +// -----------------------------------------------------------------------------
1.1056 +// MatchesEscapeSequence()
1.1057 +//If the remainder of the foreign text starts with the passed escapesequence, modifies the remainder of the foreign text
1.1058 +//and sets the homogeneous run buffer that uses the same conversion data.
1.1059 +//The homogeneous run buffer is the buffer that will use a single conversion data, it doesn't contain the attribute code
1.1060 +// neither it contains the script switching code.
1.1061 +//The aRemainderOfForeign buffer
1.1062 +
1.1063 +// Returns: ETrue: If the sequence contains the escape sequence
1.1064 +// EFalse: If the sequence does not contain the escape sequence
1.1065 +//
1.1066 +// -----------------------------------------------------------------------------
1.1067 +//
1.1068 +LOCAL_C TBool MatchesEscapeSequence(TInt& aNumberOfForeignBytesConsumed, TPtrC8& aHomogeneousRun,
1.1069 + TPtrC8& aRemainderOfForeign, const TDesC8& aEscapeSequence)
1.1070 +{
1.1071 + const TInt lengthOfEscapeSequence=aEscapeSequence.Length();
1.1072 + if (IsStartOf(aEscapeSequence, aRemainderOfForeign))
1.1073 + {
1.1074 + aRemainderOfForeign.Set(aRemainderOfForeign.Mid(lengthOfEscapeSequence));
1.1075 + const TInt startOfNextEscapeSequence=aRemainderOfForeign.Locate(KControlCharacterEscape);
1.1076 + if (startOfNextEscapeSequence==KErrNotFound)
1.1077 + {
1.1078 + aHomogeneousRun.Set(aRemainderOfForeign);
1.1079 + aRemainderOfForeign.Set(NULL, 0);
1.1080 + }
1.1081 + else
1.1082 + {
1.1083 + aHomogeneousRun.Set(aRemainderOfForeign.Left(startOfNextEscapeSequence));
1.1084 + aRemainderOfForeign.Set(aRemainderOfForeign.Mid(startOfNextEscapeSequence));
1.1085 + }
1.1086 + aNumberOfForeignBytesConsumed+=lengthOfEscapeSequence;
1.1087 + return ETrue;
1.1088 + }
1.1089 + return EFalse;
1.1090 +}
1.1091 +
1.1092 +// -----------------------------------------------------------------------------
1.1093 +// NextHomogeneousForeignRun()
1.1094 +//Matches the escape sequence of each of the elements of the SState array with the remainder of
1.1095 +//foreign text and if the escape sequence matches with the start of remainder of the foreign text,
1.1096 +//then the conversion data is set to the conversion data corresponding to the escape sequence
1.1097 +//Also the homogeneous foreign text for conversion with the same escape sequence is set.
1.1098 +
1.1099 +// Returns: ETrue: If length of the remainder of foreign buffer is nonzero.
1.1100 +// EFalse: If length of the remainder of foreign buffer is zero.
1.1101 +//
1.1102 +// -----------------------------------------------------------------------------
1.1103 +//
1.1104 +
1.1105 +
1.1106 +LOCAL_C TBool NextHomogeneousForeignRun(const SCnvConversionData*& aConversionData, TInt& aNumberOfForeignBytesConsumed, TPtrC8& aHomogeneousRun, TPtrC8& aRemainderOfForeign, const TArray<CnvUtilities::SState>& aArrayOfStates, TUint& aOutputConversionFlags)
1.1107 +{
1.1108 + TBool returnValue = EFalse;
1.1109 + TBool foundState = EFalse;
1.1110 + __ASSERT_DEBUG((aRemainderOfForeign.Length()==0) || (aRemainderOfForeign[0]==KControlCharacterEscape), User::Panic(KPanicReason,EPanicBadRemainderOfForeign));
1.1111 + if (aRemainderOfForeign.Length()==0)
1.1112 + {
1.1113 + return returnValue;
1.1114 + }
1.1115 + const TInt numberOfStates=aArrayOfStates.Count();
1.1116 + TInt i;
1.1117 + for (i=0; i<numberOfStates; ++i)
1.1118 + {
1.1119 + const CnvUtilities::SState& state=aArrayOfStates[i];
1.1120 + if (MatchesEscapeSequence(aNumberOfForeignBytesConsumed, aHomogeneousRun, aRemainderOfForeign, *state.iEscapeSequence))
1.1121 + {
1.1122 + aConversionData=state.iConversionData;
1.1123 + foundState = ETrue;
1.1124 + }
1.1125 + }
1.1126 + if(!foundState)
1.1127 + {
1.1128 + for (i=0; i<numberOfStates; ++i)
1.1129 + {
1.1130 + if (IsStartOf(aRemainderOfForeign, *aArrayOfStates[i].iEscapeSequence))
1.1131 + {
1.1132 + // aRemainderOfForeign ends with a truncated escape sequence, so ConvertToUnicode cannot convert any more
1.1133 + aOutputConversionFlags|=CCnvCharacterSetConverter::EOutputConversionFlagInputIsTruncated;
1.1134 + break;
1.1135 + }
1.1136 + }
1.1137 +
1.1138 + MatchesEscapeSequence(aNumberOfForeignBytesConsumed,aHomogeneousRun,aRemainderOfForeign,aRemainderOfForeign.Left(2));
1.1139 + aConversionData = &conversionDataDummy;
1.1140 + returnValue = ETrue;
1.1141 + }
1.1142 + if (aHomogeneousRun.Length()>0)
1.1143 + {
1.1144 + returnValue = ETrue;
1.1145 + }
1.1146 + return returnValue;
1.1147 +}
1.1148 +// -----------------------------------------------------------------------------
1.1149 +// ConvertFromUnicodeIntermediateBufferInPlace()
1.1150 +//Default implementation for conversion to the intermediate buffer
1.1151 +//It modifies the unicode buffer before it is converted back to iscii.
1.1152 +//The current implementation of iscii plug-in doesn't require any
1.1153 +//modification to the default implementation
1.1154 +// Returns: Nothing
1.1155 +//
1.1156 +// -----------------------------------------------------------------------------
1.1157 +//
1.1158 +
1.1159 +
1.1160 +LOCAL_C void ConvertFromUnicodeIntermediateBufferInPlace(TInt aStartPositionInDescriptor, TDes8& aDescriptor, TInt& aNumberOfCharactersThatDroppedOut)
1.1161 +{
1.1162 + CnvUtilities::ConvertFromIntermediateBufferInPlace(aStartPositionInDescriptor, aDescriptor, aNumberOfCharactersThatDroppedOut, KEscapeSequenceDevanagari, 1);
1.1163 +}
1.1164 +
1.1165 +// -----------------------------------------------------------------------------
1.1166 +// DoFindAndModifyBuffer()
1.1167 +//Modifies the iscii buffer by replacing the search buffer with the replacement buffer.
1.1168 +//Introduced for handling multibyte iscii sequence.
1.1169 +//Takes the search buffer array and the replacement buffer arrays as input to it and replaces all
1.1170 +//the occurances of the search buffer with the corresponding replace buffer.
1.1171 +// Returns: Nothing
1.1172 +//
1.1173 +// -----------------------------------------------------------------------------
1.1174 +//
1.1175 +
1.1176 +LOCAL_C void DoFindAndModifyBuffer(TDes8& aModifyBuffer,const TDesC8& aSearchBuffer,const TDesC8& aReplaceBuffer)
1.1177 +{
1.1178 + FOREVER
1.1179 + {
1.1180 + TInt offset;
1.1181 + __ASSERT_ALWAYS((aSearchBuffer.Length()>= aReplaceBuffer.Length()),User::Panic(KPanicReason,EPanicBadReplacementBuffer));
1.1182 + if((offset = aModifyBuffer.Find(aSearchBuffer)) != KErrNotFound)
1.1183 + {
1.1184 + TUint8 *pointerToBuffer = const_cast<TUint8*> (aModifyBuffer.Ptr());
1.1185 + Mem::Copy(pointerToBuffer+offset,aReplaceBuffer.Ptr(),aReplaceBuffer.Length());
1.1186 + Mem::Copy(pointerToBuffer+offset+aReplaceBuffer.Length(),pointerToBuffer+offset+aSearchBuffer.Length(),aModifyBuffer.Length()-aSearchBuffer.Length()-offset);
1.1187 + aModifyBuffer.SetLength(aModifyBuffer.Length() - aSearchBuffer.Length() + aReplaceBuffer.Length());
1.1188 + }
1.1189 + else
1.1190 + break;
1.1191 + }
1.1192 +
1.1193 +}
1.1194 +
1.1195 +// -----------------------------------------------------------------------------
1.1196 +// FindAndModifyBuffer()
1.1197 +//Modifies the iscii buffer by replacing the search buffer with the replacement buffer.
1.1198 +//Calls DoFindAndModifyBuffer() and supplies the search buffer and replacement buffer.
1.1199 +//Introduced for handling multibyte iscii sequence.
1.1200 +// Returns: Nothing
1.1201 +//
1.1202 +// -----------------------------------------------------------------------------
1.1203 +//
1.1204 +
1.1205 +LOCAL_C void FindAndModifyBuffer(TDes8& aModifyBuffer)
1.1206 +{
1.1207 + RArray<TPtrC8> searchBuffer;
1.1208 + RArray<TPtrC8> replaceBuffer;
1.1209 +
1.1210 + TInt ret = KErrNone;
1.1211 + ret |= searchBuffer.Append(KExplicitHalant().Mid(0));
1.1212 + ret |= searchBuffer.Append(KSoftHalant().Mid(0));
1.1213 + ret |= searchBuffer.Append(KOm().Mid(0));
1.1214 + ret |= searchBuffer.Append(KAvagraha().Mid(0));
1.1215 +
1.1216 + ret |= replaceBuffer.Append(KReplacementForExplicitHalant().Mid(0));
1.1217 + ret |= replaceBuffer.Append(KReplacementForSoftHalant().Mid(0));
1.1218 + ret |= replaceBuffer.Append(KReplacementForOm().Mid(0));
1.1219 + ret |= replaceBuffer.Append(KReplacementForAvagraha().Mid(0));
1.1220 +
1.1221 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.1222 +
1.1223 + for(TInt counter=0;counter<searchBuffer.Count();counter++)
1.1224 + {
1.1225 + DoFindAndModifyBuffer(aModifyBuffer,searchBuffer[counter],replaceBuffer[counter]);
1.1226 + }
1.1227 + searchBuffer.Reset();
1.1228 + replaceBuffer.Reset();
1.1229 +
1.1230 +}
1.1231 +
1.1232 +// -----------------------------------------------------------------------------
1.1233 +// DoNormalizeReturnValue()
1.1234 +//Modifies the return value(Number of bytes did not get converted) according to the modified
1.1235 +//intermediate buffer. Takes the modified intermediate buffer, return value, search and replace
1.1236 +//buffers. Searches for the replace buffer in the intermediate buffer and if found, it looks for
1.1237 +//the actual buffer corresponding to the replace buffer and adds the difference of the lengths
1.1238 +//of the actual to replace buffer to the return value.
1.1239 +// Returns: Nothing
1.1240 +//
1.1241 +// -----------------------------------------------------------------------------
1.1242 +//
1.1243 +
1.1244 +LOCAL_C void DoNormalizeReturnValue(TUint& aReturnValue,const TDesC8& aBuffer,RArray<TPtrC8>& anArrayOfSearches,RArray<TPtrC8>& anArrayOfReplaces)
1.1245 +{
1.1246 + TPtr8 buffer(const_cast<TUint8*>(aBuffer.Ptr()),aBuffer.Length(),aBuffer.Length());
1.1247 + TUint count = anArrayOfSearches.Count();
1.1248 + FOREVER
1.1249 + {
1.1250 + TBool flag = EFalse;
1.1251 + for(TUint i=0;i<count;i++)
1.1252 + {
1.1253 + TPtrC8 searchBufferForComparison(buffer.Right(anArrayOfReplaces[i].Length()));
1.1254 + TInt returnCompare = searchBufferForComparison.Compare(anArrayOfReplaces[i]);
1.1255 + if(returnCompare == 0)
1.1256 + {
1.1257 + flag =ETrue;
1.1258 + aReturnValue += (anArrayOfSearches[i].Length() - anArrayOfReplaces[i].Length());
1.1259 + buffer=buffer.MidTPtr(0,buffer.Length()-anArrayOfReplaces[i].Length());
1.1260 + break;
1.1261 + }
1.1262 + }
1.1263 +
1.1264 + if(buffer.Length() == 0)
1.1265 + {
1.1266 + break;
1.1267 + }
1.1268 +
1.1269 + if(!flag)
1.1270 + {
1.1271 + buffer=buffer.MidTPtr(0,buffer.Length()-1);
1.1272 + }
1.1273 + }
1.1274 +
1.1275 +}
1.1276 +
1.1277 +// -----------------------------------------------------------------------------
1.1278 +// NormalizeReturnValue()
1.1279 +//Modifies the return value(Number of bytes did not get converted) according to the
1.1280 +//replacements done to the iscii buffer before conversion.
1.1281 +//Internally calls DoNormalizeReturnValue() by suppling the search and replacement
1.1282 +//buffers.
1.1283 +
1.1284 +// Returns: Nothing
1.1285 +//
1.1286 +// -----------------------------------------------------------------------------
1.1287 +//
1.1288 +
1.1289 +LOCAL_C void NormalizeReturnValue(TUint& aReturnValue,const TDesC8& aBuffer)
1.1290 +{
1.1291 + RArray<TPtrC8> searchBuffer;
1.1292 + RArray<TPtrC8> replaceBuffer;
1.1293 + TInt ret =KErrNone;
1.1294 + ret |= searchBuffer.Append(KExplicitHalant().Mid(0));
1.1295 + ret |= searchBuffer.Append(KSoftHalant().Mid(0));
1.1296 + ret |= searchBuffer.Append(KOm().Mid(0));
1.1297 + ret |= searchBuffer.Append(KAvagraha().Mid(0));
1.1298 +
1.1299 + ret |= replaceBuffer.Append(KReplacementForExplicitHalant().Mid(0));
1.1300 + ret |= replaceBuffer.Append(KReplacementForSoftHalant().Mid(0));
1.1301 + ret |= replaceBuffer.Append(KReplacementForOm().Mid(0));
1.1302 + ret |= replaceBuffer.Append(KReplacementForAvagraha().Mid(0));
1.1303 +
1.1304 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.1305 +
1.1306 + DoNormalizeReturnValue(aReturnValue,aBuffer,searchBuffer,replaceBuffer);
1.1307 + searchBuffer.Reset();
1.1308 + replaceBuffer.Reset();
1.1309 +}
1.1310 +
1.1311 +// -----------------------------------------------------------------------------
1.1312 +// HandleHomogeneousRun()
1.1313 +//Handles a homogeneous foreign buffer and converts the foreign buffer to unicode
1.1314 +//On return the aUnicode argument contains the converted unicode data.
1.1315 +//Also it sets the return value, returned from the conversion. The return value also
1.1316 +//takes into account if there is any buffer modification done before passing it to
1.1317 +//CCnvCharacterSetConverter::DoConvertToUnicode()
1.1318 +//buffers.
1.1319 +
1.1320 +// Returns: Nothing
1.1321 +//
1.1322 +// -----------------------------------------------------------------------------
1.1323 +//
1.1324 +
1.1325 +LOCAL_C void HandleHomogeneousRun(const SCnvConversionData*& aConversionData,
1.1326 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.1327 + TDes16& aUnicode,
1.1328 + const TDesC8& aHomogeneousForeign,
1.1329 + TInt& aNumberOfUnconvertibleCharacters,
1.1330 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter,
1.1331 + TUint& aOutputConversionFlags,
1.1332 + TUint aInputConversionFlags,TInt& aNumberOfForeignBytesConsumed,
1.1333 + TInt& aReturnValue)
1.1334 +{
1.1335 + TInt numberOfUnconvertibleCharacters;
1.1336 + TInt indexOfFirstByteOfFirstUnconvertibleCharacter;
1.1337 + TUint noOfConsumedBytes = 0;
1.1338 + if(aConversionData == NULL)
1.1339 + {
1.1340 + aReturnValue = CCnvCharacterSetConverter::EErrorIllFormedInput;
1.1341 + return;
1.1342 + }
1.1343 + aReturnValue = CCnvCharacterSetConverter::DoConvertToUnicode(*aConversionData,aDefaultEndiannessOfForeignCharacters,
1.1344 + aUnicode,aHomogeneousForeign,numberOfUnconvertibleCharacters,
1.1345 + indexOfFirstByteOfFirstUnconvertibleCharacter,aOutputConversionFlags,
1.1346 +
1.1347 + //The numberOfUnconvertibleCharacters and indexOfFirstByteOfFirstUnconvertibleCharacter are the values with
1.1348 + //respect to the intermediate iscii buffer and original values aIndexOfFirstByteOfFirstUnconvertibleCharacter and
1.1349 + //aNumberOfUnconvertibleCharacters need to be adjusted accordingly.
1.1350 +
1.1351 + aInputConversionFlags);
1.1352 + if(numberOfUnconvertibleCharacters>0)
1.1353 + {
1.1354 + if(aNumberOfUnconvertibleCharacters == 0)
1.1355 + {
1.1356 + aIndexOfFirstByteOfFirstUnconvertibleCharacter = aNumberOfForeignBytesConsumed + indexOfFirstByteOfFirstUnconvertibleCharacter;
1.1357 + }
1.1358 + aNumberOfUnconvertibleCharacters+=numberOfUnconvertibleCharacters;
1.1359 + }
1.1360 + noOfConsumedBytes = aHomogeneousForeign.Length();
1.1361 + //To Check whether it is really required.
1.1362 + NormalizeReturnValue(noOfConsumedBytes,aHomogeneousForeign);
1.1363 + aNumberOfForeignBytesConsumed+=noOfConsumedBytes;
1.1364 + if(aReturnValue>0)
1.1365 + {
1.1366 + TUint normalizedReturnValue = aReturnValue;
1.1367 +
1.1368 + //There original iscii buffer copied to an intermediate iscii buffer and then modified
1.1369 + //and is then passed for conversion. Now, after conversion, the return value needs to
1.1370 + //be adjusted according to the original buffer. NormalizeReturnValue() does the
1.1371 + //same thing.
1.1372 +
1.1373 + NormalizeReturnValue(normalizedReturnValue,aHomogeneousForeign);
1.1374 + aNumberOfForeignBytesConsumed-=normalizedReturnValue;
1.1375 + aReturnValue=normalizedReturnValue;
1.1376 + }
1.1377 +
1.1378 + //The HandleHomogeneousRun() method is called in a loop and once there is some
1.1379 + //iscii codes converted to unicode, the ConvertToUnicode() should not return
1.1380 + //CCnvCharacterSetConverter::EErrorIllFormedInput even though the conversion
1.1381 + //method does not convert any of the iscii codes ppassed. To ensure that once the
1.1382 + //first non-zero number of iscii codes are converted, the internal input conversion
1.1383 + //flag is set to EInputConversionFlagAllowTruncatedInputNotEvenPartlyConsumable.
1.1384 +
1.1385 + if(aNumberOfForeignBytesConsumed>0)
1.1386 + {
1.1387 + aInputConversionFlags|=CCnvCharacterSetConverter::EInputConversionFlagAllowTruncatedInputNotEvenPartlyConsumable;
1.1388 + }
1.1389 + return;
1.1390 +}
1.1391 +
1.1392 +// -----------------------------------------------------------------------------
1.1393 +// IsTruncatedDoubleByteIsciiSequence()
1.1394 +//Checks if anIsciiBuffer is a part of multi byte iscii sequence truncated in the middle.
1.1395 +//If it is a truncated sequence, then returns ETrue else returns EFalse.
1.1396 +//
1.1397 +// Returns: ETrue: If the intermediate input iscii buffer is truncated
1.1398 +// EFalse: If the intermediate input iscii buffer is not truncated
1.1399 +//
1.1400 +// -----------------------------------------------------------------------------
1.1401 +//
1.1402 +
1.1403 +LOCAL_C TBool IsTruncatedDoubleByteIsciiSequence(const TDesC8& anIsciiBuffer)
1.1404 +{
1.1405 + RArray<TPtrC8> searchBuffer;
1.1406 + if(anIsciiBuffer.Length () == 0)
1.1407 + return EFalse;
1.1408 + if(anIsciiBuffer[anIsciiBuffer.Length()-1] == 0xEF)
1.1409 + return ETrue;
1.1410 +
1.1411 + TInt appendret = KErrNone;
1.1412 + appendret |= searchBuffer.Append(KSoftHalant().Mid(0));
1.1413 + appendret |= searchBuffer.Append(KOm().Mid(0));
1.1414 + appendret |= searchBuffer.Append(KAvagraha().Mid(0));
1.1415 + appendret |= searchBuffer.Append(KExplicitHalant().Mid(0));
1.1416 + __ASSERT_DEBUG(!ret, User::Panic(_L("RArray append failure"), ret));
1.1417 +
1.1418 + TBool ret = EFalse;
1.1419 + TBool isNotTruncated =EFalse;
1.1420 +
1.1421 + //First check if the intermediate iscii buffer is ending with a complete multi byte sequence.
1.1422 + //If it ends with a complete multi byte sequence, no need to check if the last character of
1.1423 + //intermediate iscii is same as first character of multi byte iscii sequence. And return EFalse.
1.1424 + for(TUint counter = 0;counter<searchBuffer.Count();counter++)
1.1425 + {
1.1426 + if(searchBuffer[counter].Compare(anIsciiBuffer.Right(searchBuffer[counter].Length())) == 0)
1.1427 + {
1.1428 + isNotTruncated = ETrue;
1.1429 + break;
1.1430 + }
1.1431 + }
1.1432 + //If the intermediate iscii buffer is not ending with a complete multi byte sequence, and the
1.1433 + //last code of the iscii buffer is a part of the multibyte sequence, then the iscii buffer is a
1.1434 + //truncated sequence and in that case return ETrue.
1.1435 +
1.1436 + for(TUint counter = 0;counter<searchBuffer.Count();counter++)
1.1437 + {
1.1438 + if(isNotTruncated)
1.1439 + break;
1.1440 + else if( (anIsciiBuffer[anIsciiBuffer.Length()-1] == searchBuffer[counter][0]))
1.1441 + {
1.1442 + ret =ETrue;
1.1443 + break;
1.1444 + }
1.1445 + }
1.1446 + searchBuffer.Reset();
1.1447 + return ret;
1.1448 +}
1.1449 +
1.1450 +// -----------------------------------------------------------------------------
1.1451 +// ReplacementForUnconvertibleUnicodeCharacters()
1.1452 +//Returns the replacement character for unconvertible unicode character.
1.1453 +//In the current implementation it is 0x1a (ASCII Substitute character)
1.1454 +//The default implementation calls ReplacementForUnconvertibleUnicodeCharacters_internal()
1.1455 +//in turn which is generated by cnvtool.
1.1456 +//
1.1457 +// Returns: Replacemt for unconvertible unicode characters (0x1a)
1.1458 +//
1.1459 +// -----------------------------------------------------------------------------
1.1460 +//
1.1461 +
1.1462 +EXPORT_C const TDesC8& ReplacementForUnconvertibleUnicodeCharacters()
1.1463 + {
1.1464 + return ReplacementForUnconvertibleUnicodeCharacters_internal();
1.1465 + }
1.1466 +
1.1467 +// -----------------------------------------------------------------------------
1.1468 +// ConvertFromUnicode()
1.1469 +//The main conversion function for converting from unicode to iscii
1.1470 +//Loaded and called by the character conversion framework.
1.1471 +//In turn calls CnvUtilities::ConvertFromUnicode() which is Symbian provide
1.1472 +//utility method for converting unicode to modal character codes.
1.1473 +//
1.1474 +// Returns: The numbet of unicode codes it could not convert.
1.1475 +//
1.1476 +// -----------------------------------------------------------------------------
1.1477 +//
1.1478 +
1.1479 +EXPORT_C TInt ConvertFromUnicode(
1.1480 + CCnvCharacterSetConverter::TEndianness
1.1481 + aDefaultEndiannessOfForeignCharacters,
1.1482 + const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,
1.1483 + TDes8& aForeign,
1.1484 + const TDesC16& aUnicode,
1.1485 + CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters )
1.1486 + {
1.1487 + TFixedArray<CnvUtilities::SCharacterSet,KNumberOfIndicCharactersetsSupported> aArrayOfCharacterSets;
1.1488 + aArrayOfCharacterSets[0].iConversionData = &conversionData;
1.1489 + aArrayOfCharacterSets[0].iConvertFromIntermediateBufferInPlace = ConvertFromUnicodeIntermediateBufferInPlace;
1.1490 + aArrayOfCharacterSets[0].iEscapeSequence = &KEscapeSequenceDevanagari();
1.1491 +
1.1492 + return CnvUtilities::ConvertFromUnicode(
1.1493 + aDefaultEndiannessOfForeignCharacters,
1.1494 + aReplacementForUnconvertibleUnicodeCharacters,
1.1495 + aForeign,
1.1496 + aUnicode,
1.1497 + aIndicesOfUnconvertibleCharacters,
1.1498 + aArrayOfCharacterSets.Array());
1.1499 + }
1.1500 +
1.1501 +// -----------------------------------------------------------------------------
1.1502 +// ConvertToUnicode()
1.1503 +//The main conversion function for converting from iscii to unicode
1.1504 +//Loaded and called by the character conversion framework.
1.1505 +//To support some of the iscii characters, the input forign buffer is
1.1506 +//copied to an intermediate buffer and then is then modified and
1.1507 +//CCnvCharactersetConverter::DoConvertToUnicode() is called with
1.1508 +//the modified buffer. For extensibility of iscii to other Indic languages
1.1509 +//it uses CnvUtilities::SState datastructure. CnvUtilities::SState is a
1.1510 +//Symbian defined class for modal charactersets. The escape sequence
1.1511 +//is specified to ATR followed by the script selection code and the conversion
1.1512 +//data is specified to be the conversion for the particular script. For the time
1.1513 +//being only Devanagari with script selection code 0x42 is supported. If
1.1514 +//any of the other script codes are used the conversion leads to unconvertible
1.1515 +//character i.e. 0xFFFD.
1.1516 +// Returns: The numbet of iscii codes it could not convert.
1.1517 +//
1.1518 +// -----------------------------------------------------------------------------
1.1519 +//
1.1520 +
1.1521 +EXPORT_C TInt ConvertToUnicode(
1.1522 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.1523 + TDes16& aUnicode,
1.1524 + const TDesC8& aForeign,
1.1525 + TInt& aState,
1.1526 + TInt& aNumberOfUnconvertibleCharacters,
1.1527 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter )
1.1528 + {
1.1529 + aNumberOfUnconvertibleCharacters = 0;
1.1530 + TUint aOutputConversionFlags = CCnvCharacterSetConverter::KStateDefault;
1.1531 + aIndexOfFirstByteOfFirstUnconvertibleCharacter=-1;
1.1532 + TUint internalInputConversionFlags = 0;
1.1533 + TInt numberOfForeignBytesConsumed=0;
1.1534 + TPtrC8 remainderOfForeign(aForeign);
1.1535 + TInt returnValue;
1.1536 + TBool flag = EFalse;
1.1537 + TBool isSkipMatchSequence = EFalse;
1.1538 + const SCnvConversionData* convData;
1.1539 + //Set the iscii conversion data and escape sequence for Devanagari.
1.1540 + TFixedArray<CnvUtilities::SState,KNumberOfIndicCharactersetsSupported> modals;
1.1541 + modals[0].iConversionData = &conversionData;
1.1542 + modals[0].iEscapeSequence = &KEscapeSequenceDevanagari();
1.1543 +
1.1544 + aUnicode.SetLength(0);
1.1545 +
1.1546 + //The internal input conversion flag for conversion is set to CCnvCharacterSetConverter::EInputConversionFlagAppend
1.1547 + //so that for each conversion in the conversion loop, the generated conversion buffer is appened to the aUnicode buffer.
1.1548 + internalInputConversionFlags |= CCnvCharacterSetConverter::EInputConversionFlagAppend;
1.1549 + if (aForeign.Length()==0)
1.1550 + {
1.1551 + return 0;
1.1552 + }
1.1553 + //Get the conversion data from the previous call else the conversion data is set to the default
1.1554 + //conversion data, i.e. Devanagari.
1.1555 + convData=(aState!=CCnvCharacterSetConverter::KStateDefault)? REINTERPRET_CAST(const SCnvConversionData*, aState): modals[0].iConversionData;
1.1556 + FOREVER
1.1557 + {
1.1558 + TBuf8<KMaximumLengthOfIntermediateBuffer> intermediateBuffer;
1.1559 + TUint numberOfForeignBytesConsumedThisTime = 0;
1.1560 + if((remainderOfForeign.Length() >=KMaximumLengthOfIntermediateBuffer) && (aUnicode.MaxLength()-aUnicode.Length() >=KMaximumLengthOfIntermediateBuffer))
1.1561 + {
1.1562 + numberOfForeignBytesConsumedThisTime = KMaximumLengthOfIntermediateBuffer;
1.1563 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.1564 + //If the intermediate buffer is a part of truncated buffer sequence but the
1.1565 + //actual input buffer is not truncated then truncated sequence is not converted.
1.1566 + //The intermediate buffer is modified so as not to contain the truncated sequence.
1.1567 +
1.1568 + flag = IsTruncatedDoubleByteIsciiSequence(intermediateBuffer);
1.1569 + if(flag)
1.1570 + {
1.1571 + numberOfForeignBytesConsumedThisTime --;
1.1572 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.1573 + }
1.1574 +
1.1575 + }
1.1576 + else
1.1577 + {
1.1578 + flag = IsTruncatedDoubleByteIsciiSequence(remainderOfForeign.Left(aUnicode.MaxLength()-aUnicode.Length()));
1.1579 + if(!flag)
1.1580 + {
1.1581 + numberOfForeignBytesConsumedThisTime = aUnicode.MaxLength()-aUnicode.Length();
1.1582 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.1583 + }
1.1584 + else
1.1585 + {
1.1586 + if(aForeign.Length()>(numberOfForeignBytesConsumed+aUnicode.Length()))
1.1587 + {
1.1588 + numberOfForeignBytesConsumedThisTime = aUnicode.MaxLength()-aUnicode.Length()-1;
1.1589 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.1590 + break;
1.1591 + }
1.1592 + else
1.1593 + {
1.1594 + numberOfForeignBytesConsumedThisTime = aUnicode.MaxLength()-aUnicode.Length();
1.1595 + intermediateBuffer = remainderOfForeign.Left(numberOfForeignBytesConsumedThisTime);
1.1596 + }
1.1597 + }
1.1598 + }
1.1599 +
1.1600 + //The input intermediate iscii buffer is modified with the search and replace
1.1601 + //buffers. It is required for supporting multibyte iscii sequences.
1.1602 + FindAndModifyBuffer(intermediateBuffer);
1.1603 + TPtrC8 remainderOfForeignInternal(intermediateBuffer);
1.1604 + TPtrC8 homogeneousRun;
1.1605 + const TInt startOfNextEscapeSequence=intermediateBuffer.Locate(KControlCharacterEscape);
1.1606 + if (startOfNextEscapeSequence!=0)
1.1607 + {
1.1608 + if (startOfNextEscapeSequence==KErrNotFound)
1.1609 + {
1.1610 + homogeneousRun.Set(remainderOfForeignInternal);
1.1611 + remainderOfForeignInternal.Set(NULL, 0);
1.1612 + }
1.1613 + else
1.1614 + {
1.1615 + __ASSERT_DEBUG(startOfNextEscapeSequence>0, User::Panic(KPanicReason,EPanicBadStartOfNextEscapeSequence));
1.1616 + homogeneousRun.Set(remainderOfForeignInternal.Left(startOfNextEscapeSequence));
1.1617 + remainderOfForeignInternal.Set(remainderOfForeignInternal.Mid(startOfNextEscapeSequence));
1.1618 + }
1.1619 + isSkipMatchSequence = ETrue;
1.1620 + }
1.1621 + FOREVER
1.1622 + {
1.1623 + if(!isSkipMatchSequence)
1.1624 + {
1.1625 + if (!NextHomogeneousForeignRun(convData, numberOfForeignBytesConsumed, homogeneousRun,
1.1626 + remainderOfForeignInternal, modals.Array(), aOutputConversionFlags))
1.1627 + {
1.1628 + break;
1.1629 + }
1.1630 + }
1.1631 + HandleHomogeneousRun( convData, aDefaultEndiannessOfForeignCharacters, aUnicode, homogeneousRun, aNumberOfUnconvertibleCharacters,
1.1632 + aIndexOfFirstByteOfFirstUnconvertibleCharacter,aOutputConversionFlags,internalInputConversionFlags,
1.1633 + numberOfForeignBytesConsumed,returnValue);
1.1634 + if(returnValue<0)
1.1635 + {
1.1636 + return returnValue;
1.1637 + }
1.1638 + isSkipMatchSequence = EFalse;
1.1639 + }
1.1640 + if(returnValue > 0)
1.1641 + break;
1.1642 + if ((!flag && (numberOfForeignBytesConsumedThisTime != KMaximumLengthOfIntermediateBuffer)) || (flag && (numberOfForeignBytesConsumedThisTime != (KMaximumLengthOfIntermediateBuffer-1) )))
1.1643 + break;
1.1644 + remainderOfForeign.Set(aForeign.Mid(numberOfForeignBytesConsumed));
1.1645 + }
1.1646 + //If the number of iscii bytes consumed by the conversion is zero also the output conversion
1.1647 + //flag is not set to EOutputConversionFlagInputIsTruncated, then return EErrorIllFormedInput.
1.1648 + if ((numberOfForeignBytesConsumed==0) && (aOutputConversionFlags&CCnvCharacterSetConverter::EOutputConversionFlagInputIsTruncated))
1.1649 + {
1.1650 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.1651 + }
1.1652 + //Set the conversion data sothat next time when ConvertToUnicode() is called,
1.1653 + //will use the previous conversion data.
1.1654 + aState=REINTERPRET_CAST(TInt, convData);
1.1655 + return aForeign.Length()-numberOfForeignBytesConsumed;
1.1656 + }
1.1657 +
1.1658 +// -----------------------------------------------------------------------------
1.1659 +// IsInThisCharacterSetL()
1.1660 +//The method tells how probable it is that a sample piece of text is encoded in this character set.
1.1661 +//On return aConfidenceLevel, indicates how confident the function is about its return value. For
1.1662 +//iscii it is the default implementation and it does not implement the autodetect functionality.
1.1663 +//Loaded and called by the character conversion framework.
1.1664 +//
1.1665 +// Returns: EFalse: To tell CCnvCharacterSetConverter::AutoDetectCharacterSetL() that the plug-in DLL
1.1666 +// is not implementing a function of this signature and is therefore empty.
1.1667 +//
1.1668 +// -----------------------------------------------------------------------------
1.1669 +//
1.1670 +
1.1671 +
1.1672 +//Default implementation for IsInThisCharacterSetL()
1.1673 +
1.1674 +EXPORT_C TBool IsInThisCharacterSetL(
1.1675 + TBool& aSetToTrue,
1.1676 + TInt& aConfidenceLevel,
1.1677 + const TDesC8& )
1.1678 + {
1.1679 + aSetToTrue = EFalse;
1.1680 + aConfidenceLevel = 0;
1.1681 + return EFalse;
1.1682 + }
1.1683 +
1.1684 +EXPORT_C void Reserved_2()
1.1685 + {
1.1686 + }
1.1687 +
1.1688 +EXPORT_C void Reserved_3()
1.1689 + {
1.1690 + }
1.1691 +
1.1692 +EXPORT_C void Reserved_4()
1.1693 + {
1.1694 + }
1.1695 +
1.1696 +EXPORT_C void Reserved_5()
1.1697 + {
1.1698 + }
1.1699 +
1.1700 +EXPORT_C void Reserved_6()
1.1701 + {
1.1702 + }
1.1703 +
1.1704 +EXPORT_C void Reserved_7()
1.1705 + {
1.1706 + }
1.1707 +
1.1708 +EXPORT_C void Reserved_8()
1.1709 + {
1.1710 + }
1.1711 +
1.1712 +#endif //EKA2