Symaptic: os/textandloc/charconvfw/charconvplugins/src/plugins/EucJpDirectmap.CPP@260cb5ec6c19

     1 /*

     2 * Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    This file is a source code file for a charconv plug-in.

    15 *                This plug-in supports EUC-JP with direct mapped pictograph.

    16 *

    17 */

    25 // INCLUDE FILES

    27 #include <e32std.h>

    29 #include <charconv.h>

    33 #ifndef EKA2

    35 #include <CONVPLUG.H>

    37 #else

    39 #include <convgeneratedcpp.h>

    41 #include <ecom/implementationproxy.h>

    43 #include "charactersetconverter.h"

    45 #endif // !EKA2

    49 #include <convutils.h>

    51 #include "jisx0201.h"

    53 #include "jisx0208.h"

    55 #include "jisx0212.h"

    57 #include "CnvShiftJisDirectmap.h"

    59 // LOCAL CONSTANTS AND MACROS

    61 const TUint KSingleShift2=0x8e;

    63 const TUint KSingleShift3=0x8f;

    65 const TUint KFirstByteRangeFirstBlockStart = 0xF5;

    67 const TUint KFirstByteRangeFirstBlockEnd = 0xFE;

    69 const TUint KSecondByteRangeSecondBlockStart = 0xA1;

    71 const TUint KSecondByteRangeSecondBlockEnd = 0xFE;

    73 const TUint KPictographStartFirstByte = 0xF0;

    75 const TUint KPictographStartSecondByte = 0x40;

    77 const TUint KEUCJPSecondBlockStart = 0xF5;

    79 const TUint KEUCJPBlockSize = 0x5D;

    81 const TUint KShiftJisTrailByteIllegal = 0x7F;

    85 // SecureID for Brower app

    87 const TUint32 KBrowserSecureId = 0x10008D39;

    89 // Define for converting from YenSign to BackSlash

    91 const TUint KCharacterCodeForYenSign = 0x00A5;

    93 const TUint KCharacterCodeForBackSlash = 0x005C;

    97 // fullwidth question mark

    99 _LIT8(KLit8EucJpPackedReplacementForUnconvertibleUnicodeCharacters, "\xa1\xa9");

   101 #if defined(_DEBUG)

   103 _LIT(KLitPanicText, "EucJpDirectmap");

   105 enum TPanic

   107     {

   109     EPanicNothingToConvert1=1,

   111     EPanicNothingToConvert2,

   113     EPanicNothingToConvert3,

   115     EPanicNothingToConvert4,

   117     EPanicNothingToConvert5,

   119     EPanicNothingToConvert6,

   121     EPanicOddNumberOfBytes1,

   123     EPanicOddNumberOfBytes2,

   125     EPanicOddNumberOfBytes3,

   127     EPanicOddNumberOfBytes4,

   129     EPanicOddNumberOfBytes5,

   131     EPanicOddNumberOfBytes6,

   133     EPanicBadHighBit1,

   135     EPanicBadHighBit2,

   137     EPanicBadHighBit3,

   139     EPanicBadHighBit4,

   141     EPanicBadHighBit5,

   143     EPanicBadHighBit6,

   145     EPanicBadHighBit7,

   147     EPanicBadPointers1,

   149     EPanicBadPointers2,

   151     EPanicBadPointers3,

   153     EPanicBadPointers4,

   155     EPanicBadPointers5,

   157     EPanicBadPointers6,

   159     EPanicBadPointers7,

   161     EPanicBadPointers8,

   163     EPanicBadPointers9,

   165     EPanicBadPointers10,

   167     EPanicBadPointers11,

   169     EPanicBadPointers12,

   171     EPanicBadPointers13,

   173     EPanicBadPointers14,

   175     EPanicBadPointers15,

   177     EPanicBadPointers16,

   179     EPanicBadPointers17,

   181     EPanicBadPointers18,

   183     EPanicBadPointers19,

   185     EPanicBadPointers20,

   187     EPanicBadPointers21,

   189     EPanicBadPointers22,

   191     EPanicBadPointers23,

   193     EPanicBadPointers24,

   195     EPanicBadPointers25,

   197     EPanicBadPointers26,

   199     EPanicBadPointers27,

   201     EPanicBadPointers28,

   203     EPanicBadPointers29,

   205     EPanicBadPointers30,

   207     EPanicBadPointers31,

   209     EPanicBadPointers32,

   211     EPanicBadPointers33,

   213     EPanicBadPointers34,

   215     EPanicBadPointers35,

   217     EPanicBadPointers36,

   219     EPanicBadCalculation1,

   221     EPanicBadCalculation2,

   223     EPanicNumberOfBytesIsNotMultipleOfThree1,

   225     EPanicNumberOfBytesIsNotMultipleOfThree2,

   227     EPanicSingleShift2Expected,

   229     EPanicSingleShift3Expected

   231     };

   235 LOCAL_C void Panic(TPanic aPanic)

   237     {

   239     User::Panic(KLitPanicText, aPanic);

   241     }

   243 #endif

   247 // -----------------------------------------------------------------------------

   249 // DummyConvertFromIntermediateBufferInPlace

   251 //

   253 // -----------------------------------------------------------------------------

   255 //

   257 LOCAL_C void DummyConvertFromIntermediateBufferInPlace(TInt, TDes8&,

   259         TInt& aNumberOfCharactersThatDroppedOut)

   261     {

   263     aNumberOfCharactersThatDroppedOut = 0;

   265     }

   269 // -----------------------------------------------------------------------------

   271 // ConvertFromJisX0208ToEucJpPackedInPlace

   273 // Converts from JIS code to EUC-JP

   275 // -----------------------------------------------------------------------------

   277 //

   279 LOCAL_C void ConvertFromJisX0208ToEucJpPackedInPlace(

   281         TInt aStartPositionInDescriptor, TDes8& aDescriptor,

   283         TInt& aNumberOfCharactersThatDroppedOut)

   285     {

   287     aNumberOfCharactersThatDroppedOut = 0;

   289     const TInt descriptorLength = aDescriptor.Length();

   291     __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,

   293         Panic(EPanicNothingToConvert1));

   295     __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,

   297         Panic(EPanicOddNumberOfBytes1));

   299     TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

   301     const TUint8* const pointerToLastByte =

   303         pointerToCurrentByte + (descriptorLength - 1);

   305     pointerToCurrentByte += aStartPositionInDescriptor;

   307     FOREVER

   309         {

   311         const TUint currentByte = *pointerToCurrentByte;

   313         __ASSERT_DEBUG((currentByte & 0x80) == 0, Panic(EPanicBadHighBit1));

   315         *pointerToCurrentByte = STATIC_CAST(TUint8, currentByte | 0x80);

   317         __ASSERT_DEBUG(pointerToCurrentByte <= pointerToLastByte,

   319             Panic(EPanicBadPointers1));

   321         if (pointerToCurrentByte >= pointerToLastByte)

   323             {

   325             break;

   327             }

   329         ++pointerToCurrentByte;

   331         }

   333     }

   337 // -----------------------------------------------------------------------------

   339 // ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace

   341 // Converts from half width Katakana code to EUC-JP

   343 // -----------------------------------------------------------------------------

   345 //

   347 LOCAL_C void ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace(

   349         TInt aStartPositionInDescriptor, TDes8& aDescriptor,

   351         TInt& aNumberOfCharactersThatDroppedOut)

   353     {

   355     TInt descriptorLength = aDescriptor.Length();

   357     __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,

   359         Panic(EPanicNothingToConvert2));

   361     aNumberOfCharactersThatDroppedOut = Max(0, (descriptorLength -

   363         aStartPositionInDescriptor) - ((aDescriptor.MaxLength() -

   365         aStartPositionInDescriptor) / 2));

   367     descriptorLength -= aNumberOfCharactersThatDroppedOut;

   369     __ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,

   371         Panic(EPanicBadCalculation1));

   373     if (descriptorLength <= aStartPositionInDescriptor)

   375         {

   377         aDescriptor.SetLength(descriptorLength);

   379         }

   381     else

   383         {

   385         // pointerToTargetByte is initialized properly when descriptorLength

   387         // has been offset to the actual final length of aDescriptor

   389         TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

   391         const TUint8* const pointerToFirstByte =

   393             pointerToTargetByte + aStartPositionInDescriptor;

   395         const TUint8* pointerToSourceByte =

   397             pointerToTargetByte + (descriptorLength - 1);

   399         descriptorLength =

   401             ((descriptorLength - aStartPositionInDescriptor) * 2) +

   403             aStartPositionInDescriptor;

   405         __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,

   407             Panic(EPanicOddNumberOfBytes2));

   409         aDescriptor.SetLength(descriptorLength);

   411         // pointerToTargetByte is is initialized properly here

   413         pointerToTargetByte += descriptorLength - 1;

   415         FOREVER

   417             {

   419             *pointerToTargetByte = *pointerToSourceByte;

   421             __ASSERT_DEBUG(pointerToTargetByte>pointerToFirstByte,

   423                 Panic(EPanicBadPointers2));

   425             --pointerToTargetByte;

   427             *pointerToTargetByte = KSingleShift2;

   429             __ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,

   431                 Panic(EPanicBadPointers3));

   433             if (pointerToTargetByte <= pointerToFirstByte)

   435                 {

   437                 break;

   439                 }

   441             --pointerToTargetByte;

   443             __ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,

   445                 Panic(EPanicBadPointers4));

   447             --pointerToSourceByte;

   449             }

   451         __ASSERT_DEBUG(pointerToTargetByte == pointerToFirstByte,

   453             Panic(EPanicBadPointers5));

   455         __ASSERT_DEBUG(pointerToSourceByte == pointerToFirstByte,

   457             Panic(EPanicBadPointers6));

   459         }

   461     }

   465 // -----------------------------------------------------------------------------

   467 // ConvertFromJisX0212ToEucJpPackedInPlace

   469 // Converts from JIS code to EUC-JP

   471 // -----------------------------------------------------------------------------

   473 //

   475 LOCAL_C void ConvertFromJisX0212ToEucJpPackedInPlace(

   477         TInt aStartPositionInDescriptor, TDes8& aDescriptor,

   479         TInt& aNumberOfCharactersThatDroppedOut)

   481     {

   483     TInt descriptorLength=aDescriptor.Length();

   485     __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,

   487         Panic(EPanicNothingToConvert3));

   489     __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,

   491         Panic(EPanicOddNumberOfBytes3));

   493     aNumberOfCharactersThatDroppedOut =

   495         Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -

   497         ((aDescriptor.MaxLength() - aStartPositionInDescriptor) / 3));

   499     descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;

   501     __ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,

   503         Panic(EPanicBadCalculation2));

   505     if (descriptorLength <= aStartPositionInDescriptor)

   507         {

   509         aDescriptor.SetLength(descriptorLength);

   511         }

   513     else

   515         {

   517         __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,

   519             Panic(EPanicOddNumberOfBytes4));

   521         // pointerToTargetByte is initialized properly when descriptorLength

   523         // has been offset to the actual final length of aDescriptor

   525         TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

   527         const TUint8* const pointerToFirstByte =

   529             pointerToTargetByte + aStartPositionInDescriptor;

   531         const TUint8* pointerToSourceByte =

   533             pointerToTargetByte + (descriptorLength - 1);

   535         descriptorLength = (((descriptorLength - aStartPositionInDescriptor)

   537             * 3) / 2) + aStartPositionInDescriptor;

   539         __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 3 ==0,

   541             Panic(EPanicNumberOfBytesIsNotMultipleOfThree1));

   543         aDescriptor.SetLength(descriptorLength);

   545         // pointerToTargetByte is is initialized properly here

   547         pointerToTargetByte += descriptorLength - 1;

   549         FOREVER

   551             {

   553             __ASSERT_DEBUG((*pointerToSourceByte & 0x80) == 0,

   555                 Panic(EPanicBadHighBit2));

   557             *pointerToTargetByte =

   559                 STATIC_CAST(TUint8, *pointerToSourceByte | 0x80);

   561             __ASSERT_DEBUG(pointerToTargetByte > pointerToFirstByte,

   563                 Panic(EPanicBadPointers7));

   565             --pointerToTargetByte;

   567             __ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,

   569                 Panic(EPanicBadPointers8));

   571             --pointerToSourceByte;

   573             __ASSERT_DEBUG((*pointerToSourceByte & 0x80) == 0,

   575                 Panic(EPanicBadHighBit3));

   577             *pointerToTargetByte =

   579                 STATIC_CAST(TUint8, *pointerToSourceByte | 0x80);

   581             __ASSERT_DEBUG(pointerToTargetByte > pointerToFirstByte,

   583                 Panic(EPanicBadPointers9));

   585             --pointerToTargetByte;

   587             *pointerToTargetByte = KSingleShift3;

   589             __ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,

   591                 Panic(EPanicBadPointers10));

   593             if (pointerToTargetByte <= pointerToFirstByte)

   595                 {

   597                 break;

   599                 }

   601             --pointerToTargetByte;

   603             __ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,

   605                 Panic(EPanicBadPointers11));

   607             --pointerToSourceByte;

   609             }

   611         __ASSERT_DEBUG(pointerToTargetByte == pointerToFirstByte,

   613             Panic(EPanicBadPointers12));

   615         __ASSERT_DEBUG(pointerToSourceByte == pointerToFirstByte,

   617             Panic(EPanicBadPointers13));

   619         }

   621     }

   625 // -----------------------------------------------------------------------------

   627 // NumberOfBytesAbleToConvertToJisRoman

   629 // Counts the bytes of be able to convert to JIS

   631 // -----------------------------------------------------------------------------

   633 //

   635 LOCAL_C TInt NumberOfBytesAbleToConvertToJisRoman(const TDesC8& aDescriptor)

   637     {

   639     const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;

   641     const TUint8* const pointerToLastByte =

   643         pointerToPreviousByte + aDescriptor.Length();

   645     if (pointerToPreviousByte == pointerToLastByte)

   647         {

   649         return 0;

   651         }

   653     FOREVER

   655         {

   657         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   659             Panic(EPanicBadPointers14));

   661         const TUint currentByte = *(pointerToPreviousByte + 1);

   663         if (currentByte & 0x80)

   665             {

   667             break;

   669             }

   671         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   673             Panic(EPanicBadPointers15));

   675         ++pointerToPreviousByte;

   677         __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,

   679             Panic(EPanicBadPointers16));

   681         if (pointerToPreviousByte >= pointerToLastByte)

   683             {

   685             break;

   687             }

   689         }

   691     return (pointerToPreviousByte + 1) - aDescriptor.Ptr();

   693     }

   697 // -----------------------------------------------------------------------------

   699 // NumberOfBytesAbleToConvertToJisX0208

   701 // Counts the bytes of be able to convert to JIS

   703 // -----------------------------------------------------------------------------

   705 //

   707 LOCAL_C TInt NumberOfBytesAbleToConvertToJisX0208(const TDesC8& aDescriptor)

   709     {

   711     const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;

   713     const TUint8* const pointerToLastByte =

   715         pointerToPreviousByte + aDescriptor.Length();

   717     if (pointerToPreviousByte == pointerToLastByte)

   719         {

   721         return 0;

   723         }

   725     FOREVER

   727         {

   729         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   731             Panic(EPanicBadPointers17));

   733         TUint currentByte = *(pointerToPreviousByte + 1);

   735         if (currentByte < 0xa0)

   737             {

   739             break;

   741             }

   743         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   745             Panic(EPanicBadPointers18));

   747         if (pointerToLastByte - pointerToPreviousByte < 2)

   749             {

   751             break;

   753             }

   755         ++pointerToPreviousByte;

   757         currentByte = *(pointerToPreviousByte + 1);

   759         if (currentByte < 0xa0)

   761             {

   763             return CCnvCharacterSetConverter::EErrorIllFormedInput;

   765             }

   767         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   769             Panic(EPanicBadPointers19));

   771         ++pointerToPreviousByte;

   773         __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,

   775             Panic(EPanicBadPointers20));

   777         if (pointerToPreviousByte >= pointerToLastByte)

   779             {

   781             break;

   783             }

   785         }

   787     return (pointerToPreviousByte + 1) - aDescriptor.Ptr();

   789     }

   793 // -----------------------------------------------------------------------------

   795 // NumberOfBytesAbleToConvertToHalfWidthKatakana8

   797 // Counts the bytes of be able to convert to half width Katakana

   799 // -----------------------------------------------------------------------------

   801 //

   803 LOCAL_C TInt NumberOfBytesAbleToConvertToHalfWidthKatakana8(const TDesC8& aDescriptor)

   805     {

   807     const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;

   809     const TUint8* const pointerToLastByte =

   811         pointerToPreviousByte + aDescriptor.Length();

   813     if (pointerToPreviousByte == pointerToLastByte)

   815         {

   817         return 0;

   819         }

   821     FOREVER

   823         {

   825         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   827             Panic(EPanicBadPointers21));

   829         TUint currentByte = *(pointerToPreviousByte + 1);

   831         if (currentByte != KSingleShift2)

   833             {

   835             break;

   837             }

   839         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   841             Panic(EPanicBadPointers22));

   843         if (pointerToLastByte - pointerToPreviousByte < 2)

   845             {

   847             break;

   849             }

   851         ++pointerToPreviousByte;

   853         currentByte = *(pointerToPreviousByte + 1);

   855         if (currentByte < 0xa0)

   857             {

   859             return CCnvCharacterSetConverter::EErrorIllFormedInput;

   861             }

   863         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   865             Panic(EPanicBadPointers23));

   867         ++pointerToPreviousByte;

   869         __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,

   871             Panic(EPanicBadPointers24));

   873         if (pointerToPreviousByte >= pointerToLastByte)

   875             {

   877             break;

   879             }

   881         }

   883     return (pointerToPreviousByte + 1) - aDescriptor.Ptr();

   885     }

   889 // -----------------------------------------------------------------------------

   891 // NumberOfBytesAbleToConvertToJisX0212

   893 // Counts the bytes of be able to convert to JIS

   895 // -----------------------------------------------------------------------------

   897 //

   899 LOCAL_C TInt NumberOfBytesAbleToConvertToJisX0212(const TDesC8& aDescriptor)

   901     {

   903     const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;

   905     const TUint8* const pointerToLastByte =

   907         pointerToPreviousByte + aDescriptor.Length();

   909     if (pointerToPreviousByte == pointerToLastByte)

   911         {

   913         return 0;

   915         }

   917     FOREVER

   919         {

   921         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   923             Panic(EPanicBadPointers25));

   925         TUint currentByte = *(pointerToPreviousByte + 1);

   927         if (currentByte != KSingleShift3)

   929             {

   931             break;

   933             }

   935         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   937             Panic(EPanicBadPointers26));

   939         if (pointerToLastByte - pointerToPreviousByte < 3)

   941             {

   943             break;

   945             }

   947         ++pointerToPreviousByte;

   949         currentByte = *(pointerToPreviousByte + 1);

   951         if (currentByte < 0xa0)

   953             {

   955             return CCnvCharacterSetConverter::EErrorIllFormedInput;

   957             }

   959         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   961             Panic(EPanicBadPointers27));

   963         ++pointerToPreviousByte;

   965         currentByte = *(pointerToPreviousByte + 1);

   967         if (currentByte < 0xa0)

   969             {

   971             return CCnvCharacterSetConverter::EErrorIllFormedInput;

   973             }

   975         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

   977             Panic(EPanicBadPointers28));

   979         ++pointerToPreviousByte;

   981         __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,

   983             Panic(EPanicBadPointers29));

   985         if (pointerToPreviousByte >= pointerToLastByte)

   987             {

   989             break;

   991             }

   993         }

   995     return (pointerToPreviousByte + 1) - aDescriptor.Ptr();

   997     }

  1001 // -----------------------------------------------------------------------------

  1003 // DummyConvertToIntermediateBufferInPlace

  1005 //

  1007 // -----------------------------------------------------------------------------

  1009 //

  1011 LOCAL_C void DummyConvertToIntermediateBufferInPlace(TDes8&)

  1013     {

  1015     }

  1019 // -----------------------------------------------------------------------------

  1021 // ConvertToJisX0208FromEucJpPackedInPlace

  1023 // Converts from EUC-JP to JIS code

  1025 // -----------------------------------------------------------------------------

  1027 //

  1029 LOCAL_C void ConvertToJisX0208FromEucJpPackedInPlace(TDes8& aDescriptor)

  1031     {

  1033     const TInt descriptorLength = aDescriptor.Length();

  1035     __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert4));

  1037     __ASSERT_DEBUG(descriptorLength % 2 == 0, Panic(EPanicOddNumberOfBytes5));

  1039     TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

  1041     const TUint8* const pointerToLastByte =

  1043         pointerToCurrentByte + (descriptorLength - 1);

  1045     FOREVER

  1047         {

  1049         const TUint currentByte = *pointerToCurrentByte;

  1051         __ASSERT_DEBUG(currentByte & 0x80, Panic(EPanicBadHighBit4));

  1053         *pointerToCurrentByte = STATIC_CAST(TUint8, currentByte & ~0x80);

  1055         __ASSERT_DEBUG(pointerToCurrentByte <= pointerToLastByte,

  1057             Panic(EPanicBadPointers30));

  1059         if (pointerToCurrentByte >= pointerToLastByte)

  1061             {

  1063             break;

  1065             }

  1067         ++pointerToCurrentByte;

  1069         }

  1071     }

  1075 // -----------------------------------------------------------------------------

  1077 // ConvertToHalfWidthKatakana8FromEucJpPackedInPlace

  1079 // Converts from EUC-JP to half width Katakana

  1081 // -----------------------------------------------------------------------------

  1083 //

  1085 LOCAL_C void ConvertToHalfWidthKatakana8FromEucJpPackedInPlace(

  1087         TDes8& aDescriptor)

  1089     {

  1091     const TInt descriptorLength = aDescriptor.Length();

  1093     __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert5));

  1095     __ASSERT_DEBUG(descriptorLength % 2 == 0, Panic(EPanicOddNumberOfBytes6));

  1097     TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

  1099     const TUint8* pointerToSourceByte = pointerToTargetByte;

  1101     const TUint8* const pointerToLastByte = pointerToSourceByte +

  1103         (descriptorLength - 1);

  1105     FOREVER

  1107         {

  1109         __ASSERT_DEBUG(*pointerToSourceByte == KSingleShift2,

  1111             Panic(EPanicSingleShift2Expected));

  1113         __ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,

  1115             Panic(EPanicBadPointers31));

  1117         ++pointerToSourceByte;

  1119         const TUint sourceByte = *pointerToSourceByte;

  1121         __ASSERT_DEBUG(sourceByte & 0x80, Panic(EPanicBadHighBit5));

  1123         *pointerToTargetByte = STATIC_CAST(TUint8, sourceByte);

  1125         __ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,

  1127             Panic(EPanicBadPointers32));

  1129         if (pointerToSourceByte >= pointerToLastByte)

  1131             {

  1133             break;

  1135             }

  1137         ++pointerToSourceByte;

  1139         ++pointerToTargetByte;

  1141         }

  1143     aDescriptor.SetLength(descriptorLength / 2);

  1145     }

  1149 // -----------------------------------------------------------------------------

  1151 // ConvertToJisX0212FromEucJpPackedInPlace

  1153 // Converts from EUC-JP to JIS

  1155 // -----------------------------------------------------------------------------

  1157 //

  1159 LOCAL_C void ConvertToJisX0212FromEucJpPackedInPlace(TDes8& aDescriptor)

  1161     {

  1163     const TInt descriptorLength = aDescriptor.Length();

  1165     __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert6));

  1167     __ASSERT_DEBUG(descriptorLength % 3 == 0,

  1169         Panic(EPanicNumberOfBytesIsNotMultipleOfThree2));

  1171     TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

  1173     const TUint8* pointerToSourceByte = pointerToTargetByte;

  1175     const TUint8* const pointerToLastByte =

  1177         pointerToSourceByte + (descriptorLength - 1);

  1179     FOREVER

  1181         {

  1183         __ASSERT_DEBUG(*pointerToSourceByte == KSingleShift3,

  1185             Panic(EPanicSingleShift3Expected));

  1187         __ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,

  1189             Panic(EPanicBadPointers33));

  1191         ++pointerToSourceByte;

  1193         TUint sourceByte = *pointerToSourceByte;

  1195         __ASSERT_DEBUG(sourceByte & 0x80, Panic(EPanicBadHighBit6));

  1197         *pointerToTargetByte = STATIC_CAST(TUint8, sourceByte & ~0x80);

  1199         __ASSERT_DEBUG(pointerToSourceByte<pointerToLastByte,

  1201             Panic(EPanicBadPointers34));

  1203         ++pointerToSourceByte;

  1205         sourceByte = *pointerToSourceByte;

  1207         __ASSERT_DEBUG(sourceByte&0x80, Panic(EPanicBadHighBit7));

  1209         __ASSERT_DEBUG(pointerToTargetByte < pointerToLastByte,

  1211             Panic(EPanicBadPointers35));

  1213         ++pointerToTargetByte;

  1215         *pointerToTargetByte = STATIC_CAST(TUint8, sourceByte & ~0x80);

  1217         __ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,

  1219             Panic(EPanicBadPointers36));

  1221         if (pointerToSourceByte >= pointerToLastByte)

  1223             {

  1225             break;

  1227             }

  1229         ++pointerToSourceByte;

  1231         ++pointerToTargetByte;

  1233         }

  1235     aDescriptor.SetLength((descriptorLength / 3) * 2);

  1237     }

  1241 // -----------------------------------------------------------------------------

  1243 // NumberOfBytesAbleToConvertToPictograph

  1245 //

  1247 // -----------------------------------------------------------------------------

  1249 //

  1251 LOCAL_C TInt NumberOfBytesAbleToConvertToPictograph1(const TDesC8& aDescriptor)

  1253     {

  1255     const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;

  1257     const TUint8* const pointerToLastByte =

  1259         pointerToPreviousByte + aDescriptor.Length();

  1261     if (pointerToPreviousByte == pointerToLastByte)

  1263         {

  1265         return 0;

  1267         }

  1269     for (;pointerToPreviousByte < pointerToLastByte;)

  1271         {

  1273         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

  1275             Panic(EPanicBadPointers14));

  1277         TUint currentByte = *(pointerToPreviousByte + 1);

  1279         const TUint nextByte = *(pointerToPreviousByte + 2);

  1281         if (((currentByte < KFirstByteRangeFirstBlockStart) ||

  1283              (currentByte > KFirstByteRangeFirstBlockEnd)) ||

  1285             ((nextByte < KSecondByteRangeSecondBlockStart) ||

  1287              (nextByte > KSecondByteRangeSecondBlockEnd)))

  1289             {

  1291             break;

  1293             }

  1295         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

  1297             Panic(EPanicBadPointers15));

  1299         pointerToPreviousByte += 2;

  1301         }

  1303     return (pointerToPreviousByte + 1) - aDescriptor.Ptr();

  1305     }

  1309 // -----------------------------------------------------------------------------

  1311 // NumberOfBytesAbleToConvertToPictograph

  1313 //

  1315 // -----------------------------------------------------------------------------

  1317 //

  1319 LOCAL_C TInt NumberOfBytesAbleToConvertToPictograph2(const TDesC8& aDescriptor)

  1321     {

  1323     const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;

  1325     const TUint8* const pointerToLastByte =

  1327         pointerToPreviousByte + aDescriptor.Length();

  1329     if (pointerToPreviousByte == pointerToLastByte)

  1331         {

  1333         return 0;

  1335         }

  1337     for (;pointerToPreviousByte < pointerToLastByte;)

  1339         {

  1341         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

  1343             Panic(EPanicBadPointers14));

  1345         TUint currentByte = *(pointerToPreviousByte + 1);

  1347         if (currentByte == KSingleShift3)

  1349             {

  1351             pointerToPreviousByte++;

  1353             currentByte = *(pointerToPreviousByte + 1);

  1355             }

  1357         else

  1359             {

  1361             break;

  1363             }

  1365         if (currentByte < 0xa0)

  1367             {

  1369             return CCnvCharacterSetConverter::EErrorIllFormedInput;

  1371             }

  1373         const TUint nextByte = *(pointerToPreviousByte + 2);

  1375         if (nextByte < 0xa0)

  1377             {

  1379             return CCnvCharacterSetConverter::EErrorIllFormedInput;

  1381             }

  1383         if (((currentByte < KFirstByteRangeFirstBlockStart) ||

  1385              (currentByte > KFirstByteRangeFirstBlockEnd)) ||

  1387             ((nextByte < KSecondByteRangeSecondBlockStart) ||

  1389              (nextByte > KSecondByteRangeSecondBlockEnd)))

  1391             {

  1393             // return the previous byte to the beginning of loop.

  1395             pointerToPreviousByte--;

  1397             break;

  1399             }

  1401         __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,

  1403             Panic(EPanicBadPointers15));

  1405         pointerToPreviousByte += 2;

  1407         }

  1409     return (pointerToPreviousByte + 1) - aDescriptor.Ptr();

  1411     }

  1415 // -----------------------------------------------------------------------------

  1417 // ConvertFromPictogaphToEucJpDirectmapInPlace

  1419 // Converts from EucJp packed Pictograph to Unicode

  1421 // -----------------------------------------------------------------------------

  1423 //

  1425 LOCAL_C void ConvertFromPictogaphToEucJpDirectmapInPlace(

  1427         TInt aStartPositionInDescriptor, TDes8& aDescriptor,

  1429         TInt& aNumberOfCharactersThatDroppedOut)

  1431     {

  1433     TInt descriptorLength=aDescriptor.Length();

  1435     __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,

  1437         Panic(EPanicNothingToConvert3));

  1439     __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,

  1441         Panic(EPanicOddNumberOfBytes3));

  1443     TInt bytesPerCharacter = 2;

  1445     if (aDescriptor[0] >= KEUCJPSecondBlockStart)

  1447         {

  1449         bytesPerCharacter = 3;

  1451         }

  1455     aNumberOfCharactersThatDroppedOut =

  1457         Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -

  1459         ((aDescriptor.MaxLength() - aStartPositionInDescriptor) /

  1461         bytesPerCharacter));

  1463     descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;

  1465     __ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,

  1467         Panic(EPanicBadCalculation2));

  1469     if (descriptorLength <= aStartPositionInDescriptor)

  1471         {

  1473         aDescriptor.SetLength(descriptorLength);

  1475         }

  1477     else

  1479         {

  1481         __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,

  1483             Panic(EPanicOddNumberOfBytes4));

  1485         // pointerToTargetByte is initialized properly when descriptorLength

  1487         // has been offset to the actual final length of aDescriptor

  1489         TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

  1491         const TUint8* const pointerToFirstByte =

  1493             pointerToTargetByte + aStartPositionInDescriptor;

  1495         const TUint8* pointerToSourceByte =

  1497             pointerToTargetByte + (descriptorLength - 1);

  1499         descriptorLength = (((descriptorLength - aStartPositionInDescriptor)

  1501             * bytesPerCharacter) / 2) + aStartPositionInDescriptor;

  1503         __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) %

  1505             bytesPerCharacter == 0, Panic(EPanicNumberOfBytesIsNotMultipleOfThree1));

  1507         aDescriptor.SetLength(descriptorLength);

  1509         // pointerToTargetByte is is initialized properly here

  1511         pointerToTargetByte += descriptorLength - 1;

  1513         for (;pointerToTargetByte > pointerToFirstByte; )

  1515             {

  1517             TInt secondByte = *pointerToSourceByte;

  1519             TInt firstByte = *(pointerToSourceByte - 1);

  1523             if (bytesPerCharacter == 3)

  1525                 {

  1527                 firstByte = (firstByte - KEUCJPSecondBlockStart) * 2 +

  1529                     KFirstByteRangeFirstBlockStart;

  1531                 }

  1533             else

  1535                 {

  1537                 firstByte = (firstByte - KPictographStartFirstByte) * 2 +

  1539                     KFirstByteRangeFirstBlockStart;

  1541                 }

  1543             if (static_cast<TInt>(KEUCJPBlockSize + KPictographStartSecondByte + 1)

  1545                  < secondByte)

  1547                 {

  1549                 if (secondByte > KShiftJisTrailByteIllegal)

  1551                     secondByte -= 1;

  1553                 secondByte = secondByte -(KPictographStartSecondByte +

  1555                     KEUCJPBlockSize + 1) + KSecondByteRangeSecondBlockStart;

  1557                 firstByte++;

  1559                 }

  1561             else

  1563                 {

  1565                 if (secondByte > KShiftJisTrailByteIllegal)

  1567                     secondByte -= 1;

  1569                 secondByte += KSecondByteRangeSecondBlockStart - KPictographStartSecondByte;

  1571                 }

  1573             *pointerToTargetByte = static_cast<TUint8>(secondByte);

  1575             --pointerToTargetByte;

  1577             *pointerToTargetByte = static_cast<TUint8>(firstByte);

  1579             if (bytesPerCharacter == 3)

  1581                 {

  1583                 --pointerToTargetByte;

  1585                 *pointerToTargetByte = KSingleShift3;

  1587                 }

  1589             __ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,

  1591                 Panic(EPanicBadPointers10));

  1593             --pointerToTargetByte;

  1595             pointerToSourceByte -= 2;

  1597             }

  1599         }

  1601     }

  1605 // -----------------------------------------------------------------------------

  1607 // ConvertToPictographFromEucJpPackedInPlace1

  1609 // Converts from EucJp packed Pictograph to Unicode

  1611 // -----------------------------------------------------------------------------

  1613 //

  1615 LOCAL_C void ConvertToPictographFromEucJpPackedInPlace(TDes8& aDescriptor)

  1617     {

  1619     const TInt descriptorLength = aDescriptor.Length();

  1621     __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert6));

  1623     TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());

  1625     const TUint8* pointerToSourceByte = pointerToTargetByte;

  1627     const TUint8* const pointerToLastByte =

  1629         pointerToSourceByte + (descriptorLength - 1);

  1631     TInt bytesPerCharacter = 2;

  1633     TInt sjisStartbyte = KPictographStartFirstByte;

  1635     if (*pointerToSourceByte == KSingleShift3)

  1637         {

  1639         ++pointerToSourceByte;

  1641         bytesPerCharacter = 3;

  1643         sjisStartbyte = KEUCJPSecondBlockStart;

  1645         }

  1647     for (;pointerToSourceByte < pointerToLastByte; )

  1649         {

  1651         __ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,

  1653             Panic(EPanicBadPointers33));

  1655         TUint firstByte = (*pointerToSourceByte

  1657             - KFirstByteRangeFirstBlockStart) / 2 + sjisStartbyte;

  1659         TUint secondByte = *(pointerToSourceByte + 1);

  1661         if ((*pointerToSourceByte % 2) == 0)

  1663             {

  1665             secondByte += KPictographStartSecondByte -

  1667                 KSecondByteRangeSecondBlockStart + KEUCJPBlockSize + 1;

  1669             if (secondByte >= KShiftJisTrailByteIllegal)

  1671                 secondByte++;

  1673             }

  1675         else

  1677             {

  1679             secondByte += KPictographStartSecondByte - KSecondByteRangeSecondBlockStart;

  1681             if (secondByte >= KShiftJisTrailByteIllegal)

  1683                 secondByte++;

  1685             }

  1687         *pointerToTargetByte = static_cast<TUint8>(firstByte);

  1691         __ASSERT_DEBUG(pointerToTargetByte < pointerToLastByte,

  1693             Panic(EPanicBadPointers35));

  1695         ++pointerToTargetByte;

  1697         *pointerToTargetByte = static_cast<TUint8>(secondByte);

  1699         __ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,

  1701             Panic(EPanicBadPointers36));

  1703         pointerToSourceByte += 2;

  1705         ++pointerToTargetByte;

  1707         }

  1709     aDescriptor.SetLength((descriptorLength / bytesPerCharacter) * 2);

  1711     }

  1715 // New Interface class

  1717 class CEucJpDirectmapImplementation : public CCharacterSetConverterPluginInterface

  1719 {

  1721     public:

  1723         virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters();

  1727         virtual TInt ConvertFromUnicode(

  1729             CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,

  1731             const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,

  1733             TDes8& aForeign,

  1735             const TDesC16& aUnicode,

  1737             CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters );

  1741         virtual TInt ConvertToUnicode(

  1743             CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,

  1745             TDes16& aUnicode,

  1747             const TDesC8& aForeign,

  1749             TInt&,

  1751             TInt& aNumberOfUnconvertibleCharacters,

  1753             TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter );

  1757         virtual TBool IsInThisCharacterSetL(

  1759             TBool& aSetToTrue,

  1761             TInt& aConfidenceLevel,

  1763             const TDesC8& );

  1767         static CEucJpDirectmapImplementation* NewL();

  1771         virtual ~CEucJpDirectmapImplementation();

  1773     private:

  1775         CEucJpDirectmapImplementation();

  1777 };

  1781 // -----------------------------------------------------------------------------

  1783 // ReplacementForUnconvertibleUnicodeCharacters

  1785 // Retruns the character to replacement for unconvertible unicode character.

  1787 // Returns: '?':

  1789 // -----------------------------------------------------------------------------

  1791 //

  1793 const TDesC8& CEucJpDirectmapImplementation::ReplacementForUnconvertibleUnicodeCharacters()

  1795     {

  1797     return KLit8EucJpPackedReplacementForUnconvertibleUnicodeCharacters;

  1799     }

  1803 // -----------------------------------------------------------------------------

  1805 // ConvertFromUnicode

  1807 // Converts from Unicode to EUC-JP

  1809 // Returns: The number of unconverted characters

  1811 // -----------------------------------------------------------------------------

  1813 //

  1815 TInt CEucJpDirectmapImplementation::ConvertFromUnicode(

  1817         CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,

  1819         const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,

  1821         TDes8& aForeign, const TDesC16& aUnicode,

  1823         CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)

  1825     {

  1827     TFixedArray<CnvUtilities::SCharacterSet, 6> characterSets;

  1829     characterSets[0].iConversionData = &CnvJisRoman::ConversionData();

  1831     characterSets[0].iConvertFromIntermediateBufferInPlace =

  1833         DummyConvertFromIntermediateBufferInPlace;

  1835     characterSets[0].iEscapeSequence = &KNullDesC8;

  1837     characterSets[1].iConversionData = &CnvJisX0208::ConversionData();

  1839     characterSets[1].iConvertFromIntermediateBufferInPlace =

  1841         ConvertFromJisX0208ToEucJpPackedInPlace;

  1843     characterSets[1].iEscapeSequence = &KNullDesC8;

  1845     characterSets[2].iConversionData = &CnvHalfWidthKatakana8::ConversionData();

  1847     characterSets[2].iConvertFromIntermediateBufferInPlace =

  1849         ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace;

  1851     characterSets[2].iEscapeSequence = &KNullDesC8;

  1853     characterSets[3].iConversionData = &CnvJisX0212::ConversionData();

  1855     characterSets[3].iConvertFromIntermediateBufferInPlace =

  1857         ConvertFromJisX0212ToEucJpPackedInPlace;

  1859     characterSets[3].iEscapeSequence = &KNullDesC8;

  1861     characterSets[4].iConversionData = &CnvShiftJisDirectmap::ConversionData();

  1863     characterSets[4].iConvertFromIntermediateBufferInPlace =

  1865         ConvertFromPictogaphToEucJpDirectmapInPlace;

  1867     characterSets[4].iEscapeSequence = &KNullDesC8;

  1869     characterSets[5].iConversionData = &CnvShiftJisDirectmap::ConversionData();

  1871     characterSets[5].iConvertFromIntermediateBufferInPlace =

  1873         ConvertFromPictogaphToEucJpDirectmapInPlace;

  1875     characterSets[5].iEscapeSequence = &KNullDesC8;

  1879     TInt unconvert = CnvUtilities::ConvertFromUnicode(

  1881         aDefaultEndiannessOfForeignCharacters,

  1883         aReplacementForUnconvertibleUnicodeCharacters,

  1885         aForeign, aUnicode, aIndicesOfUnconvertibleCharacters,

  1887         characterSets.Array());

  1891     return unconvert;

  1893     }

  1897 // -----------------------------------------------------------------------------

  1899 // ConvertToUnicode

  1901 // Converts from EUC-JP to Unicode.

  1903 // Returns: The number of unconverted bytes

  1905 // -----------------------------------------------------------------------------

  1907 //

  1909 TInt CEucJpDirectmapImplementation::ConvertToUnicode(

  1911         CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,

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

  1915         TInt& aNumberOfUnconvertibleCharacters,

  1917         TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)

  1919     {

  1921     TFixedArray<CnvUtilities::SMethod, 6> methods;

  1925     methods[0].iNumberOfBytesAbleToConvert =

  1927         NumberOfBytesAbleToConvertToPictograph1;

  1929     methods[0].iConvertToIntermediateBufferInPlace =

  1931         ConvertToPictographFromEucJpPackedInPlace;

  1933     methods[0].iConversionData = &CnvShiftJisDirectmap::ConversionData();

  1935     methods[0].iNumberOfBytesPerCharacter = 2;

  1937     methods[0].iNumberOfCoreBytesPerCharacter = 2;

  1939     methods[1].iNumberOfBytesAbleToConvert =

  1941         NumberOfBytesAbleToConvertToPictograph2;

  1943     methods[1].iConvertToIntermediateBufferInPlace =

  1945         ConvertToPictographFromEucJpPackedInPlace;

  1947     methods[1].iConversionData = &CnvShiftJisDirectmap::ConversionData();

  1949     methods[1].iNumberOfBytesPerCharacter = 3;

  1951     methods[1].iNumberOfCoreBytesPerCharacter = 2;

  1955     methods[2].iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvertToJisRoman;

  1957     methods[2].iConvertToIntermediateBufferInPlace =

  1959         DummyConvertToIntermediateBufferInPlace;

  1961     methods[2].iConversionData = &CnvJisRoman::ConversionData();

  1963     methods[2].iNumberOfBytesPerCharacter = 1;

  1965     methods[2].iNumberOfCoreBytesPerCharacter = 1;

  1967     methods[3].iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvertToJisX0208;

  1969     methods[3].iConvertToIntermediateBufferInPlace =

  1971         ConvertToJisX0208FromEucJpPackedInPlace;

  1973     methods[3].iConversionData = &CnvJisX0208::ConversionData();

  1975     methods[3].iNumberOfBytesPerCharacter = 2;

  1977     methods[3].iNumberOfCoreBytesPerCharacter = 2;

  1979     methods[4].iNumberOfBytesAbleToConvert =

  1981         NumberOfBytesAbleToConvertToHalfWidthKatakana8;

  1983     methods[4].iConvertToIntermediateBufferInPlace =

  1985         ConvertToHalfWidthKatakana8FromEucJpPackedInPlace;

  1987     methods[4].iConversionData = &CnvHalfWidthKatakana8::ConversionData();

  1989     methods[4].iNumberOfBytesPerCharacter = 2;

  1991     methods[4].iNumberOfCoreBytesPerCharacter = 1;

  1993     methods[5].iNumberOfBytesAbleToConvert =

  1995         NumberOfBytesAbleToConvertToJisX0212;

  1997     methods[5].iConvertToIntermediateBufferInPlace =

  1999         ConvertToJisX0212FromEucJpPackedInPlace;

  2001     methods[5].iConversionData = &CnvJisX0212::ConversionData();

  2003     methods[5].iNumberOfBytesPerCharacter = 3;

  2005     methods[5].iNumberOfCoreBytesPerCharacter = 2;

  2009     TInt unconvert = CnvUtilities::ConvertToUnicodeFromHeterogeneousForeign(

  2011         aDefaultEndiannessOfForeignCharacters, aUnicode, aForeign,

  2013         aNumberOfUnconvertibleCharacters,

  2015         aIndexOfFirstByteOfFirstUnconvertibleCharacter, methods.Array());

  2019     // The following is specific impelementation for brower.

  2021     // If brower app calls this API, the yen sign code(0xA5)

  2023     // must be converted to backslash code(0x5C).

  2025     // Becasue Javascript supports backslash code ony.

  2027     TBool browserProcess = (RProcess().SecureId().iId == KBrowserSecureId);

  2029     if (browserProcess && aUnicode.Length() > 0)

  2031         {

  2033         const TUint16* pB = aUnicode.Ptr();

  2035         const TUint16* pbase = pB;

  2037         const TUint16* pE = pB + aUnicode.Length() -1;

  2039         while (pE>=pbase)

  2041             {

  2043             if (*pbase == KCharacterCodeForYenSign)

  2045                 {

  2047                 aUnicode[pbase - pB] = KCharacterCodeForBackSlash;

  2049                 }

  2051             pbase++;

  2053             }

  2055         }

  2059     return unconvert;

  2061     }

  2065 // -----------------------------------------------------------------------------

  2067 // IsInThisCharacterSetL

  2069 // Detects whether the text is the character code or not.

  2071 // Returns: ETrue:

  2073 // -----------------------------------------------------------------------------

  2075 //

  2077 TBool CEucJpDirectmapImplementation::IsInThisCharacterSetL(TBool& /*aSetToTrue*/, TInt& /*aConfidenceLevel*/,

  2079         const TDesC8& /*aSample*/)

  2081     {

  2083     return EFalse;

  2085     }

  2089 CEucJpDirectmapImplementation* CEucJpDirectmapImplementation::NewL()

  2091     {

  2093     CEucJpDirectmapImplementation* self = new(ELeave) CEucJpDirectmapImplementation;

  2095     return self;

  2097     }

  2101 CEucJpDirectmapImplementation::CEucJpDirectmapImplementation()

  2103     {

  2105     //default constructor.. do nothing

  2107     }

  2111 CEucJpDirectmapImplementation::~CEucJpDirectmapImplementation()

  2113     {

  2115     //default destructor .. do nothing

  2117     }

  2121 // ECOM CREATION FUNCTION

  2123 const TImplementationProxy ImplementationTable[] =

  2125     {

  2127     // Note: This is the same UID as defined in old mmp-file

  2129     // Used also in 12221212.rss ( implementation_uid )

  2131     IMPLEMENTATION_PROXY_ENTRY( 0x101F86A6, CEucJpDirectmapImplementation::NewL )

  2133     };

  2137 EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

  2139     {

  2141     aTableCount = sizeof( ImplementationTable ) / sizeof(TImplementationProxy);

  2143     return ImplementationTable;

  2145     }

  2149 // End of file

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--