/*
* Copyright (c) 2002-2004 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: This file is a source code file for a charconv plug-in.
* This plug-in supports EUC-JP with direct mapped pictograph.
*
*/
// INCLUDE FILES
#include <e32std.h>
#include <charconv.h>
#ifndef EKA2
#include <CONVPLUG.H>
#else
#include <convgeneratedcpp.h>
#include <ecom/implementationproxy.h>
#include "charactersetconverter.h"
#endif // !EKA2
#include <convutils.h>
#include "jisx0201.h"
#include "jisx0208.h"
#include "jisx0212.h"
#include "CnvShiftJisDirectmap.h"
// LOCAL CONSTANTS AND MACROS
const TUint KSingleShift2=0x8e;
const TUint KSingleShift3=0x8f;
const TUint KFirstByteRangeFirstBlockStart = 0xF5;
const TUint KFirstByteRangeFirstBlockEnd = 0xFE;
const TUint KSecondByteRangeSecondBlockStart = 0xA1;
const TUint KSecondByteRangeSecondBlockEnd = 0xFE;
const TUint KPictographStartFirstByte = 0xF0;
const TUint KPictographStartSecondByte = 0x40;
const TUint KEUCJPSecondBlockStart = 0xF5;
const TUint KEUCJPBlockSize = 0x5D;
const TUint KShiftJisTrailByteIllegal = 0x7F;
// SecureID for Brower app
const TUint32 KBrowserSecureId = 0x10008D39;
// Define for converting from YenSign to BackSlash
const TUint KCharacterCodeForYenSign = 0x00A5;
const TUint KCharacterCodeForBackSlash = 0x005C;
// fullwidth question mark
_LIT8(KLit8EucJpPackedReplacementForUnconvertibleUnicodeCharacters, "\xa1\xa9");
#if defined(_DEBUG)
_LIT(KLitPanicText, "EucJpDirectmap");
enum TPanic
{
EPanicNothingToConvert1=1,
EPanicNothingToConvert2,
EPanicNothingToConvert3,
EPanicNothingToConvert4,
EPanicNothingToConvert5,
EPanicNothingToConvert6,
EPanicOddNumberOfBytes1,
EPanicOddNumberOfBytes2,
EPanicOddNumberOfBytes3,
EPanicOddNumberOfBytes4,
EPanicOddNumberOfBytes5,
EPanicOddNumberOfBytes6,
EPanicBadHighBit1,
EPanicBadHighBit2,
EPanicBadHighBit3,
EPanicBadHighBit4,
EPanicBadHighBit5,
EPanicBadHighBit6,
EPanicBadHighBit7,
EPanicBadPointers1,
EPanicBadPointers2,
EPanicBadPointers3,
EPanicBadPointers4,
EPanicBadPointers5,
EPanicBadPointers6,
EPanicBadPointers7,
EPanicBadPointers8,
EPanicBadPointers9,
EPanicBadPointers10,
EPanicBadPointers11,
EPanicBadPointers12,
EPanicBadPointers13,
EPanicBadPointers14,
EPanicBadPointers15,
EPanicBadPointers16,
EPanicBadPointers17,
EPanicBadPointers18,
EPanicBadPointers19,
EPanicBadPointers20,
EPanicBadPointers21,
EPanicBadPointers22,
EPanicBadPointers23,
EPanicBadPointers24,
EPanicBadPointers25,
EPanicBadPointers26,
EPanicBadPointers27,
EPanicBadPointers28,
EPanicBadPointers29,
EPanicBadPointers30,
EPanicBadPointers31,
EPanicBadPointers32,
EPanicBadPointers33,
EPanicBadPointers34,
EPanicBadPointers35,
EPanicBadPointers36,
EPanicBadCalculation1,
EPanicBadCalculation2,
EPanicNumberOfBytesIsNotMultipleOfThree1,
EPanicNumberOfBytesIsNotMultipleOfThree2,
EPanicSingleShift2Expected,
EPanicSingleShift3Expected
};
LOCAL_C void Panic(TPanic aPanic)
{
User::Panic(KLitPanicText, aPanic);
}
#endif
// -----------------------------------------------------------------------------
// DummyConvertFromIntermediateBufferInPlace
//
// -----------------------------------------------------------------------------
//
LOCAL_C void DummyConvertFromIntermediateBufferInPlace(TInt, TDes8&,
TInt& aNumberOfCharactersThatDroppedOut)
{
aNumberOfCharactersThatDroppedOut = 0;
}
// -----------------------------------------------------------------------------
// ConvertFromJisX0208ToEucJpPackedInPlace
// Converts from JIS code to EUC-JP
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertFromJisX0208ToEucJpPackedInPlace(
TInt aStartPositionInDescriptor, TDes8& aDescriptor,
TInt& aNumberOfCharactersThatDroppedOut)
{
aNumberOfCharactersThatDroppedOut = 0;
const TInt descriptorLength = aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
Panic(EPanicNothingToConvert1));
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
Panic(EPanicOddNumberOfBytes1));
TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* const pointerToLastByte =
pointerToCurrentByte + (descriptorLength - 1);
pointerToCurrentByte += aStartPositionInDescriptor;
FOREVER
{
const TUint currentByte = *pointerToCurrentByte;
__ASSERT_DEBUG((currentByte & 0x80) == 0, Panic(EPanicBadHighBit1));
*pointerToCurrentByte = STATIC_CAST(TUint8, currentByte | 0x80);
__ASSERT_DEBUG(pointerToCurrentByte <= pointerToLastByte,
Panic(EPanicBadPointers1));
if (pointerToCurrentByte >= pointerToLastByte)
{
break;
}
++pointerToCurrentByte;
}
}
// -----------------------------------------------------------------------------
// ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace
// Converts from half width Katakana code to EUC-JP
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace(
TInt aStartPositionInDescriptor, TDes8& aDescriptor,
TInt& aNumberOfCharactersThatDroppedOut)
{
TInt descriptorLength = aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
Panic(EPanicNothingToConvert2));
aNumberOfCharactersThatDroppedOut = Max(0, (descriptorLength -
aStartPositionInDescriptor) - ((aDescriptor.MaxLength() -
aStartPositionInDescriptor) / 2));
descriptorLength -= aNumberOfCharactersThatDroppedOut;
__ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,
Panic(EPanicBadCalculation1));
if (descriptorLength <= aStartPositionInDescriptor)
{
aDescriptor.SetLength(descriptorLength);
}
else
{
// pointerToTargetByte is initialized properly when descriptorLength
// has been offset to the actual final length of aDescriptor
TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* const pointerToFirstByte =
pointerToTargetByte + aStartPositionInDescriptor;
const TUint8* pointerToSourceByte =
pointerToTargetByte + (descriptorLength - 1);
descriptorLength =
((descriptorLength - aStartPositionInDescriptor) * 2) +
aStartPositionInDescriptor;
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
Panic(EPanicOddNumberOfBytes2));
aDescriptor.SetLength(descriptorLength);
// pointerToTargetByte is is initialized properly here
pointerToTargetByte += descriptorLength - 1;
FOREVER
{
*pointerToTargetByte = *pointerToSourceByte;
__ASSERT_DEBUG(pointerToTargetByte>pointerToFirstByte,
Panic(EPanicBadPointers2));
--pointerToTargetByte;
*pointerToTargetByte = KSingleShift2;
__ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,
Panic(EPanicBadPointers3));
if (pointerToTargetByte <= pointerToFirstByte)
{
break;
}
--pointerToTargetByte;
__ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,
Panic(EPanicBadPointers4));
--pointerToSourceByte;
}
__ASSERT_DEBUG(pointerToTargetByte == pointerToFirstByte,
Panic(EPanicBadPointers5));
__ASSERT_DEBUG(pointerToSourceByte == pointerToFirstByte,
Panic(EPanicBadPointers6));
}
}
// -----------------------------------------------------------------------------
// ConvertFromJisX0212ToEucJpPackedInPlace
// Converts from JIS code to EUC-JP
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertFromJisX0212ToEucJpPackedInPlace(
TInt aStartPositionInDescriptor, TDes8& aDescriptor,
TInt& aNumberOfCharactersThatDroppedOut)
{
TInt descriptorLength=aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
Panic(EPanicNothingToConvert3));
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
Panic(EPanicOddNumberOfBytes3));
aNumberOfCharactersThatDroppedOut =
Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -
((aDescriptor.MaxLength() - aStartPositionInDescriptor) / 3));
descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;
__ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,
Panic(EPanicBadCalculation2));
if (descriptorLength <= aStartPositionInDescriptor)
{
aDescriptor.SetLength(descriptorLength);
}
else
{
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
Panic(EPanicOddNumberOfBytes4));
// pointerToTargetByte is initialized properly when descriptorLength
// has been offset to the actual final length of aDescriptor
TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* const pointerToFirstByte =
pointerToTargetByte + aStartPositionInDescriptor;
const TUint8* pointerToSourceByte =
pointerToTargetByte + (descriptorLength - 1);
descriptorLength = (((descriptorLength - aStartPositionInDescriptor)
* 3) / 2) + aStartPositionInDescriptor;
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 3 ==0,
Panic(EPanicNumberOfBytesIsNotMultipleOfThree1));
aDescriptor.SetLength(descriptorLength);
// pointerToTargetByte is is initialized properly here
pointerToTargetByte += descriptorLength - 1;
FOREVER
{
__ASSERT_DEBUG((*pointerToSourceByte & 0x80) == 0,
Panic(EPanicBadHighBit2));
*pointerToTargetByte =
STATIC_CAST(TUint8, *pointerToSourceByte | 0x80);
__ASSERT_DEBUG(pointerToTargetByte > pointerToFirstByte,
Panic(EPanicBadPointers7));
--pointerToTargetByte;
__ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,
Panic(EPanicBadPointers8));
--pointerToSourceByte;
__ASSERT_DEBUG((*pointerToSourceByte & 0x80) == 0,
Panic(EPanicBadHighBit3));
*pointerToTargetByte =
STATIC_CAST(TUint8, *pointerToSourceByte | 0x80);
__ASSERT_DEBUG(pointerToTargetByte > pointerToFirstByte,
Panic(EPanicBadPointers9));
--pointerToTargetByte;
*pointerToTargetByte = KSingleShift3;
__ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,
Panic(EPanicBadPointers10));
if (pointerToTargetByte <= pointerToFirstByte)
{
break;
}
--pointerToTargetByte;
__ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,
Panic(EPanicBadPointers11));
--pointerToSourceByte;
}
__ASSERT_DEBUG(pointerToTargetByte == pointerToFirstByte,
Panic(EPanicBadPointers12));
__ASSERT_DEBUG(pointerToSourceByte == pointerToFirstByte,
Panic(EPanicBadPointers13));
}
}
// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToJisRoman
// Counts the bytes of be able to convert to JIS
// -----------------------------------------------------------------------------
//
LOCAL_C TInt NumberOfBytesAbleToConvertToJisRoman(const TDesC8& aDescriptor)
{
const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
const TUint8* const pointerToLastByte =
pointerToPreviousByte + aDescriptor.Length();
if (pointerToPreviousByte == pointerToLastByte)
{
return 0;
}
FOREVER
{
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers14));
const TUint currentByte = *(pointerToPreviousByte + 1);
if (currentByte & 0x80)
{
break;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers15));
++pointerToPreviousByte;
__ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
Panic(EPanicBadPointers16));
if (pointerToPreviousByte >= pointerToLastByte)
{
break;
}
}
return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
}
// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToJisX0208
// Counts the bytes of be able to convert to JIS
// -----------------------------------------------------------------------------
//
LOCAL_C TInt NumberOfBytesAbleToConvertToJisX0208(const TDesC8& aDescriptor)
{
const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
const TUint8* const pointerToLastByte =
pointerToPreviousByte + aDescriptor.Length();
if (pointerToPreviousByte == pointerToLastByte)
{
return 0;
}
FOREVER
{
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers17));
TUint currentByte = *(pointerToPreviousByte + 1);
if (currentByte < 0xa0)
{
break;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers18));
if (pointerToLastByte - pointerToPreviousByte < 2)
{
break;
}
++pointerToPreviousByte;
currentByte = *(pointerToPreviousByte + 1);
if (currentByte < 0xa0)
{
return CCnvCharacterSetConverter::EErrorIllFormedInput;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers19));
++pointerToPreviousByte;
__ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
Panic(EPanicBadPointers20));
if (pointerToPreviousByte >= pointerToLastByte)
{
break;
}
}
return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
}
// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToHalfWidthKatakana8
// Counts the bytes of be able to convert to half width Katakana
// -----------------------------------------------------------------------------
//
LOCAL_C TInt NumberOfBytesAbleToConvertToHalfWidthKatakana8(const TDesC8& aDescriptor)
{
const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
const TUint8* const pointerToLastByte =
pointerToPreviousByte + aDescriptor.Length();
if (pointerToPreviousByte == pointerToLastByte)
{
return 0;
}
FOREVER
{
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers21));
TUint currentByte = *(pointerToPreviousByte + 1);
if (currentByte != KSingleShift2)
{
break;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers22));
if (pointerToLastByte - pointerToPreviousByte < 2)
{
break;
}
++pointerToPreviousByte;
currentByte = *(pointerToPreviousByte + 1);
if (currentByte < 0xa0)
{
return CCnvCharacterSetConverter::EErrorIllFormedInput;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers23));
++pointerToPreviousByte;
__ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
Panic(EPanicBadPointers24));
if (pointerToPreviousByte >= pointerToLastByte)
{
break;
}
}
return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
}
// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToJisX0212
// Counts the bytes of be able to convert to JIS
// -----------------------------------------------------------------------------
//
LOCAL_C TInt NumberOfBytesAbleToConvertToJisX0212(const TDesC8& aDescriptor)
{
const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
const TUint8* const pointerToLastByte =
pointerToPreviousByte + aDescriptor.Length();
if (pointerToPreviousByte == pointerToLastByte)
{
return 0;
}
FOREVER
{
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers25));
TUint currentByte = *(pointerToPreviousByte + 1);
if (currentByte != KSingleShift3)
{
break;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers26));
if (pointerToLastByte - pointerToPreviousByte < 3)
{
break;
}
++pointerToPreviousByte;
currentByte = *(pointerToPreviousByte + 1);
if (currentByte < 0xa0)
{
return CCnvCharacterSetConverter::EErrorIllFormedInput;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers27));
++pointerToPreviousByte;
currentByte = *(pointerToPreviousByte + 1);
if (currentByte < 0xa0)
{
return CCnvCharacterSetConverter::EErrorIllFormedInput;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers28));
++pointerToPreviousByte;
__ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
Panic(EPanicBadPointers29));
if (pointerToPreviousByte >= pointerToLastByte)
{
break;
}
}
return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
}
// -----------------------------------------------------------------------------
// DummyConvertToIntermediateBufferInPlace
//
// -----------------------------------------------------------------------------
//
LOCAL_C void DummyConvertToIntermediateBufferInPlace(TDes8&)
{
}
// -----------------------------------------------------------------------------
// ConvertToJisX0208FromEucJpPackedInPlace
// Converts from EUC-JP to JIS code
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertToJisX0208FromEucJpPackedInPlace(TDes8& aDescriptor)
{
const TInt descriptorLength = aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert4));
__ASSERT_DEBUG(descriptorLength % 2 == 0, Panic(EPanicOddNumberOfBytes5));
TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* const pointerToLastByte =
pointerToCurrentByte + (descriptorLength - 1);
FOREVER
{
const TUint currentByte = *pointerToCurrentByte;
__ASSERT_DEBUG(currentByte & 0x80, Panic(EPanicBadHighBit4));
*pointerToCurrentByte = STATIC_CAST(TUint8, currentByte & ~0x80);
__ASSERT_DEBUG(pointerToCurrentByte <= pointerToLastByte,
Panic(EPanicBadPointers30));
if (pointerToCurrentByte >= pointerToLastByte)
{
break;
}
++pointerToCurrentByte;
}
}
// -----------------------------------------------------------------------------
// ConvertToHalfWidthKatakana8FromEucJpPackedInPlace
// Converts from EUC-JP to half width Katakana
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertToHalfWidthKatakana8FromEucJpPackedInPlace(
TDes8& aDescriptor)
{
const TInt descriptorLength = aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert5));
__ASSERT_DEBUG(descriptorLength % 2 == 0, Panic(EPanicOddNumberOfBytes6));
TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* pointerToSourceByte = pointerToTargetByte;
const TUint8* const pointerToLastByte = pointerToSourceByte +
(descriptorLength - 1);
FOREVER
{
__ASSERT_DEBUG(*pointerToSourceByte == KSingleShift2,
Panic(EPanicSingleShift2Expected));
__ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,
Panic(EPanicBadPointers31));
++pointerToSourceByte;
const TUint sourceByte = *pointerToSourceByte;
__ASSERT_DEBUG(sourceByte & 0x80, Panic(EPanicBadHighBit5));
*pointerToTargetByte = STATIC_CAST(TUint8, sourceByte);
__ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,
Panic(EPanicBadPointers32));
if (pointerToSourceByte >= pointerToLastByte)
{
break;
}
++pointerToSourceByte;
++pointerToTargetByte;
}
aDescriptor.SetLength(descriptorLength / 2);
}
// -----------------------------------------------------------------------------
// ConvertToJisX0212FromEucJpPackedInPlace
// Converts from EUC-JP to JIS
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertToJisX0212FromEucJpPackedInPlace(TDes8& aDescriptor)
{
const TInt descriptorLength = aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert6));
__ASSERT_DEBUG(descriptorLength % 3 == 0,
Panic(EPanicNumberOfBytesIsNotMultipleOfThree2));
TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* pointerToSourceByte = pointerToTargetByte;
const TUint8* const pointerToLastByte =
pointerToSourceByte + (descriptorLength - 1);
FOREVER
{
__ASSERT_DEBUG(*pointerToSourceByte == KSingleShift3,
Panic(EPanicSingleShift3Expected));
__ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,
Panic(EPanicBadPointers33));
++pointerToSourceByte;
TUint sourceByte = *pointerToSourceByte;
__ASSERT_DEBUG(sourceByte & 0x80, Panic(EPanicBadHighBit6));
*pointerToTargetByte = STATIC_CAST(TUint8, sourceByte & ~0x80);
__ASSERT_DEBUG(pointerToSourceByte<pointerToLastByte,
Panic(EPanicBadPointers34));
++pointerToSourceByte;
sourceByte = *pointerToSourceByte;
__ASSERT_DEBUG(sourceByte&0x80, Panic(EPanicBadHighBit7));
__ASSERT_DEBUG(pointerToTargetByte < pointerToLastByte,
Panic(EPanicBadPointers35));
++pointerToTargetByte;
*pointerToTargetByte = STATIC_CAST(TUint8, sourceByte & ~0x80);
__ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,
Panic(EPanicBadPointers36));
if (pointerToSourceByte >= pointerToLastByte)
{
break;
}
++pointerToSourceByte;
++pointerToTargetByte;
}
aDescriptor.SetLength((descriptorLength / 3) * 2);
}
// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToPictograph
//
// -----------------------------------------------------------------------------
//
LOCAL_C TInt NumberOfBytesAbleToConvertToPictograph1(const TDesC8& aDescriptor)
{
const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
const TUint8* const pointerToLastByte =
pointerToPreviousByte + aDescriptor.Length();
if (pointerToPreviousByte == pointerToLastByte)
{
return 0;
}
for (;pointerToPreviousByte < pointerToLastByte;)
{
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers14));
TUint currentByte = *(pointerToPreviousByte + 1);
const TUint nextByte = *(pointerToPreviousByte + 2);
if (((currentByte < KFirstByteRangeFirstBlockStart) ||
(currentByte > KFirstByteRangeFirstBlockEnd)) ||
((nextByte < KSecondByteRangeSecondBlockStart) ||
(nextByte > KSecondByteRangeSecondBlockEnd)))
{
break;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers15));
pointerToPreviousByte += 2;
}
return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
}
// -----------------------------------------------------------------------------
// NumberOfBytesAbleToConvertToPictograph
//
// -----------------------------------------------------------------------------
//
LOCAL_C TInt NumberOfBytesAbleToConvertToPictograph2(const TDesC8& aDescriptor)
{
const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
const TUint8* const pointerToLastByte =
pointerToPreviousByte + aDescriptor.Length();
if (pointerToPreviousByte == pointerToLastByte)
{
return 0;
}
for (;pointerToPreviousByte < pointerToLastByte;)
{
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers14));
TUint currentByte = *(pointerToPreviousByte + 1);
if (currentByte == KSingleShift3)
{
pointerToPreviousByte++;
currentByte = *(pointerToPreviousByte + 1);
}
else
{
break;
}
if (currentByte < 0xa0)
{
return CCnvCharacterSetConverter::EErrorIllFormedInput;
}
const TUint nextByte = *(pointerToPreviousByte + 2);
if (nextByte < 0xa0)
{
return CCnvCharacterSetConverter::EErrorIllFormedInput;
}
if (((currentByte < KFirstByteRangeFirstBlockStart) ||
(currentByte > KFirstByteRangeFirstBlockEnd)) ||
((nextByte < KSecondByteRangeSecondBlockStart) ||
(nextByte > KSecondByteRangeSecondBlockEnd)))
{
// return the previous byte to the beginning of loop.
pointerToPreviousByte--;
break;
}
__ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
Panic(EPanicBadPointers15));
pointerToPreviousByte += 2;
}
return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
}
// -----------------------------------------------------------------------------
// ConvertFromPictogaphToEucJpDirectmapInPlace
// Converts from EucJp packed Pictograph to Unicode
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertFromPictogaphToEucJpDirectmapInPlace(
TInt aStartPositionInDescriptor, TDes8& aDescriptor,
TInt& aNumberOfCharactersThatDroppedOut)
{
TInt descriptorLength=aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
Panic(EPanicNothingToConvert3));
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
Panic(EPanicOddNumberOfBytes3));
TInt bytesPerCharacter = 2;
if (aDescriptor[0] >= KEUCJPSecondBlockStart)
{
bytesPerCharacter = 3;
}
aNumberOfCharactersThatDroppedOut =
Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -
((aDescriptor.MaxLength() - aStartPositionInDescriptor) /
bytesPerCharacter));
descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;
__ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,
Panic(EPanicBadCalculation2));
if (descriptorLength <= aStartPositionInDescriptor)
{
aDescriptor.SetLength(descriptorLength);
}
else
{
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
Panic(EPanicOddNumberOfBytes4));
// pointerToTargetByte is initialized properly when descriptorLength
// has been offset to the actual final length of aDescriptor
TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* const pointerToFirstByte =
pointerToTargetByte + aStartPositionInDescriptor;
const TUint8* pointerToSourceByte =
pointerToTargetByte + (descriptorLength - 1);
descriptorLength = (((descriptorLength - aStartPositionInDescriptor)
* bytesPerCharacter) / 2) + aStartPositionInDescriptor;
__ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) %
bytesPerCharacter == 0, Panic(EPanicNumberOfBytesIsNotMultipleOfThree1));
aDescriptor.SetLength(descriptorLength);
// pointerToTargetByte is is initialized properly here
pointerToTargetByte += descriptorLength - 1;
for (;pointerToTargetByte > pointerToFirstByte; )
{
TInt secondByte = *pointerToSourceByte;
TInt firstByte = *(pointerToSourceByte - 1);
if (bytesPerCharacter == 3)
{
firstByte = (firstByte - KEUCJPSecondBlockStart) * 2 +
KFirstByteRangeFirstBlockStart;
}
else
{
firstByte = (firstByte - KPictographStartFirstByte) * 2 +
KFirstByteRangeFirstBlockStart;
}
if (static_cast<TInt>(KEUCJPBlockSize + KPictographStartSecondByte + 1)
< secondByte)
{
if (secondByte > KShiftJisTrailByteIllegal)
secondByte -= 1;
secondByte = secondByte -(KPictographStartSecondByte +
KEUCJPBlockSize + 1) + KSecondByteRangeSecondBlockStart;
firstByte++;
}
else
{
if (secondByte > KShiftJisTrailByteIllegal)
secondByte -= 1;
secondByte += KSecondByteRangeSecondBlockStart - KPictographStartSecondByte;
}
*pointerToTargetByte = static_cast<TUint8>(secondByte);
--pointerToTargetByte;
*pointerToTargetByte = static_cast<TUint8>(firstByte);
if (bytesPerCharacter == 3)
{
--pointerToTargetByte;
*pointerToTargetByte = KSingleShift3;
}
__ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,
Panic(EPanicBadPointers10));
--pointerToTargetByte;
pointerToSourceByte -= 2;
}
}
}
// -----------------------------------------------------------------------------
// ConvertToPictographFromEucJpPackedInPlace1
// Converts from EucJp packed Pictograph to Unicode
// -----------------------------------------------------------------------------
//
LOCAL_C void ConvertToPictographFromEucJpPackedInPlace(TDes8& aDescriptor)
{
const TInt descriptorLength = aDescriptor.Length();
__ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert6));
TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
const TUint8* pointerToSourceByte = pointerToTargetByte;
const TUint8* const pointerToLastByte =
pointerToSourceByte + (descriptorLength - 1);
TInt bytesPerCharacter = 2;
TInt sjisStartbyte = KPictographStartFirstByte;
if (*pointerToSourceByte == KSingleShift3)
{
++pointerToSourceByte;
bytesPerCharacter = 3;
sjisStartbyte = KEUCJPSecondBlockStart;
}
for (;pointerToSourceByte < pointerToLastByte; )
{
__ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,
Panic(EPanicBadPointers33));
TUint firstByte = (*pointerToSourceByte
- KFirstByteRangeFirstBlockStart) / 2 + sjisStartbyte;
TUint secondByte = *(pointerToSourceByte + 1);
if ((*pointerToSourceByte % 2) == 0)
{
secondByte += KPictographStartSecondByte -
KSecondByteRangeSecondBlockStart + KEUCJPBlockSize + 1;
if (secondByte >= KShiftJisTrailByteIllegal)
secondByte++;
}
else
{
secondByte += KPictographStartSecondByte - KSecondByteRangeSecondBlockStart;
if (secondByte >= KShiftJisTrailByteIllegal)
secondByte++;
}
*pointerToTargetByte = static_cast<TUint8>(firstByte);
__ASSERT_DEBUG(pointerToTargetByte < pointerToLastByte,
Panic(EPanicBadPointers35));
++pointerToTargetByte;
*pointerToTargetByte = static_cast<TUint8>(secondByte);
__ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,
Panic(EPanicBadPointers36));
pointerToSourceByte += 2;
++pointerToTargetByte;
}
aDescriptor.SetLength((descriptorLength / bytesPerCharacter) * 2);
}
// New Interface class
class CEucJpDirectmapImplementation : 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&,
TInt& aNumberOfUnconvertibleCharacters,
TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter );
virtual TBool IsInThisCharacterSetL(
TBool& aSetToTrue,
TInt& aConfidenceLevel,
const TDesC8& );
static CEucJpDirectmapImplementation* NewL();
virtual ~CEucJpDirectmapImplementation();
private:
CEucJpDirectmapImplementation();
};
// -----------------------------------------------------------------------------
// ReplacementForUnconvertibleUnicodeCharacters
// Retruns the character to replacement for unconvertible unicode character.
// Returns: '?':
// -----------------------------------------------------------------------------
//
const TDesC8& CEucJpDirectmapImplementation::ReplacementForUnconvertibleUnicodeCharacters()
{
return KLit8EucJpPackedReplacementForUnconvertibleUnicodeCharacters;
}
// -----------------------------------------------------------------------------
// ConvertFromUnicode
// Converts from Unicode to EUC-JP
// Returns: The number of unconverted characters
// -----------------------------------------------------------------------------
//
TInt CEucJpDirectmapImplementation::ConvertFromUnicode(
CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,
TDes8& aForeign, const TDesC16& aUnicode,
CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)
{
TFixedArray<CnvUtilities::SCharacterSet, 6> characterSets;
characterSets[0].iConversionData = &CnvJisRoman::ConversionData();
characterSets[0].iConvertFromIntermediateBufferInPlace =
DummyConvertFromIntermediateBufferInPlace;
characterSets[0].iEscapeSequence = &KNullDesC8;
characterSets[1].iConversionData = &CnvJisX0208::ConversionData();
characterSets[1].iConvertFromIntermediateBufferInPlace =
ConvertFromJisX0208ToEucJpPackedInPlace;
characterSets[1].iEscapeSequence = &KNullDesC8;
characterSets[2].iConversionData = &CnvHalfWidthKatakana8::ConversionData();
characterSets[2].iConvertFromIntermediateBufferInPlace =
ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace;
characterSets[2].iEscapeSequence = &KNullDesC8;
characterSets[3].iConversionData = &CnvJisX0212::ConversionData();
characterSets[3].iConvertFromIntermediateBufferInPlace =
ConvertFromJisX0212ToEucJpPackedInPlace;
characterSets[3].iEscapeSequence = &KNullDesC8;
characterSets[4].iConversionData = &CnvShiftJisDirectmap::ConversionData();
characterSets[4].iConvertFromIntermediateBufferInPlace =
ConvertFromPictogaphToEucJpDirectmapInPlace;
characterSets[4].iEscapeSequence = &KNullDesC8;
characterSets[5].iConversionData = &CnvShiftJisDirectmap::ConversionData();
characterSets[5].iConvertFromIntermediateBufferInPlace =
ConvertFromPictogaphToEucJpDirectmapInPlace;
characterSets[5].iEscapeSequence = &KNullDesC8;
TInt unconvert = CnvUtilities::ConvertFromUnicode(
aDefaultEndiannessOfForeignCharacters,
aReplacementForUnconvertibleUnicodeCharacters,
aForeign, aUnicode, aIndicesOfUnconvertibleCharacters,
characterSets.Array());
return unconvert;
}
// -----------------------------------------------------------------------------
// ConvertToUnicode
// Converts from EUC-JP to Unicode.
// Returns: The number of unconverted bytes
// -----------------------------------------------------------------------------
//
TInt CEucJpDirectmapImplementation::ConvertToUnicode(
CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
TDes16& aUnicode, const TDesC8& aForeign, TInt&,
TInt& aNumberOfUnconvertibleCharacters,
TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)
{
TFixedArray<CnvUtilities::SMethod, 6> methods;
methods[0].iNumberOfBytesAbleToConvert =
NumberOfBytesAbleToConvertToPictograph1;
methods[0].iConvertToIntermediateBufferInPlace =
ConvertToPictographFromEucJpPackedInPlace;
methods[0].iConversionData = &CnvShiftJisDirectmap::ConversionData();
methods[0].iNumberOfBytesPerCharacter = 2;
methods[0].iNumberOfCoreBytesPerCharacter = 2;
methods[1].iNumberOfBytesAbleToConvert =
NumberOfBytesAbleToConvertToPictograph2;
methods[1].iConvertToIntermediateBufferInPlace =
ConvertToPictographFromEucJpPackedInPlace;
methods[1].iConversionData = &CnvShiftJisDirectmap::ConversionData();
methods[1].iNumberOfBytesPerCharacter = 3;
methods[1].iNumberOfCoreBytesPerCharacter = 2;
methods[2].iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvertToJisRoman;
methods[2].iConvertToIntermediateBufferInPlace =
DummyConvertToIntermediateBufferInPlace;
methods[2].iConversionData = &CnvJisRoman::ConversionData();
methods[2].iNumberOfBytesPerCharacter = 1;
methods[2].iNumberOfCoreBytesPerCharacter = 1;
methods[3].iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvertToJisX0208;
methods[3].iConvertToIntermediateBufferInPlace =
ConvertToJisX0208FromEucJpPackedInPlace;
methods[3].iConversionData = &CnvJisX0208::ConversionData();
methods[3].iNumberOfBytesPerCharacter = 2;
methods[3].iNumberOfCoreBytesPerCharacter = 2;
methods[4].iNumberOfBytesAbleToConvert =
NumberOfBytesAbleToConvertToHalfWidthKatakana8;
methods[4].iConvertToIntermediateBufferInPlace =
ConvertToHalfWidthKatakana8FromEucJpPackedInPlace;
methods[4].iConversionData = &CnvHalfWidthKatakana8::ConversionData();
methods[4].iNumberOfBytesPerCharacter = 2;
methods[4].iNumberOfCoreBytesPerCharacter = 1;
methods[5].iNumberOfBytesAbleToConvert =
NumberOfBytesAbleToConvertToJisX0212;
methods[5].iConvertToIntermediateBufferInPlace =
ConvertToJisX0212FromEucJpPackedInPlace;
methods[5].iConversionData = &CnvJisX0212::ConversionData();
methods[5].iNumberOfBytesPerCharacter = 3;
methods[5].iNumberOfCoreBytesPerCharacter = 2;
TInt unconvert = CnvUtilities::ConvertToUnicodeFromHeterogeneousForeign(
aDefaultEndiannessOfForeignCharacters, aUnicode, aForeign,
aNumberOfUnconvertibleCharacters,
aIndexOfFirstByteOfFirstUnconvertibleCharacter, methods.Array());
// The following is specific impelementation for brower.
// If brower app calls this API, the yen sign code(0xA5)
// must be converted to backslash code(0x5C).
// Becasue Javascript supports backslash code ony.
TBool browserProcess = (RProcess().SecureId().iId == KBrowserSecureId);
if (browserProcess && aUnicode.Length() > 0)
{
const TUint16* pB = aUnicode.Ptr();
const TUint16* pbase = pB;
const TUint16* pE = pB + aUnicode.Length() -1;
while (pE>=pbase)
{
if (*pbase == KCharacterCodeForYenSign)
{
aUnicode[pbase - pB] = KCharacterCodeForBackSlash;
}
pbase++;
}
}
return unconvert;
}
// -----------------------------------------------------------------------------
// IsInThisCharacterSetL
// Detects whether the text is the character code or not.
// Returns: ETrue:
// -----------------------------------------------------------------------------
//
TBool CEucJpDirectmapImplementation::IsInThisCharacterSetL(TBool& /*aSetToTrue*/, TInt& /*aConfidenceLevel*/,
const TDesC8& /*aSample*/)
{
return EFalse;
}
CEucJpDirectmapImplementation* CEucJpDirectmapImplementation::NewL()
{
CEucJpDirectmapImplementation* self = new(ELeave) CEucJpDirectmapImplementation;
return self;
}
CEucJpDirectmapImplementation::CEucJpDirectmapImplementation()
{
//default constructor.. do nothing
}
CEucJpDirectmapImplementation::~CEucJpDirectmapImplementation()
{
//default destructor .. do nothing
}
// ECOM CREATION FUNCTION
const TImplementationProxy ImplementationTable[] =
{
// Note: This is the same UID as defined in old mmp-file
// Used also in 12221212.rss ( implementation_uid )
IMPLEMENTATION_PROXY_ENTRY( 0x101F86A6, CEucJpDirectmapImplementation::NewL )
};
EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
{
aTableCount = sizeof( ImplementationTable ) / sizeof(TImplementationProxy);
return ImplementationTable;
}
// End of file