/*

 * Copyright (c) 2002-2008 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: 

 *

 */

 #include <f32file.h>

 #include <barsc.h> 

 #include "NumberGrouping.h"

 #include "RegularExpression.h"

 #include "cleanuputil.h"

 #include <barsread.h>

 //#include <eikenv.h>

 #include <centralrepository.h>

 #include <NumberGroupingCRKeys.h>

 const TText KNumberGroupingWildcard('n');

 const TText KNumberGroupingOneOrMoreCharactersToken('~');

 // This constant represents all the valid whitespace that we can handle. Several

 // APIs give whitespace special significance as a formatting character, especially

 // those methods used to obtain text for formatting into fixed-width UI elements

 // where spaces are not to be rendered at the margins.

 const TText KNumberGroupingSpace(' ');

 const TInt KMinimumLengthToGroup = 1; // No grouping occurs if fewer than this in unformatted buffer

 #include <numbergrouping.rsg>

 GLDEF_C void Panic(TNumberGroupingPanic aPanic)

     {

     _LIT(KPanicCat,"Number Grouping");

     User::Panic(KPanicCat, aPanic);

     }

 // Valid phone number characters apart from IsDigit() characters are listed here

 const TText KAdditionalPhoneNumberCharacters[] = {'+','#','*','p','w'};

 NONSHARABLE_CLASS(CPNGNumberGroupingExtension): public CBase

 	{

 public:

 	CPNGNumberGroupingExtension();

 	~CPNGNumberGroupingExtension();

 public:

     TInt        iMaxExtraCharacters; 

     TInt        iNumberGroupingCRValue;

     };

 CPNGNumberGroupingExtension::CPNGNumberGroupingExtension()

 	{

 	}

 CPNGNumberGroupingExtension::~CPNGNumberGroupingExtension()

 	{

 	}

 CPNGNumberGrouping::TPNGSeparator::TPNGSeparator()

     : iPosition(-1), iSeparatorCharacter(KNumberGroupingSpace)

     {

     }

 CPNGNumberGrouping::TPNGSeparator::TPNGSeparator( TInt aPosition, TText aSeparatorCharacter )

     : iPosition(aPosition), iSeparatorCharacter(aSeparatorCharacter)

     {

     }

 CPNGNumberGrouping::TPNGGroupingInfo::TPNGGroupingInfo()

     {

     }

 // CPNGNumberGrouping - grouping engine class

 CPNGNumberGrouping::CPNGNumberGrouping(TInt aMaxLength /* = 0 */, TBool aReversed /* = EFalse */) :

                                             iForceLanguage(ELangTest),

                                             iUnformattedNumberPtr(KNullDesC),

                                             iFormattedNumberPtr(KNullDesC),

                                             iReverseFormattedNumberPtr(KNullDesC),

                                             iSelectionPtr(KNullDesC),

                                             iLanguage(ELangTest),

                                             iMaxUnformattedLength(aMaxLength),

                                             iReversed(aReversed),

                                             iMatchedPatternIndex(ENoMatchedPattern)

     {

     }

 EXPORT_C CPNGNumberGrouping* CPNGNumberGrouping::NewL( TInt aMaxLength, TBool aReserved)

     {

     CPNGNumberGrouping* s = NewLC(aMaxLength, aReserved);

     CleanupStack::Pop();

     return s;

     }

 EXPORT_C CPNGNumberGrouping* CPNGNumberGrouping::NewLC( TInt aMaxLength, TBool aReserved)

     {

     CPNGNumberGrouping* s = new(ELeave)CPNGNumberGrouping( aMaxLength, aReserved);

     CleanupStack::PushL(s);

     s->ConstructL();

     return s;

     }

 void CPNGNumberGrouping::ConstructL()

     {

     iExtension = new (ELeave) CPNGNumberGroupingExtension(); 

     CRepository* repository = NULL;

     iExtension->iNumberGroupingCRValue = 0;

     TRAPD(ret, repository = CRepository::NewL(KCRUidNumberGrouping));

     if (ret == KErrNone)

         {

         ret = repository->Get(KNumberGrouping, iExtension->iNumberGroupingCRValue);

         }

     delete repository;

     // Read from resource first in order to obtain a value for iExtension->iMaxExtraCharacters

     iLanguage = doReadLanguageFromSharedData();

     doReadFormatInfoFromResourceFileL(); // This sets iExtension->iMaxExtraCharacters

     // Allocation of buffers.  Note that iMaxUnformattedLength must be retained as member

     // data because HBufCs may come back with more storage available than asked for.

     // The uncertainty in the actual length provided by the HBufCs means that although

     // they are asked to be different by iExtension->iMaxExtraCharacters, the difference between the

     // actual MaxLengths may be less than iMaxExtraCharcaters.

     // The approach decided upon is to retain iMaxUnformattedLength as member data and

     // use IT everywhere throughout this class's implementation, NEVER using

     // iUnformattedNumber->Des().MaxLength()

     iUnformattedNumber = HBufC::NewL(iMaxUnformattedLength);

     iFormattedNumber = HBufC::NewL(iMaxUnformattedLength + iExtension->iMaxExtraCharacters);

     // Create revesed buffer only if requested

     if ( iReversed )

         iReverseFormattedNumber = HBufC::NewL(iMaxUnformattedLength + iExtension->iMaxExtraCharacters);        

     }

 EXPORT_C CPNGNumberGrouping::~CPNGNumberGrouping()

     {

     doClearGroupingItemsList();

     delete iUnformattedNumber;

     delete iFormattedNumber;

     delete iReverseFormattedNumber;

     delete iRegExp;

     delete iExtension;

     }

 EXPORT_C TInt CPNGNumberGrouping::Insert(TInt aIndex, TText aChar)

     {

     if( aIndex >= 0 && aIndex <= iUnformattedNumber->Length())

         {

         if(iUnformattedNumber->Length() >= iMaxUnformattedLength)

             return KErrOverflow;

         TBuf<1> bufChar(1);

         bufChar[0] = aChar;

         TPtr ptrModifyable(iUnformattedNumber->Des());

         ptrModifyable.Insert(aIndex, bufChar);

         doClearFormattedNumbers();

         return KErrNone;

         }

     return KErrIndexOutOfRange;

     }

 EXPORT_C TInt CPNGNumberGrouping::Delete(TInt aIndex)

     {

     if(aIndex >= 0 && aIndex < iUnformattedNumber->Length())

         {

         TPtr ptrModifyable(iUnformattedNumber->Des());

         ptrModifyable.Delete(aIndex, KSingleCharacter);

         doClearFormattedNumbers();

         return KErrNone;

         }

     return KErrIndexOutOfRange;

     }

 EXPORT_C TInt CPNGNumberGrouping::Append(TText aChar)

     {

     if(iUnformattedNumber->Length() >= iMaxUnformattedLength)

         return KErrOverflow;

     TBuf<1> bufChar(1);

     bufChar[0] = aChar;

     TPtr ptrModifyable(iUnformattedNumber->Des());

     ptrModifyable.Append(bufChar);

     doClearFormattedNumbers();

     return KErrNone;

     }

 EXPORT_C TInt CPNGNumberGrouping::Set(const TDesC& aNumber)

     {

     if( aNumber.Length() > iMaxUnformattedLength )

         return KErrOverflow;

     TPtr ptrModifyable( iUnformattedNumber->Des() );

     ptrModifyable.Copy( aNumber );

     doClearFormattedNumbers();

     return KErrNone;

     }

 EXPORT_C TInt CPNGNumberGrouping::Length() const

     {

     if(!iFormattedNumber->Length()) // This test is used as the trigger to reformat

         FormattedNumber();

     return iFormattedNumber->Length();

     }

 EXPORT_C TInt CPNGNumberGrouping::UnFormattedLength() const

     {

     return iUnformattedNumber->Length();

     }

 EXPORT_C TInt CPNGNumberGrouping::MaxDisplayLength() const

     {

     // Despite its name, this method returns the max length of the UNFORMATTED buffer

     // This must not be implemented to return the actual length available in

     // iUnformattedBuffer.

     return iMaxUnformattedLength;

     }

 EXPORT_C TBool CPNGNumberGrouping::IsSpace(TInt aPos) const

     {

     // Very tricky semantics for this.  Must be a space inserted by the formatting

     if ( iFormattedNumber->Length() > aPos &&

          iFormattedNumber->operator[](aPos) == KNumberGroupingSpace &&

          // Check also that is is less than the length to group + inserted characters

          aPos < ( LengthToGroup() + (iFormattedNumber->Length() - iUnformattedNumber->Length()) ) )

         return ETrue;

     else

         return EFalse;

     }

 EXPORT_C const TDesC& CPNGNumberGrouping::FormattedNumber(TInt aFrom, TInt aTo) const

     {

     if(iUnformattedNumber->Length() != 0 &&

         aFrom >= 0 &&

         aFrom <= aTo )

         {

         FormattedNumber();

         iFormattedNumberPtr.Set(KNullDesC);

         TInt length = iFormattedNumber->Length();

         if(aTo < length + 1)

             {

             TInt length = iFormattedNumber->Length();

             if ( iExtension->iNumberGroupingCRValue )

             	{

 				// Advance to the next non-space

 				while( (aFrom < length ) && (*iFormattedNumber)[aFrom] == KNumberGroupingSpace )

 					{

 					++aFrom;

 					}

 				// Retreat to the last non-space

 				while( (aTo > 0) && (*iFormattedNumber)[aTo] == KNumberGroupingSpace )

 					{

 					--aTo;

 					}

             	}

             // Does fetching the descriptor still make sense?

             if ( (0 <= aFrom) && (aFrom <= aTo) && (aTo < length) )

                 iFormattedNumberPtr.Set( iFormattedNumber->Mid( aFrom, aTo-aFrom+1 ) );

             }

         }

     else

         {

         if(iFormattedNumber->Length())

             {

             CPNGNumberGrouping* pThis = const_cast<CPNGNumberGrouping*>(this);

             pThis->doClearFormattedNumbers();

             }

         iFormattedNumberPtr.Set(KNullDesC);

         }

     return iFormattedNumberPtr;

     }

 EXPORT_C const TDesC& CPNGNumberGrouping::FormattedNumber() const

     {

     if( !iFormattedNumber->Length() )

         {

         TInt err = KErrNone;

         CPNGNumberGrouping* pThis = const_cast<CPNGNumberGrouping*>(this);

         if( LengthToGroup() < KMinimumLengthToGroup || !iExtension->iNumberGroupingCRValue )

             {

             // This is now just a short cut, as doNumberGroupingL handles premature truncation of

             // formatting. But this avoids all the language checking

             doNumberSquashing();  // copies the unformatted number straight into the formatted number

             }

         else

             {

             TLanguage eLanguage;

             if(iForceLanguage != ELangTest)

                 eLanguage = iForceLanguage;

             else

                 eLanguage = doReadLanguageFromSharedData();

             if(eLanguage != iLanguage)

                 {

                 iLanguage = eLanguage;

                 TRAP(err, pThis->doReadFormatInfoFromResourceFileL());

                 if(err != KErrNone)

                     {

                     iFormattedNumberPtr.Set(KNullDesC);

                     return iFormattedNumberPtr;

                     }

                 }

             TRAP(err, doNumberGroupingL());

             }

         if(err != KErrNone)

             pThis->doClearFormattedNumbers();

         else

             iFormattedNumberPtr.Set(iFormattedNumber->Ptr(), iFormattedNumber->Length());

         }

     return iFormattedNumberPtr;

     }

 EXPORT_C const TDesC& CPNGNumberGrouping::ReverseFormattedNumber(TInt aFrom, TInt aTo) const

     {

     if ( iReversed )

         {

         if(iUnformattedNumber->Length() != 0 &&

             aFrom >= 0 &&

             aFrom <= aTo)

             {

             ReverseFormattedNumber();

             iReverseFormattedNumberPtr.Set(KNullDesC);

             TInt length = iReverseFormattedNumber->Length();

             if( aTo < length + 1 )

                 {

                 // Advance to the next non-space

                 if( iExtension->iNumberGroupingCRValue )

                 	{

 					while( (aFrom < length ) && (*iReverseFormattedNumber)[aFrom] == KNumberGroupingSpace )

 						{

 						++aFrom;

 						}

 					// Retreat to the last non-space

 					while( (aTo > 0) && (*iReverseFormattedNumber)[aTo] == KNumberGroupingSpace )

 						{

 						--aTo;

 						}

                 	}

                 // Does fetching the descriptor still make sense?

                 if ( (0 <= aFrom) && (aFrom <= aTo) && (aTo < length) )

                     iReverseFormattedNumberPtr.Set(

                         iReverseFormattedNumber->Mid( aFrom, aTo-aFrom+1) );

                 }

             }

         else

             iReverseFormattedNumberPtr.Set(KNullDesC);

         }

     return iReverseFormattedNumberPtr; // Zero initialized at construction

     }

 EXPORT_C const TDesC& CPNGNumberGrouping::ReverseFormattedNumber() const

     {

     if( iReverseFormattedNumber && !iReverseFormattedNumber->Length())

         {

         if(!iFormattedNumber->Length())

             FormattedNumber();

         TInt nLength = iFormattedNumber->Length();

         TPtr ptrModifyable(iReverseFormattedNumber->Des());

         TBuf<1> bufChar(1);

         for(TInt i = nLength; i > 0; --i)

             {

             TText cChar = (*iFormattedNumber)[i-1];

             bufChar[0] = cChar;

             ptrModifyable.Insert(nLength - i, bufChar);

             }

         iReverseFormattedNumberPtr.Set(iReverseFormattedNumber->Ptr(), nLength);

         }

     return iReverseFormattedNumberPtr;

     }

 EXPORT_C const TDesC& CPNGNumberGrouping::Selection(TInt aFrom, TInt aTo) const

     {

     if(aFrom < iUnformattedNumber->Length())

         {

         TPtr ptrUnformatted = iUnformattedNumber->Des();

         iSelectionPtr.Set(&(ptrUnformatted[aFrom]), aTo - aFrom);

         }

     else

         iSelectionPtr.Set(KNullDesC);

     return iSelectionPtr;

     }

 EXPORT_C const TDesC&   CPNGNumberGrouping::UnFormattedNumber(TInt aFrom, TInt aTo) const

     {

     if (iUnformattedNumber && aFrom >= 0 && aFrom <= aTo && aTo < iUnformattedNumber->Length())

         {

         iUnformattedNumberPtr.Set(&((*iUnformattedNumber)[aFrom]), aTo - aFrom + 1);

         }

     else

         {

         iUnformattedNumberPtr.Set(KNullDesC);

         }

     return iUnformattedNumberPtr;

     }

 EXPORT_C const TDesC& CPNGNumberGrouping::UnFormattedNumber() const

     {

     return UnFormattedNumber(0, iUnformattedNumber->Length() - 1);

     }

 TLanguage CPNGNumberGrouping::doReadLanguageFromSharedData() const

     {    

     if (iExtension->iNumberGroupingCRValue)

         {

         return ELangAmerican;

         }

     else

         {

         return ELangTest;

         }

     }

 void CPNGNumberGrouping::doClearFormattedNumbers()

     {

     TPtr ptrModifyable( iUnformattedNumber->Des() );

     for (TInt index = 0; index < ptrModifyable.Length(); index++)

         {

         TChar ch = TChar(ptrModifyable[index]);

         ch.Fold( TChar::EFoldDigits | TChar::EFoldSpaces);

         }

     iFormattedNumber->Des().Zero();

     iFormattedNumberPtr.Set(KNullDesC);

     if ( iReverseFormattedNumber )

         iReverseFormattedNumber->Des().Zero();

     iReverseFormattedNumberPtr.Set(KNullDesC);

     iMatchedPatternIndex = ENoMatchedPattern;

     }

 void CPNGNumberGrouping::doReadFormatInfoFromResourceFileL()

     {

     doClearGroupingItemsList();

     delete iRegExp;

     iRegExp = NULL;

     RPointerArray<TDesC> parrGroupingPatternsList;

     CleanupResetAndDestroyPushL(parrGroupingPatternsList);

     TInt maxExtraCharacters(0);

     RFs fs;

     CleanupClosePushL(fs);

     if(fs.Connect() == KErrNone)

         {

         RResourceFile resourceFile;

         CleanupClosePushL(resourceFile);

         resourceFile.OpenL(fs, _L("z:\\resource\\numbergrouping.rsc"));

         HBufC8* bufResource = resourceFile.AllocReadL(R_GROUPING_MAPPING);

         TResourceReader resourceReader;

         resourceReader.SetBuffer(bufResource);

         TInt    nLanguageCount = resourceReader.ReadInt8();

         TBool   bLanguageMatches = EFalse;

         while(nLanguageCount-- || !bLanguageMatches)

             {

             TBool bLanguageMatches = (resourceReader.ReadInt8() == iLanguage);

             if(bLanguageMatches || ((nLanguageCount == -1) && !bLanguageMatches))

                 {

                 TInt nGroupingSchemeCount = resourceReader.ReadInt8();

                 while(nGroupingSchemeCount--)

                     {

                     TInt thisMaxExtraCharacters(0);

                     ReadGroupingSchemeL(

                         resourceReader, parrGroupingPatternsList, thisMaxExtraCharacters );

                     // take this new max extra characters if bigger

                     maxExtraCharacters = Max( maxExtraCharacters, thisMaxExtraCharacters );

                     }

                 break; // This breaks out because we take the first language that matches

                 } // End of if on language/locale test

             else  // skip other locales

                 {

                 TInt nGroupingSchemeCount = resourceReader.ReadInt8();

                 while(nGroupingSchemeCount--)

                     {

                     SkipGroupingSchemeL( resourceReader );

                     }

                 }

             }

         delete bufResource;

         resourceFile.Close();

         CleanupStack::Pop();  // resource file

         }

     fs.Close();

     CleanupStack::Pop();  // file system

     iExtension->iMaxExtraCharacters = maxExtraCharacters; // Latch the high water mark of extra characters

     iRegExp = CRegularExpression::NewL(&parrGroupingPatternsList);

     CleanupStack::PopAndDestroy(&parrGroupingPatternsList);  // patterns list

     }

 void CPNGNumberGrouping::doNumberGroupingL() const

     {

     TInt lengthToGroup = LengthToGroup();

     if ( lengthToGroup >= KMinimumLengthToGroup )

         {

         TInt matchedPattern = KErrNotFound;

         TInt newMatchedPattern = KErrNotFound;

         // Search for matches in the RegExp object. It returns the next matching pattern

         // However, even if there is a match, lengthToGroup may not be in the deployment

         // length range between minDigits and MaxDigits, inclusive

         do  {

             // Check for another matching pattern

             newMatchedPattern = iRegExp->SearchFrom( newMatchedPattern+1, *iUnformattedNumber);

             if( newMatchedPattern != KErrNotFound) // Found a match, but it is OK?

                 {

                 TInt minDigits = iGroupingItemsList[newMatchedPattern]->iMinNumberOfDigits;

                 TInt maxDigits = iGroupingItemsList[newMatchedPattern]->iMaxNumberOfDigits;

                 // Fill in sensible values for min and max if not present

                 if(minDigits == -1)

                     minDigits = 0;

                 if(maxDigits == -1)

                     maxDigits = lengthToGroup;

                 if ( minDigits <= lengthToGroup && lengthToGroup <= maxDigits )

                     {

                     matchedPattern = newMatchedPattern; // accept this new pattern

                     break;

                     }

                 }

             } while ( newMatchedPattern != KErrNotFound  );

         // Actually go and do the grouping

         if ( matchedPattern != KErrNotFound )

             {

             doNumberGroupingForPatternL( matchedPattern, lengthToGroup );

             return;

             }

         }

     // if we get to here, either the string was not matched to any of the patterns or the

     // unformatted string is exactly the display length.  In either case we call

     // doNumberSquashing() which simply leaves the string as it is...

     doNumberSquashing();

     }

 void CPNGNumberGrouping::doNumberGroupingForPatternL( TInt aMatchingPattern, TInt aLengthToGroup ) const

     {

     iMatchedPatternIndex = aMatchingPattern;

     TInt nLowPos = 0;

     TInt nHighPos = 0;

     TPtr desUnformattedNumber = iUnformattedNumber->Des();

     TInt unformattedLength = iUnformattedNumber->Length();

     __ASSERT_ALWAYS( aLengthToGroup <= unformattedLength , Panic(ENumberGroupingBadLengthToGroup) );

     TPNGGroupingInfo* matchedPattern = iGroupingItemsList[iMatchedPatternIndex];

     TInt nAfterCount = matchedPattern->iAfterPositions.Count();

     TBool bBeforePosition = (matchedPattern->iBeforePosition.iPosition == -1)?0:1;

     // Test to see if the beforePosition can be used with the current text length.

     // The following does not allow the before position to be used if it would result in an

     // insertion right next to one from the AfterPositions.

     // That is, tildas in the formatting string represent 1 or more characters.

     // e.g. if the last afterPosition is 4 and the before position is 3, then a 7 digit

     // number will not be able to have the before position used.

     if( nAfterCount &&

         (unformattedLength - matchedPattern->iBeforePosition.iPosition) <=

         matchedPattern->iAfterPositions[nAfterCount - 1].iPosition)

         {

         bBeforePosition = EFalse;

         }

     TPtr ptrModifyable(iFormattedNumber->Des());

     for(TInt i  = 0; i < nAfterCount && nHighPos < aLengthToGroup ; ++i)

         {

         nHighPos = matchedPattern->iAfterPositions[i].iPosition;

         if ( nHighPos >= aLengthToGroup )

             break;

         if(nHighPos < unformattedLength)

             {

             ptrModifyable.Append( desUnformattedNumber.Mid( nLowPos, nHighPos - nLowPos) );

             ptrModifyable.Append(matchedPattern->iAfterPositions[i].iSeparatorCharacter);

             nLowPos = nHighPos;

             }

         }

     // Do not do "before end" formatting at all if there is any truncation

     if ( aLengthToGroup < unformattedLength )

         {

         TInt nBeforePosition = matchedPattern->iBeforePosition.iPosition;

         if(bBeforePosition && nBeforePosition < unformattedLength)

             {

             nHighPos = unformattedLength - nBeforePosition;

             ptrModifyable.Append( desUnformattedNumber.Mid( nLowPos, nHighPos - nLowPos) );

             ptrModifyable.Append( matchedPattern->iBeforePosition.iSeparatorCharacter );

             nLowPos = nHighPos;

             }

         }

     nHighPos = unformattedLength;

     ptrModifyable.Append( desUnformattedNumber.Mid( nLowPos, nHighPos - nLowPos) );

     }

 void CPNGNumberGrouping::doNumberSquashing() const

     {

     __ASSERT_ALWAYS( !iFormattedNumber->Length(), Panic(ENumberGroupingFormattedNumberAlreadyExists) );

     // just copy from one t'other...

     TPtr ptrModifyable(iFormattedNumber->Des());

     ptrModifyable.Copy(*iUnformattedNumber);

     iMatchedPatternIndex = ENoMatchedPattern;

     }

 void CPNGNumberGrouping::doClearGroupingItemsList()

     {

     TInt nCount = iGroupingItemsList.Count();

     for(TInt i = 0; i < nCount; ++i)

         {

         iGroupingItemsList[i]->iAfterPositions.Close();

         delete iGroupingItemsList[i];

         iGroupingItemsList[i] = NULL;

         }

     iGroupingItemsList.Close();

     }

 void CPNGNumberGrouping::ReadGroupingSchemeL(

     TResourceReader& aResourceReader,

     RPointerArray<TDesC>& aGroupingPatternsList,

     TInt& aMaxExtraCharacters )

     {

     CleanupResetAndDestroyPushL(aGroupingPatternsList);

     TPNGGroupingInfo* groupingInfo = new (ELeave) TPNGGroupingInfo;

     CleanupStack::PushL( groupingInfo );

     // Read in all resource for this grouping scheme, perform checking and then analyze it

     HBufC* initialDigits = aResourceReader.ReadHBufCL();

     __ASSERT_ALWAYS( initialDigits, Panic( ENumberGroupingNoInitialDigitsInResource ) );

     CleanupStack::PushL( initialDigits );

     groupingInfo->iMinNumberOfDigits = aResourceReader.ReadInt8();

     groupingInfo->iMaxNumberOfDigits = aResourceReader.ReadInt8();

     __ASSERT_DEBUG(

         ( groupingInfo->iMaxNumberOfDigits == -1) ||

         ( groupingInfo->iMinNumberOfDigits <= groupingInfo->iMaxNumberOfDigits ),

         Panic( ENumberGroupingBadMinMaxDigitRangeInResource ) );

     // Read in formatting Pattern

     HBufC* formatPattern = aResourceReader.ReadHBufCL();

     if ( formatPattern ) // Does not have to be there

         {

         CleanupStack::PushL( formatPattern );

         TInt formatLength = formatPattern->Length();

         if ( formatLength > 0 )

             {

             // Obtain a wildcard version of the matching pattern in initialDigits.

             // This is used to check the supplied formatPattern for comformance to initialDigits

             HBufC* wildcardedMatchBuf = HBufC::NewLC( formatLength ); // Will not be longer than the search pattern

             TPtr wildcardedMatchPtr( wildcardedMatchBuf->Des() );

             // Get the example number using the latest search pattern only

             GetWildcardVersionOfMatchStringL( *initialDigits, KNumberGroupingWildcard, wildcardedMatchPtr );

             // Now parse the descriptor

             TBool trailingPossible(EFalse);

             ParseForAfterPositions(

                 *formatPattern, groupingInfo, wildcardedMatchPtr, aMaxExtraCharacters, trailingPossible );

             // Now parse the descriptor from the end if needed

             if ( trailingPossible )

                 ParseForBeforePosition( *formatPattern, groupingInfo, aMaxExtraCharacters );

             CleanupStack::PopAndDestroy( wildcardedMatchBuf );

             }

         CleanupStack::PopAndDestroy( formatPattern );

         } // End of if on formatPattern.Length

     User::LeaveIfError( aGroupingPatternsList.Append( initialDigits ) );

     CleanupStack::Pop( initialDigits );

     // Do not leave if the next one fails, but remove the last from the patterns list and then leave

     // This is done in case someone TRAPs. Otherwise neither of these lists would be used and their

     // mismatch would not be a problem

     if ( TInt err = iGroupingItemsList.Append(groupingInfo) != KErrNone )

         {

         // return value of Count will be at least 1, because we have just successfully gone through an Append

         aGroupingPatternsList.Remove( aGroupingPatternsList.Count() - 1 );

         // ownership is now mine again...

         delete initialDigits;

         // Need to delete groupingInfo, and make sure it is no longer on the cleanupstack

         CleanupStack::PopAndDestroy( groupingInfo );

         User::Leave(err);

         }

     else

         {

         CleanupStack::Pop( groupingInfo ); // Success. This object now not owned by the cleanupstack

         }

     CleanupStack::Pop(&aGroupingPatternsList);

     }

 void CPNGNumberGrouping::ParseForAfterPositions(

     const TDesC& aFormatPattern,

     TPNGGroupingInfo* aGroupingInfo,

     const TDesC& aWildcardedMatchingPattern,

     TInt& aMaxExtraCharacters,

     TBool& trailingPossible ) const

     {

     TInt pos(0); // Keeps track of the position with which the next separator will be stored

     TInt formatLength = aFormatPattern.Length();

     for (TInt index = 0; index < formatLength; index++ )

         {

         // The format pattern is compared with the matching pattern.  The matching pattern may be

         // shorter than the format pattern, so by default a wildcard character is used.

         TText ch = aFormatPattern[index];

         TText matchingChar(KNumberGroupingWildcard); // default to expect is the wildcard character

         if ( pos < aWildcardedMatchingPattern.Length() ) // if still within the matching pattern

             matchingChar = aWildcardedMatchingPattern[pos];

         if ( ch == matchingChar )

             pos++; // not a separator. index where the next "after" marker goes

         else if ( ch == KNumberGroupingOneOrMoreCharactersToken )

             {

             // finish looking for "afterPositions". But there may be a "before" position in the

             // remainder, so set the flag

             trailingPossible = ETrue;

             break;

             }

         else

             {

             // Explicit prevention of any separator characters being valid phone numbers

 #ifdef _DEBUG

             if ( IsValidPhoneNumberCharacter( ch ) || ch == KNumberGroupingWildcard )

                 {

                 RDebug::Print(

                     _L("NumberGrouping: Illegal character or format mismatch in resource: initialDigits pattern= <%S> formatPattern=<%S>"),

                     &aWildcardedMatchingPattern, &aFormatPattern );

                 }

 #endif

             __ASSERT_DEBUG( !IsValidPhoneNumberCharacter( ch ), Panic( ENumberGroupingInvalidSeparatorCharacterInFormat ) );

             __ASSERT_DEBUG( ch != KNumberGroupingWildcard, Panic( ENumberGroupingMatchingPatternVersusFormatPatternMismatch ) );

             TPNGSeparator separator( pos, aFormatPattern[index]);

             aGroupingInfo->iAfterPositions.Append(separator);

             aMaxExtraCharacters++;

             }

         }

     }

 void CPNGNumberGrouping::ParseForBeforePosition(

     const TDesC& aFormatPattern,

     TPNGGroupingInfo* aGroupingInfo,

     TInt& aMaxExtraCharacters ) const

     {

     TInt pos=0;

     TInt formatLength = aFormatPattern.Length();

     for (TInt index = formatLength-1; index >=0; index-- )

         {

         TText ch = aFormatPattern[index];

         if ( ch == KNumberGroupingWildcard )

             pos++;

         else if ( ch == KNumberGroupingOneOrMoreCharactersToken )

             break;

         else

             {

             // Explicit prevention of any separator characters being valid phone numbers

 #ifdef _DEBUG

             if ( IsValidPhoneNumberCharacter( ch ) )

                 {

                 RDebug::Print(

                     _L("NumberGrouping: Illegal character in trailing part of format string in resource: formatPattern=<%S>"),

                     &aFormatPattern );

                 }

 #endif

             __ASSERT_DEBUG( !IsValidPhoneNumberCharacter( ch ),

                 Panic( ENumberGroupingInvalidSeparatorCharacterInFormat ) );

             TPNGSeparator separator( pos, ch );

             aGroupingInfo->iBeforePosition = separator;

             aMaxExtraCharacters++;

             break;

             }

         }

     }

 void CPNGNumberGrouping::SkipGroupingSchemeL( TResourceReader& aResourceReader ) const

     {

     HBufC* tempBuf;

     tempBuf = aResourceReader.ReadHBufCL();

     delete tempBuf;

     aResourceReader.Advance(2); // min and max characters

     tempBuf = aResourceReader.ReadHBufCL();

     delete tempBuf;

     }

 void CPNGNumberGrouping::GetWildcardVersionOfMatchStringL(

     const TDesC& aMatchString,

     TText aWildcard,

     TDes& aWildcardMatchString ) const

     {

     RPointerArray<TDesC> patternList;

     CleanupClosePushL(patternList);

     // Make a copy of the input string

     HBufC* matchString = aMatchString.AllocLC();

     User::LeaveIfError( patternList.Append(matchString) );// takes ownership

     CleanupStack::Pop( matchString );

     CRegularExpression* regExp = CRegularExpression::NewLC(&patternList);

     // Only 1 pattern fed in.  Access that pattern at index 0

     regExp->GetWildcardVersionOfPattern( 0 , aWildcard, aWildcardMatchString );

     CleanupStack::PopAndDestroy(regExp);

     // Delete the patterns list

     delete patternList[0];

     CleanupStack::PopAndDestroy();

     }

 EXPORT_C TBool CPNGNumberGrouping::IsCharacterInsertedByNumberGrouping(TInt aPos) const

     {

     TInt insertedCharacters = Length() - UnFormattedLength();

     if( insertedCharacters == 0 ) // no formatting was done

         return EFalse;

     else if ( aPos < ( insertedCharacters + LengthToGroup() ) )

         {

         return !IsValidPhoneNumberCharacter( (*iFormattedNumber)[aPos] );

         }

     else // aPos is pointing at or beyond index= LengthToGroup() + <chars inserted>; no formatting there

         return EFalse;

     }

 TBool CPNGNumberGrouping::IsValidPhoneNumberCharacter( TText aCharacter ) const

     {

     if ( ((TChar)aCharacter).IsDigit() )

         return ETrue;

     // Check through the list of additional valid phone number characters

     TInt numAdditionalChars = sizeof( KAdditionalPhoneNumberCharacters )/sizeof(TText);

     for (TInt index = 0; index < numAdditionalChars; index++)

         {

         if ( aCharacter == KAdditionalPhoneNumberCharacters[index] )

             return ETrue;

         }

     return EFalse;

     }

 EXPORT_C TBool CPNGNumberGrouping::IsChangedByGrouping() const

     {

     // The only way that grouping is effectively different is by making things longer

     return ( Length() > UnFormattedLength() );

     }

 TInt CPNGNumberGrouping::LengthToGroup() const

     {

     TPtrC ptr = iUnformattedNumber->Des();

     TInt lengthToGroup = ptr.Length();

     // Find the first non-digit

     for (TInt index = 0; index < ptr.Length(); index++)

         {

         TChar ch = TChar(ptr[index]);

         ch.Fold(TChar::EFoldDigits);

         if ( !( ch.IsDigit() ) )

             {

             lengthToGroup = index; // only characters BEFORE the character at index are grouped

             break;

             }

         }

     return lengthToGroup;

     }

 // End of File