/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "TXTSTD.H"

#include "ParseLst.h"

//++ sort out definitive hash includes

CParserList::CParserItem::CParserItem(MParser* aParser, const TUint aTagIndex)

: iParser(aParser),

  iTagIndex(aTagIndex)

	{

	}

// Panic the process with UikParse as the category.

void CParserList::Panic(TParserListPanic aPanic) const

	{

	_LIT(panicStr, "ParseLst");

	User::Panic(panicStr, aPanic);

	}

CParserList::CParserList()

: iParserList(4)

	{

	iHighestIndex = 0;

	iNumberInList = 0;

	}

CParserList::~CParserList()

	{

	iParserList.ResetAndDestroy();	// Reset the list and destroy the CParserItems

	iParserList.Close();			// but leave the parsers and free the resources

	}

// Add parser to appropriate list

void CParserList::ActivateAParserL(MParser* aParser, const TBool aDefaultParser)

	{

	// Check the index isn't rolling over

	// N.B. This is somewhat unlikely. Since index is effectively a 29-bit

	// uint (I'm using the top 3 bits as flags) this allows 268435456 parsers

	// to be installed. (Assuming we deinstall almost as many, as we went

	// along, to avoid OOM.) At 50 per sec that's 20 years continuous action!

	__ASSERT_DEBUG((iHighestIndex < EMaxParserIndex), Panic(EParserIndexRollover));

	__ASSERT_DEBUG(aParser, Panic(EParserNullPtr));

	TUint parserIndex = iHighestIndex + 1;

	// Adjust flags to describe parser

	if (aParser->ReformatOnRecognise())

		parserIndex |= static_cast<TUint>( EReformatOnRecogniseFlag );

	if (aParser->ReformatOnRollover())

		parserIndex |= EReformatOnRolloverFlag;

	if (aDefaultParser)

		parserIndex |= EDefaultParserFlag;

	// Create a parser item

	TInt result;

	CParserItem* parserItem = new (ELeave) CParserItem(aParser, parserIndex);

	++iHighestIndex;

	if (aDefaultParser)

		{

		CleanupStack::PushL(parserItem);

		result = iParserList.Append(parserItem);

		if (result) // We couldn't get it in the main list

			User::Leave(result);

		CleanupStack::Pop();

		}

	else

		{

		// Look for the end of the specific parsers and the start of the default set

		TInt count;

		for (count = 0; count < iNumberInList; count++)

			{

			if (DefaultParser(iParserList[count]->TagIndex()))

				break;

			}

		CleanupStack::PushL(parserItem);

		result = iParserList.Insert(parserItem, count);

		if (result) // We couldn't get it in the main list

			User::Leave(result);

		CleanupStack::Pop();

		}

	iNumberInList++;

	}

// Activate an individual parser

void CParserList::ActivateParserL(MParser* aParser)

	{

	ActivateAParserL(aParser, EFalse);

	}

// N.B. We can't just delete CParserList and zero TLS when we get back

// to a list with no specific or default parsers because there could be

// an EText left with a local ptr to it.

void CParserList::DeactivateParser(MParser* aParser)

	{

	__ASSERT_DEBUG(iNumberInList, Panic(EParserNoneActive));

	__ASSERT_DEBUG(aParser, Panic(EParserNullPtr));

	// Run thru list till find entry we need

	TInt count;

	for (count = 0; count < iNumberInList; count++)

		{

		if (iParserList[count]->Parser() == aParser)

			{

			delete iParserList[count];

			iParserList.Remove(count);

			break;

			}

		}

	__ASSERT_DEBUG((count < iNumberInList), Panic(EParserInstanceNotActive));

	iNumberInList--;

	}

// Activate a parser as one of the default set

void CParserList::ActivateDefaultParserL(MParser* aParser)

	{

	ActivateAParserL(aParser, ETrue);

	}

//++ Put comment here

void CParserList::DeactivateParserDefaults()

	{

	if (iNumberInList)

		{

		// Take them out of the list

		while (iNumberInList && DefaultParser(iParserList[iNumberInList - 1]->TagIndex()))

			{

			// Tell the parser to free itself

			iParserList[iNumberInList - 1]->Parser()->Release();

			// Delete the item that refers to it

			delete iParserList[iNumberInList - 1];

			// Remove the entry from the list

			iParserList.Remove(iNumberInList - 1);

			iNumberInList--;

			}

		}

	}

// Called by EText to scan an area of text

TBool CParserList::ParseThisText(CRichText& aTextObj,TInt aStartScan,TInt aScanLength,TInt& aStartOfTags,TInt& aLength)

	{

	TBool foundSomething = EFalse;

	TCharFormatX format;

	TCharFormatXMask varies;

	TPtrC ptr;

	TInt endRange;

	// Scan either side of the range in case part of some tagged text was deleted.

	if (aStartScan > 0)

		{

		aStartScan--;

		aScanLength++;

		}

	if (aStartScan + aScanLength < aTextObj.DocumentLength())

		aScanLength++;

	if (iNumberInList && aScanLength)

		{

		aStartOfTags = aStartScan + aScanLength;

		aLength = 0;

		for (TInt count = 0; count < iNumberInList; count++)

			{

			// For each parser in the list

			TUint tagIndex = iParserList[count]->TagIndex();

			TInt pos;

			MParser* parser = iParserList[count]->Parser();

			TInt localStartScan = aStartScan;

			TInt localScanLength = aScanLength;

			// Start by removing existing tags for this parser. This ensures

			// that old tags that have been invalidated by subsequent editing

			// are removed. Any that are still valid will be replaced.

			aTextObj.GetExtendedCharFormat(format, varies, localStartScan, aScanLength);

			if (format.iParserTag || varies.AttribIsSet(EAttParserTag))

				{

				// At least some of the object contains a non-zero tag - go through it

				// Are we starting part way through a tag?

				aTextObj.GetExtendedCharFormat(format, varies, localStartScan, 1);

				if (format.iParserTag == tagIndex)

					{

					// The first char of this range has the current parsers tag

					// so we need to check backwards for the start of that tag

					for (pos = localStartScan; pos > 0; pos--)

						{

						aTextObj.GetExtendedCharFormat(format, varies, pos - 1, 1);

						if (format.iParserTag != tagIndex)

							break;

						}

					// Since we are going to remove a tag starting from here

					// we need to allow this area to be rescanned

					localScanLength += localStartScan - pos;

					localStartScan = pos;

					}

				// What about off the end?

				aTextObj.GetExtendedCharFormat(format, varies, localStartScan + localScanLength - 1, 1);

				if (format.iParserTag == tagIndex)

					{

					// The last char of this range has the current parsers tag

					// so we need to check forwards for the end of that tag

					pos = localStartScan + localScanLength;

					TInt end = aTextObj.DocumentLength();

					while (pos < end)

						{

						aTextObj.GetTextAndExtendedFormat(ptr, format, pos);

						if (format.iParserTag != tagIndex)

							break;

						pos += ptr.Length();

						}

					// Adjust scan length

					localScanLength = pos - localStartScan;

					}

				pos = localStartScan;

				while (pos < localStartScan + localScanLength)

					{

					// Run along the scan range

					aTextObj.GetTextAndExtendedFormat(ptr, format, pos);

					if (format.iParserTag == tagIndex)

						{

						// Remove this tag

						format.iParserTag = 0;

						varies.ClearAll();

						varies.SetAttrib(EAttParserTag);

						TRAPD(leaveCode, aTextObj.ApplyExtendedCharFormatL(format, varies, pos, ptr.Length()));

						if (leaveCode==KErrNone)

							foundSomething = ETrue;	// We are removing a tag

						if (aLength)

							{

							if (pos < aStartOfTags)

								{

								aLength += aStartOfTags - pos;

								aStartOfTags = pos;

								}

							if (pos + ptr.Length() > aStartOfTags + aLength)

								aLength = pos + ptr.Length() - aStartOfTags;

							}

						else

							{

							aStartOfTags = pos;

							aLength = ptr.Length();

							}

						}

					pos += ptr.Length();

					}

				}

			endRange = localStartScan + localScanLength;

			// For this parser, run through text looking for changes

			TBool allowBack = ETrue;

			for (;;)	// Run forever

				{

				TInt localStartTag = aTextObj.DocumentLength();

				TInt localTagLength = 0;

				TInt result = parser->ParseThisText(aTextObj, allowBack, localStartScan, localScanLength, localStartTag, localTagLength);

				if (!result)

					break;

				__ASSERT_DEBUG(allowBack || (localStartTag >= localStartScan), Panic(EParserIgnoringAllowFlag));

				TInt startNewTag = localStartTag;

				TInt lengthNewTag = localTagLength;

				aTextObj.GetExtendedCharFormat(format, varies, localStartTag, localTagLength);

				if (format.iParserTag || varies.AttribIsSet(EAttParserTag))

					{

					// At least some of this area contains a non-zero tag - go through it

					pos = localStartTag;

					TBool higher = EFalse;

					while (pos < localStartTag + localTagLength)

						{

						aTextObj.GetTextAndExtendedFormat(ptr, format, pos);

						if (format.iParserTag && (MaskedTag(format.iParserTag) < MaskedTag(tagIndex)))

							{

							// A higher precedence tag is already here so we can't

							// insert our tag - let's see how far it goes

							TUint tag = format.iParserTag;	// Stash tag before overwriting it

							TInt len = aTextObj.DocumentLength();

							while (pos < len)

								{

								aTextObj.GetTextAndExtendedFormat(ptr, format, pos);

								if (format.iParserTag != tag)

									break;

								pos += ptr.Length();

								}

							result = EFalse;

							startNewTag = pos;

							lengthNewTag = 0;

							break;

							}

						// If there aren't any higher precedence tags in here then this

						// will save us having to go through again if there aren't any

						// lower precedence tags either

						if (MaskedTag(format.iParserTag) >= MaskedTag(tagIndex))

							higher = ETrue;

						pos += ptr.Length();

						}

					if (higher)

						{

						// There are lower or equal precedence tags in this range

						// Do they extend back off the start?

						aTextObj.GetExtendedCharFormat(format, varies, localStartTag, 1);

						if (format.iParserTag)

							{

							// need to check backwards

							TUint tag = format.iParserTag;	// Stash tag before overwriting it

							for (pos = localStartTag; pos > 0; pos--)

								{

								aTextObj.GetExtendedCharFormat(format, varies, pos - 1, 1);

								if (format.iParserTag != tag)

									break;

								}

							localTagLength += localStartTag - pos;

							localStartTag = pos;

							}

						// What about off the end?

						pos = localStartTag + localTagLength;

						aTextObj.GetExtendedCharFormat(format, varies, pos - 1, 1);

						if (format.iParserTag)

							{

							// need to check forwards

							TUint tag = format.iParserTag;	// Stash tag before overwriting it

							TInt len = aTextObj.DocumentLength();

							while (pos < len)

								{

								aTextObj.GetTextAndExtendedFormat(ptr, format, pos);

								if (format.iParserTag != tag)

									break;

								pos += ptr.Length();

								}

							localTagLength = pos - localStartTag;

							}

						// Remove all tags in this area - they all have lower precedence

						format.iParserTag = 0;

						varies.ClearAll();

						varies.SetAttrib(EAttCharLanguage);

						TRAPD(leaveCode, aTextObj.ApplyExtendedCharFormatL(format, varies, localStartTag, localTagLength));

						if (leaveCode==KErrNone)

							foundSomething = ETrue;	// We are removing a tag

						}

					}

				if (result)

					{

					// Format tag this area with tagIndex

					format.iParserTag = tagIndex;

					varies.ClearAll();

					varies.SetAttrib(EAttParserTag);

					// Use the original length, not the possibly expanded version

					TRAPD(leaveCode, aTextObj.ApplyExtendedCharFormatL(format, varies, startNewTag, lengthNewTag));

					if (leaveCode==KErrNone)

						foundSomething = ETrue;		// We are applying a tag

					if (aLength)

						{

						if (localStartTag < aStartOfTags)

							{

							aLength += aStartOfTags - localStartTag;

							aStartOfTags = localStartTag;

							}

						if (localStartTag + localTagLength > aStartOfTags + aLength)

							aLength = localStartTag + localTagLength - aStartOfTags;

						}

					else

						{

						aStartOfTags = localStartTag;

						aLength = localTagLength;

						}

					}

				// Jump over

				localScanLength -= startNewTag + lengthNewTag - localStartScan;

				localStartScan = startNewTag + lengthNewTag;	// Adjust start of next scan run

				if (localStartScan >= endRange)	// Have we reached the end of the range yet?

					break;

				allowBack = EFalse;

				}

			}

		}

	return foundSomething;

	}

// given a tag, fetch a ptr to the parser - or null

MParser* CParserList::ParserWithThisTag(const TUint aTagIndex) const

	{

	MParser* parser = NULL;

	for (TInt count = 0; count < iNumberInList; count++)

		{

		if (aTagIndex == iParserList[count]->TagIndex())

			{

			parser = iParserList[count]->Parser();

			break;

			}

		}

	return parser;

	}

// given a ptr to a parser, fetch a tag - or zero

TUint CParserList::TagForThisParser(const MParser *const aParser) const

	{

	TUint tagIndex = 0;

	for (TInt count = 0; count < iNumberInList; count++)

		{

		if (aParser == iParserList[count]->Parser())

			{

			tagIndex = iParserList[count]->TagIndex();

			break;

			}

		}

	__ASSERT_DEBUG(tagIndex, Panic(EParserNoSuchTag));

	return tagIndex;

	}

CParserData::CParserData(TInt aEndParse):

	iStartParse(0),

	iEndParse(aEndParse)

	{

	// Get parser data

	iActiveParserList = (CParserList*)Dll::Tls();

	iLastKnownCursor = -1;

	if (iActiveParserList)

		iActiveParserList->iRefCount++;

	}

CParserData::~CParserData()

	{

	if (iActiveParserList)

		{

		iActiveParserList->iRefCount--;

		if ((iActiveParserList->iRefCount == 0) && (iActiveParserList->iNumberInList == 0))

			{

			Dll::FreeTls();

			delete iActiveParserList;

			}

		}

	}

// Merge the specified range, which may have changed length, into the current range.

// aOldLength is the # of chars deleted and to be removed from the range

// aNewLength is the # of chars inserted and to be added to the range

void CParserData::MergeRange(TInt aStart,TInt aOldLength,TInt aNewLength)

	{

	if (iStartParse == -1) // no current range

		{

		iStartParse = aStart;

		iEndParse = aStart + aNewLength;

		}

	else

		{

		if (aStart < iStartParse)

			iStartParse = aStart;

		if (aStart + aOldLength > iEndParse)

			iEndParse = aStart + aOldLength;

		iEndParse += aNewLength - aOldLength;

		}

	}