/*

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

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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: 

 *     A utility for providing Japanese Language-specific (UNICODE) functions.

 *

 *

 */

 // INCLUDES FILES

 #include "jplangutil.h"

 #include "jplangutil.tables.h"

 // LOCAL DEFINES

 // LOCAL CONSTANTS AND ENUMS

 #if defined(_DEBUG)

 _LIT( KJPLangUtilPanic, "JPLangUtil" );

 enum TJPLangUtilPanicCodes

     {

     EErrNotKatakana = 0x777,

     EErrNotVoicedKatakana

     };

 #endif

 enum TConvDirection

     {

     EHalfToFullWidth,

     EFullToHalfWidth

     };

 const TInt KHalfWidthKatakanaRange = 59;

 const TInt KHalfWidthIndex = 0;

 const TInt KFullWidthIndex = 1;

 const TInt KFullWidthVoicableKatakanaRange = 23;

 const TInt KFullWidthSemiVoicableKatakanaRange = 5;

 const TInt KHalfWidthSpecialCharRange = 21;

 const TText KHalfWidthKatakanaVoicedSoundMark     = 0xff9e;

 const TText KHalfWidthKatakanaSemiVoicedSoundMark = 0xff9f;

 // The following Full-width (semi-)voiced markers are

 // *also* considered Hiragana, per Unicode spec.

 const TText KFullWidthKatakanaVoicedSoundMark     = 0x309b;

 const TText KFullWidthKatakanaSemiVoicedSoundMark = 0x309c;

 const TText KHalfWidthKatakanaLowerBound = 0xff65;

 const TText KHalfWidthKatakanaUpperBound = 0xff9f;

 const TText KFullWidthKatakanaLowerBound = 0x30a0;

 const TText KFullWidthKatakanaUpperBound = 0x30ff;

 const TText KCJKUnifiedIdiographLowerBound = 0x4e00;

 const TText KCJKUnifiedIdiographUpperBound = 0x9fa5;

 const TText KCJKUnifiedIdeographExtALowerBound = 0x3400;

 const TText KCJKUnifiedIdeographExtAUpperBound = 0x4dbf;

 const TText KHalfToFullWidthASCIIOffset = 0xfee0;

 const TText KHalfWidthASCIILowerBound = 0x0021; // Leaves out space (0x0020)

 const TText KHalfWidthASCIIUpperBound = 0x007e;

 const TText KFullWidthASCIILowerBound = 0xff01;

 const TText KFullWidthASCIIUpperBound = 0xff5e;

 const TUint KFullWidthHiraganaSmallA = 0x3041;

 const TUint KFullWidthHiraganaVU = 0x3094;

 const TUint KFullWidthHiraganaU = 0x3046;

 const TUint KFullWidthHiraganaVoicedSound = 0x309B;

 const TUint KFullWidthKatakanaSmallA = 0x30a1;

 const TUint KFullWidthKatakanaSmallVU = 0x30F4;

 // ============================== LOCAL CLASSES ================================

 /**

  *  This is an internal utility class used by the JPLangUtil class

  *  and is intended for encapsulation only.

  *

  *  @lib JPLangUtil.lib

  *  @since 2.6

  */

 class UnicodeTextUtil

     {

     public: // Query Functions

         /**

         * Determines if aUnicodeChar is a base Katakana that is capable

         * of being converted into either a Vioced or Semi-voiced Full-width

         * Katakana character.

         * If aSemiVoiced is true, then the check is only performed

         * for Semi-voiced conversion capability.

         *

         * @param aUnicodeChar The character to be tested.

         * @param aSemiVoiced  Whether or not the character is to be tested

         *                     as convertable to a Semi-voiced Full-width

         *                     Katakana, rather than just voiced.

         *

         * @return ETrue is the character is in fact convertable to either

         *         a voiced or semi-voiced fullwidth katakana character,

         *         depending on the aSemiVoiced flag.

         */

         static TBool IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                              ( TText aUnicodeChar, TBool aSemiVoiced = EFalse );

         /**

         * Determines if aUnicodeChar is a  Vioced or Semi-voiced Full-width

         * Katakana character.

         * If aSemiVoiced is true, then the check is only performed

         * for Semi-voiced.

         *

         * @param aUnicodeChar The character to be tested.

         * @param aSemiVoiced  Whether or not the character is a Semi-voiced

         *                     Full-width Katakana, rather than just voiced.

         *

         * @return ETrue is the character is in fact a voiced or semi-voiced

         *         fullwidth katakana character, depending on the aSemiVoiced

         *         flag.

         */

         static TBool IsFullWidthVoicedKatakana( TText aUnicodeChar,

                                                 TBool aSemiVoiced = EFalse);

     public: // Conversion Functions

         /**

         * Converts one Katakana character from either Half to Full-width

         * or vice versa, depending on the direction specified by aDirection

         *

         * @param aDirection Direction to convert.

         * @param aKatakanaChar The character to convert.

         *

         * @return The opposite width Katakana character.

         */

         static TChar ConvertKatakanaChar( TConvDirection aDirection,

                                           TText aKatakanaChar );

         /**

         * Converts one voiced Katakana character from either Half to Full-width

         * or vice versa, depending on the direction specified by aDirection,

         * and appends the converted character to the descriptor aTarget.

         * In the case that it is from Full to Half-width, it is necessary to

         * convert it into a base-katakana + (semi-)voiced mark pair, thus

         * the necessity for passing in the TDes reference return type.

         * In the case of converting from Half to Full-width, it is only

         * necessary to pass in a base-katakana that has a (semi-)voiced

         * Full-width counterpart.

         *

         * @param aDirection Direction to convert.

         * @param aVoicedKatakana The character to convert.

         * @param aTarget The descriptor to append the converted character(s) to.

         * @param aSemiVoiced ETrue if performing a Semi-voiced conversion.

         *                    Default is EFalse.

         */

         static void ConvertVoicedKatakanaCharAndAppendToTarget(

                                                    TConvDirection aDirection,

                                                    TText aVoicedKatakana,

                                                    TDes& aTarget,

                                                    TBool aSemiVoiced = EFalse );

         /**

         * Converts all special characters *in-place* from either Half to

         * Full-width or vice versa, depending on the direction specified

         * by aDirection

         *

         * @param aDirection Direction to convert.

         * @param aUnicodeText The character to convert.

         *

         * @return The number of converted special characters.

         */

         static TInt ConvertSpecialCharactersInPlace( TConvDirection aDirection,

                                                      TDes16& aUnicodeText );

         /**

         * Converts all ASCII *in-place* from either Half to

         * Full-width or vice versa, depending on the direction specified

         * by aDirection

         *

         * @param aDirection Direction to convert.

         * @param aUnicodeText The character to convert.

         *

         * @return The number of converted ASCII-range characters.

         */

         static TInt ConvertASCIIInPlace( TConvDirection aDirection,

                                          TDes16& aUnicodeText );

     };

 // ============================= LOCAL FUNCTIONS ===============================

 // -----------------------------------------------------------------------------

 // UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

 // Determines if aUnicodeChar is a base Katakana that is capable

 // of being converted into either a Vioced or Semi-voiced

 // Full-width character.

 // If aSemiVoiced is true, then the check is only performed

 // for Semi-voiced conversion capability.

 // Returns: ETrue if it is convertable.

 // -----------------------------------------------------------------------------

 //

 TBool UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                                        ( TText aUnicodeChar, TBool aSemiVoiced )

     {

     if( aSemiVoiced )

         {

         return ( aUnicodeChar >= 0xff8a && aUnicodeChar <= 0xff8e );

         }

     else

         {

         return ( ( aUnicodeChar == 0xff73 ) ||

                  ( aUnicodeChar >= 0xff76 && aUnicodeChar <= 0xff7f ) ||

                  ( aUnicodeChar >= 0xff80 && aUnicodeChar <= 0xff84 ) ||

                  ( aUnicodeChar >= 0xff8a && aUnicodeChar <= 0xff8e ) ||

                  ( aUnicodeChar == 0xff9c ) ||

                  ( aUnicodeChar == 0xff66 ) );

         }

     }

 // -----------------------------------------------------------------------------

 // UnicodeTextUtil::IsFullWidthVoicedKatakana

 // Determines if aUnicodeChar is Full-width Katakana.

 // Returns: ETrue if it is Full-width Katakana.

 // -----------------------------------------------------------------------------

 //

 TBool UnicodeTextUtil::IsFullWidthVoicedKatakana( TText aUnicodeChar,

                                                   TBool aSemiVoiced )

     {

     const TInt voicableRange( aSemiVoiced ?

                               KFullWidthSemiVoicableKatakanaRange :

                               KFullWidthVoicableKatakanaRange );

     const TText* const (*voicedTable) = aSemiVoiced ?

                               KHalfWidthBaseToFullWidthSemiVoicedKatakanaTable :

                               KHalfWidthBaseToFullWidthVoicedKatakanaTable;

     for( TInt i( 0 ); i < voicableRange; ++i )

         {

         if( aUnicodeChar == voicedTable[i][KFullWidthIndex] )

             {

             return ETrue;

             }

         }

     return EFalse;

     }

 // -----------------------------------------------------------------------------

 // UnicodeTextUtil::ConvertKatakanaChar

 // Converts one Katakana Char in the direction specified by aDirection.

 // Assumes aKatakanaChar is within range.

 // Returns: A TText containing either the varient character or the character

 //          itself, in the case there is no conversion.

 // -----------------------------------------------------------------------------

 //

 TChar UnicodeTextUtil::ConvertKatakanaChar( TConvDirection aDirection,

                                             TText aKatakanaChar )

     {

     __ASSERT_DEBUG(

         JPLangUtil::IsKatakana( aKatakanaChar ) &&

         !IsFullWidthVoicedKatakana( aKatakanaChar ),

         User::Panic( KJPLangUtilPanic, EErrNotKatakana )

     );

     TChar convChar( aKatakanaChar );

     const TInt directionIndex( ( aDirection == EHalfToFullWidth ) ?

                                    KHalfWidthIndex : KFullWidthIndex );

     for( TInt i( 0 ); i < KHalfWidthKatakanaRange; ++i )

         {

         if( aKatakanaChar ==

                 KHalfToFullWidthKatakanaCharTable[i][directionIndex] )

             {

             convChar = KHalfToFullWidthKatakanaCharTable[i][!directionIndex];

             break;

             }

         }

     return convChar;

     }

 // -----------------------------------------------------------------------------

 // UnicodeTextUtil::ConvertVoicedKatakanaChar

 // Converts one Voiced Katakana Char in the direction specified by aDirection,

 // and appends to the descriptor, aTarget.

 // If aSemiVoiced is ETrue, then the code point is converted to the Semi-voiced

 // variant.

 // Assumes aVoicedKatakana is within range.

 // -----------------------------------------------------------------------------

 //

 void UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget(

                                                       TConvDirection aDirection,

                                                       TText aVoicedKatakana,

                                                       TDes& aTarget,

                                                       TBool aSemiVoiced )

     {

     __ASSERT_DEBUG(

         IsFullWidthVoicedConvertableHalfWidthBaseKatakana( aVoicedKatakana ) ||

         IsFullWidthVoicedKatakana( aVoicedKatakana, aSemiVoiced ),

         User::Panic( KJPLangUtilPanic, EErrNotVoicedKatakana )

     );

     const TInt  voicableRange( aSemiVoiced ?

                                KFullWidthSemiVoicableKatakanaRange :

                                KFullWidthVoicableKatakanaRange );

     const TText* const (*voicedTable) = aSemiVoiced ?

                               KHalfWidthBaseToFullWidthSemiVoicedKatakanaTable :

                               KHalfWidthBaseToFullWidthVoicedKatakanaTable;

     if( aDirection == EHalfToFullWidth )

         {

         // In the case of Half Width, only the base character is needed for

         // the conversion

         for( TInt i( 0 ); i < voicableRange; ++i )

             {

             if( aVoicedKatakana == voicedTable[i][KHalfWidthIndex] )

                 {

                 const TChar uniChar( voicedTable[i][KFullWidthIndex] );

                 aTarget.Append( uniChar );

                 break;

                 }

             }

         }

     else

         {

         for( TInt i( 0 ); i < voicableRange; ++i )

             {

             if( aVoicedKatakana == voicedTable[i][KFullWidthIndex] )

                 {

                 const TChar uniChar( voicedTable[i][KHalfWidthIndex] );

                 aTarget.Append( uniChar );

                 break;

                 }

             }

         const TChar voicedSoundMark( aSemiVoiced ?

                                      KHalfWidthKatakanaSemiVoicedSoundMark :

                                      KHalfWidthKatakanaVoicedSoundMark );

         aTarget.Append( voicedSoundMark );

         }

     }

 // -----------------------------------------------------------------------------

 // UnicodeTextUtil::ConvertSpecialCharactersInPlace

 // Converts all special characters in the aUnicodeText descriptor in-place

 // that have both Full and Half-width variants.

 // Conversion occurs in the direction specified by aDirection.

 // Returns: The total number of characters converted.

 // -----------------------------------------------------------------------------

 //

 TInt UnicodeTextUtil::ConvertSpecialCharactersInPlace

                              ( TConvDirection aDirection, TDes16& aUnicodeText )

     {

     TInt totalConverted( 0 );

     const TInt directionIndex( ( aDirection == EHalfToFullWidth ) ?

                                  KHalfWidthIndex : KFullWidthIndex );

     for( TInt i( 0 ); i < aUnicodeText.Length(); ++i )

         {

         const TText uniChar( aUnicodeText[i] );

         for( TInt j( 0 ); j < KHalfWidthSpecialCharRange; ++j )

             {

             if( uniChar == KHalfToFullWidthSpecialCharTable[j][directionIndex] )

                 {

                 aUnicodeText[i] =

                     KHalfToFullWidthSpecialCharTable[j][!directionIndex];

                 totalConverted++;

                 break;

                 }

             }

         }

     return totalConverted;

     }

 // -----------------------------------------------------------------------------

 // UnicodeTextUtil::ConvertASCIIInPlace

 // Converts all ASCII *in-place* from either Half to Full-width or vice versa,

 // depending on the direction specified by aDirection.

 // Returns: The total number of characters converted.

 // -----------------------------------------------------------------------------

 //

 TInt UnicodeTextUtil::ConvertASCIIInPlace( TConvDirection aDirection,

                                            TDes16& aUnicodeText )

     {

     TInt totalConverted( 0 );

     TText lowerBound( ( aDirection == EHalfToFullWidth ) ?

                         KHalfWidthASCIILowerBound :

                         KFullWidthASCIILowerBound );

     TText upperBound( ( aDirection == EHalfToFullWidth ) ?

                         KHalfWidthASCIIUpperBound :

                         KFullWidthASCIIUpperBound );

     TInt offset( ( aDirection == EHalfToFullWidth ) ?

                    KHalfToFullWidthASCIIOffset :

                    -KHalfToFullWidthASCIIOffset );

     for( TInt i( 0 ); i < aUnicodeText.Length(); ++i )

         {

         const TText uniChar( aUnicodeText[i] );

         if( uniChar >= lowerBound && uniChar <= upperBound )

             {

             TText convertedChar( static_cast<TText>( uniChar + offset ) );

             aUnicodeText[i] = convertedChar;

             totalConverted++;

             }

         }

     return totalConverted;

     }

 // EXPORTED FUNCTIONS

 // ============================ MEMBER FUNCTIONS ===============================

 // -----------------------------------------------------------------------------

 // JPLangUtil::ConvertHalfToFullWidth

 // Converts all Half-width conformant text (including ASCII, Special Characters

 // and Katakana) found in aUnicodeSource to their Full-width counterparts and

 // places the resulting text into aUnicodeTarget.

 // (detailed information about the parameters and return values can be found

 //  in the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TInt JPLangUtil::ConvertHalfToFullWidth( const TDesC16& aUnicodeSource,

                                                   TDes16& aUnicodeTarget )

     {

     TInt totalConverted( 0 );

     // Special Characters are handled in the Katakana conversion...

     totalConverted =  ConvertHalfToFullWidthKatakana( aUnicodeSource,

                                                       aUnicodeTarget );

     totalConverted += UnicodeTextUtil::ConvertASCIIInPlace( EHalfToFullWidth,

                                                             aUnicodeTarget );

     return totalConverted;

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::ConvertFullToHalfWidth

 // Converts all Full-width conformant text found in aUnicodeSource to their

 // Full-width counterparts and places the resulting text into aUnicodeTarget.

 // Only those characters with existing Half-width variants are converted. There

 // will be a 2-for-1 conversion for each Full-width Voiced and Semi-voiced

 // Katakana character.

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TInt JPLangUtil::ConvertFullToHalfWidth( const TDesC16& aUnicodeSource,

                                                   TDes16& aUnicodeTarget )

     {

     TInt totalConverted( 0 );

     // Special Characters are handled in the Katakana conversion...

     totalConverted =  ConvertFullToHalfWidthKatakana( aUnicodeSource,

                                                       aUnicodeTarget );

     totalConverted += UnicodeTextUtil::ConvertASCIIInPlace( EFullToHalfWidth,

                                                             aUnicodeTarget );

     return totalConverted;

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::ConvertHalfToFullWidthKatakana

 // Converts Half-width Katakana and Special Character text found in

 // aUnicodeSource to their Full-width counterparts and places the resulting text

 // into aUnicodeTarget.

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TInt JPLangUtil::ConvertHalfToFullWidthKatakana

                        ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget )

     {

     TInt totalConverted( 0 );

     const TInt length( aUnicodeSource.Length() );

     if( length > aUnicodeTarget.MaxLength() )

         {

         return KErrTooBig;

         }

     aUnicodeTarget.Zero();

     for( TInt i( 0 ); i < length; ++i )

         {

         const TText uniChar( aUnicodeSource[i] );

         // Check if the next character is a Half Width Katakana (Semi-)Voiced

         // Sound Mark and if the current character + the voiced sound mark have

         // a Full Width counterpart

         if( i + 1 < length )

             {

             const TBool isVoiced(

             ( UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                   ( uniChar ) &&

               ( aUnicodeSource[i + 1] == KHalfWidthKatakanaVoicedSoundMark )

             ) );

             const TBool isSemiVoiced(

             ( UnicodeTextUtil::IsFullWidthVoicedConvertableHalfWidthBaseKatakana

                   ( uniChar, ETrue ) &&

               ( aUnicodeSource[i + 1] == KHalfWidthKatakanaSemiVoicedSoundMark )

             ) );

             if( isVoiced || isSemiVoiced )

                 {

                 UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget(

                     EHalfToFullWidth,

                     uniChar,

                     aUnicodeTarget,

                     isSemiVoiced

                 );

                 i++; // Skip the (semi-)voice marker

                 totalConverted++;

                 continue;

                 }

             }

         // If not, then just convert directly if in range

         if( uniChar >= KHalfWidthKatakanaLowerBound &&

             uniChar <= KHalfWidthKatakanaUpperBound )

             {

             aUnicodeTarget.Append(

                 UnicodeTextUtil::ConvertKatakanaChar( EHalfToFullWidth,

                                                       uniChar )

             );

             totalConverted++;

             }

         // Else this is not Half Width Katakana, so copy directly...

         else

             {

             const TChar uniCharacter( uniChar );

             aUnicodeTarget.Append( uniCharacter );

             }

         }

     // Now handle special characters

     // This logic may be moved into this function to avoid another

     // loop over the text.

     totalConverted +=

         UnicodeTextUtil::ConvertSpecialCharactersInPlace( EHalfToFullWidth,

                                                           aUnicodeTarget );

     return totalConverted;

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::ConvertFullToHalfWidthKatakana

 // Converts Full-width Katakana and Special Character text found in

 // aUnicodeSource to their Half-width counterparts and places the resulting text

 // into aUnicodeTarget. There will be a 2-for-1 conversion for each Full-width

 // Voiced and Semi-voiced Katakana character.

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TInt JPLangUtil::ConvertFullToHalfWidthKatakana

                        ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget )

     {

     TInt totalConverted( 0 );

     const TInt length( aUnicodeSource.Length() );

     const TInt maxLength( aUnicodeTarget.MaxLength() );

     if( length > maxLength )

         {

         return KErrTooBig;

         }

     aUnicodeTarget.Zero();

     for( TInt i( 0 ); i < length; ++i )

         {

         const TText uniChar( aUnicodeSource[i] );

         // First check if this is this Full Width Katakana

         if( ( uniChar >= KFullWidthKatakanaLowerBound &&

               uniChar <= KFullWidthKatakanaUpperBound ) ||

             ( uniChar == KFullWidthKatakanaVoicedSoundMark ||

               uniChar == KFullWidthKatakanaSemiVoicedSoundMark ) )

             {

             // Then check if it is (Semi-)Voiced and convert it properly

             const TBool isVoiced(

                 UnicodeTextUtil::IsFullWidthVoicedKatakana( uniChar )

             );

             const TBool isSemiVoiced(

                 UnicodeTextUtil::IsFullWidthVoicedKatakana( uniChar, ETrue )

             );

             if( isVoiced || isSemiVoiced )

                 {

                 if( aUnicodeTarget.Length() + 2 > maxLength )

                     {

                     // This descriptor can't hold the new data

                     aUnicodeTarget.Zero();

                     return KErrTooBig;

                     }

                 UnicodeTextUtil::ConvertVoicedKatakanaCharAndAppendToTarget(

                     EFullToHalfWidth,

                     uniChar,

                     aUnicodeTarget,

                     isSemiVoiced

                 );

                 totalConverted++;

                 }

             else

                 {

                 if( aUnicodeTarget.Length() + 1 > maxLength )

                     {

                     // This descriptor can't hold the new data

                     aUnicodeTarget.Zero();

                     return KErrTooBig;

                     }

                 aUnicodeTarget.Append(

                     UnicodeTextUtil::ConvertKatakanaChar(

                         EFullToHalfWidth,

                         uniChar

                     )

                 );

                 totalConverted++;

                 }

             }

         // This is not Full Width Katakana, so copy directly...

         else

             {

             if( aUnicodeTarget.Length() + 1 > maxLength )

                 {

                 // This descriptor can't hold the new data

                 aUnicodeTarget.Zero();

                 return KErrTooBig;

                 }

             const TChar uniCharacter( uniChar );

             aUnicodeTarget.Append( uniCharacter );

             }

         }

     // Now handle special characters

     // This logic may be moved into this function to avoid another loop over

     // the text

     totalConverted +=

         UnicodeTextUtil::ConvertSpecialCharactersInPlace( EFullToHalfWidth,

                                                           aUnicodeTarget );

     return totalConverted;

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::ConvertFullHiragnaToFullKatakana

 // Converts Full-width Hiragana and Special Character text found in

 // aUnicodeSource to their Full-width counterparts and places the

 // resulting text into aUnicodeTarget.

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TInt JPLangUtil::ConvertFullHiragnaToFullKatakana

                        ( const TDesC16& aUnicodeSource, TDes16& aUnicodeTarget )

     {

     TInt totalConverted( 0 );

     const TInt length( aUnicodeSource.Length() );

     const TInt maxLength( aUnicodeTarget.MaxLength() );

     if( length > maxLength )

         {

         return KErrTooBig;

         }

     const TUint comp = KFullWidthKatakanaSmallA - KFullWidthHiraganaSmallA;

     aUnicodeTarget.Zero();

     for( TInt i( 0 ); i < length; ++i )

         {

         const TText uniChar( aUnicodeSource[i] );

         TText uniChar2(0);

         if (i + 1 < length)

             {

             uniChar2 = aUnicodeSource[i+1];

             }

         // First check if this is this Full Width Katakana

         if (KFullWidthHiraganaSmallA <= uniChar && uniChar <= KFullWidthHiraganaVU)

             {

             if (uniChar == KFullWidthHiraganaU

              && uniChar2 == KFullWidthHiraganaVoicedSound)

                 {

                 aUnicodeTarget.Append(KFullWidthKatakanaSmallVU);

                 totalConverted++;

                 i++;

                 }

             else

                 {

                 TUint katakana = uniChar + comp;

                 if (IsKatakana(katakana))

                     {

                     aUnicodeTarget.Append(katakana);

                     totalConverted++;

                     }

                 }

             }

         else

             {

             aUnicodeTarget.Append(uniChar);

             totalConverted++;

             }

         }

     // Now handle special characters

     // This logic may be moved into this function to avoid another loop over

     // the text

     totalConverted +=

         UnicodeTextUtil::ConvertSpecialCharactersInPlace( EFullToHalfWidth,

                                                           aUnicodeTarget );

     return totalConverted;

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::IsKatakana

 // Determines whether or not the character is Katakana

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TBool JPLangUtil::IsKatakana( const TText aUnicodeChar )

     {

     return ( ( aUnicodeChar >= KFullWidthKatakanaLowerBound &&

                aUnicodeChar <= KFullWidthKatakanaUpperBound ) ||

              ( aUnicodeChar >= KHalfWidthKatakanaLowerBound &&

                aUnicodeChar <= KHalfWidthKatakanaUpperBound ) ||

              ( aUnicodeChar == KFullWidthKatakanaVoicedSoundMark ||

                aUnicodeChar == KFullWidthKatakanaSemiVoicedSoundMark ) );

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::IsHiragana

 // Determines whether or not the character is Hiragana

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TBool JPLangUtil::IsHiragana( const TText aUnicodeChar )

     {

     return ( ( aUnicodeChar >= 0x3041 && aUnicodeChar <= 0x3096 ) ||

              ( aUnicodeChar >= 0x3099 && aUnicodeChar <= 0x309f ) );

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::IsKanji

 // Determines whether or not the character is a CJK Unified Ideograph (ExtA)

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TBool JPLangUtil::IsKanji( const TText aUnicodeChar )

     {

     return( ( aUnicodeChar >= KCJKUnifiedIdiographLowerBound &&

               aUnicodeChar <= KCJKUnifiedIdiographUpperBound ) ||

             ( aUnicodeChar >= KCJKUnifiedIdeographExtALowerBound &&

               aUnicodeChar <= KCJKUnifiedIdeographExtAUpperBound ) );

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::IsHalfWidth

 // Determines whether or not the character is UNICODE defined Half-width.

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TBool JPLangUtil::IsHalfWidth( const TText aUnicodeChar )

     {

     return // HW Katakana

            ( ( aUnicodeChar >= 0xff61 && aUnicodeChar <= 0xff9f ) ||

            // ASCII

              ( aUnicodeChar >= 0x0020 && aUnicodeChar <= 0x007e ) ||

            // Special Characters

              ( aUnicodeChar == 0x00a2 || aUnicodeChar == 0x00a3 ||

                aUnicodeChar == 0x00a5 || aUnicodeChar == 0x00a6 ||

                aUnicodeChar == 0x00a9 || aUnicodeChar == 0x00ac ||

                aUnicodeChar == 0x00af || aUnicodeChar == 0x2985 ||

                aUnicodeChar == 0x2986 ) ||

            // HW Symbol Variants

              ( aUnicodeChar >= 0xffe8 && aUnicodeChar <= 0xffee ) );

     }

 // -----------------------------------------------------------------------------

 // JPLangUtil::IsFullWidth

 // Determines whether or not the character is UNICODE defined Full-width.

 // Essentially, all code values that are not Half-width.

 // (detailed information about the parameters and return values can be found in

 // the header file)

 // -----------------------------------------------------------------------------

 //

 EXPORT_C TBool JPLangUtil::IsFullWidth( const TText aUnicodeChar )

     {

         return !IsHalfWidth( aUnicodeChar );

     }

 // End of File