/*

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

            }

        }