/*

* Copyright (c) 1997-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 "../incp/T_PMLPAR.H"

#define UNUSED_VAR(a) a = a

#define UNUSED_VAR(a) a = a

////////////////////////////////////////////

// CParser

////////////////////////////////////////////

CParser* CParser::NewL()

	{

	CParser* self=new(ELeave) CParser;

	CleanupStack::PushL(self);

	self->ConstructApplicationL();

	CleanupStack::Pop();

	return self;

	}

CParser::CParser()

	{

	// init variables

	iErrorLevel = ENoError;			

	iParagraphIsOpen = EFalse;	

	iLineNo = 1;

	iReadPos = 0;

	iDocInsertPos = 0;

	iDocParaLength = 0;

	iDocPhraseLength = 0;

	iBorderUsed = EFalse;

	iBulletUsed = EFalse;

	}

void CParser::ConstructApplicationL()

	{ 

	// Construct Rich Text Doc

	// Make the global format layers and associated formats and masks

	iGlobalParaFormatLayer=CParaFormatLayer::NewL();

	iGlobalCharFormatLayer=CCharFormatLayer::NewL();

	iGlobalParaFormat=CParaFormat::NewL();	   	// initialised with factory settings

	iGlobalParaFormatMask.SetAll();

	iGlobalCharFormatMask.SetAll();

	// Set the global layers

	iGlobalParaFormatLayer->SetL(iGlobalParaFormat,iGlobalParaFormatMask);

	iGlobalCharFormatLayer->SetL(iGlobalCharFormat, iGlobalCharFormatMask);

	// Create the rich text document

	iRichTextDoc=CRichText::NewL(iGlobalParaFormatLayer,iGlobalCharFormatLayer);

	// Initialise the paragraph and character layers

	iParaFormatLayer = CParaFormatLayer::NewL();

	iCharFormatLayer = CCharFormatLayer::NewL();

	iParaFormat = CParaFormat::NewL();

	// Create temp alias' for compound attributes

	iBorder = new TParaBorder;

	User::LeaveIfNull(iBorder);

	iBullet = new (ELeave) TBullet;

	}

CParser::~CParser()

	{

	// destroy Rich Text Document

// 	delete iRichTextDoc;

//	delete iGlobalParaFormatLayer;

//	delete iGlobalCharFormatLayer;

	delete iGlobalParaFormat;

	delete iParaFormatLayer;

	delete iCharFormatLayer;

	delete iParaFormat;

	if (!iBorderUsed)

		delete(iBorder);

	if (!iBulletUsed)

		delete(iBullet);

	}

CRichText* CParser::ParseL(CConsoleBase* aConsole)

// version for parsing with console output and interactive file dialog

// primarily for debugging purposes (you can see what's going on!)

	{

	// set console

	iConsoleExists = ETrue;

	iConsole = aConsole;

	// Construct a CFileApp & load a file

	CFileApp* myFileApp=NULL;

	TRAPD(ret, myFileApp = CFileApp::NewL());

    UNUSED_VAR(ret);

	iTextBuf = myFileApp->LoadFileL(iConsole);

	iFileName = myFileApp->ReturnFileName();

	ParseTextBufL();	   			// parse the buffer

	delete myFileApp;	// destroy file app

	// Pause before returning

	WriteNewLine();

	WriteNewLine();

	OutputToScreen(_L("Press Space to continue\n"));

	TKeyCode keystroke = EKeyNull;

	while (keystroke != EKeySpace)

		keystroke = iConsole->Getch();

	return iRichTextDoc;

	}

CRichText* CParser::ParseL(const TFileName &aFileName)

// silent version of the parser

	{

	iConsoleExists = EFalse;

	// Construct a CFileApp & load a file

	CFileApp* myFileApp=NULL;

	TRAPD(ret, myFileApp = CFileApp::NewL());

    UNUSED_VAR(ret);

	iTextBuf = myFileApp->LoadFileL(aFileName);

	iFileName = myFileApp->ReturnFileName();

	ParseTextBufL();	   			// parse the buffer

	delete myFileApp;	// destroy file app

	return iRichTextDoc;

	}

void CParser::EmitErrorMessage()

	{

	TBuf<80> errorMessage;

	switch (iErrorLevel)

		{

		case EUnknownTagType:

			errorMessage.Format(_L("    Unknown tag type: Line %d"),iLineNo);

			break;

		case EUnparagraphedText:

			errorMessage.Format(_L("    Text not contained by paragraph: Line %d"),iLineNo);

			break;

		case EUnknownAttrib:

			errorMessage.Format(_L("    Unknown tag attribute: Line %d"),iLineNo);

			break;

		case ENoAttribValue:

			errorMessage.Format(_L("    Unknown attribute or no attribute value supplied: Line %d"),iLineNo);

			break;

		case EIllegalAttribValue:

			errorMessage.Format(_L("    Illegal attribute value: Line %d"),iLineNo);

			break;

		default:

			errorMessage.Format(_L("    Error: Line %d"),iLineNo);

			break;

		}

	OutputToScreen(_L(""));

	OutputToScreen(_L("*** Error!!\n"));

	OutputToScreen(errorMessage);

	}

void CParser::OutputToScreen(const TDesC& aMessageBuffer)

	{

	if (iConsoleExists)

		iConsole->Write(aMessageBuffer);  // output line to screen

	}

TBool CParser::Validate()

// Check that document starts with <G> tag - serves as file validation

//  - Read in characters sequentially

//  - if the first alphanumeric characters encountered are not "<G" then error

	{

	TBool fileFormatError = EFalse;

	TBool fileValidated = EFalse;

	TChar charToTest;

	while ((!fileFormatError)&&(!fileValidated))

		{					

		charToTest = ReadChar();

		if (charToTest == '<')

			{

			iReadPos+=KCharLength;

			charToTest = ReadTagChar();

			if (charToTest != 'G')			 // Not a style tag - error

				fileFormatError = ETrue;

			else

				fileValidated = ETrue;

			}

		else

			{

			if (charToTest.IsAlphaDigit())	 // Char is alphanumeric - error

				fileFormatError = ETrue;	 // (File must start with style tag)

			else

				iReadPos+=KCharLength;

			}

		}

	if (fileFormatError)

		{

		OutputToScreen(_L("File format error\n"));

		}

	iReadPos = 0;		// reset after validation

	iLineNo = 1;		// ...

	return fileValidated;

	}

void CParser::ParseTextBufL()

// Parses contents of iTextBuf

// Reads in chars sequentially.

// - If a char is a tag open ("<") process the following tag

// - otherwise add the char to the text of the rich text document

// Tidy up at the end of the document 

	{ 

	TChar charToTest;

	TUint textBufSize = iTextBuf->Size();

	if (Validate())

		{

		while ((iReadPos < textBufSize)&&(iErrorLevel == ENoError))

			{

			charToTest = ReadChar();

			if (charToTest == '<')

				ProcessTagL();

			else

				ProcessTextL(charToTest);

			iReadPos+=KCharLength;						

			}

		if ((iReadPos == textBufSize)&&(iReadPos>0)&&(iErrorLevel == ENoError))

			{

			// at end of document apply any outstanding formatting (if there is text to apply it to)

			if (iDocParaLength > 0)

				{

				iParaFormatLayer->SetL(iParaFormat, iParaFormatMask);

				iRichTextDoc->ApplyParaFormatL( iParaFormat,iParaFormatMask,iDocInsertPos-iDocParaLength,iDocParaLength);

				}

			if (iDocPhraseLength > 0)

				{

				iCharFormatLayer->SetL(iCharFormat, iCharFormatMask);

				iRichTextDoc->ApplyCharFormatL(iCharFormat,iCharFormatMask,iDocInsertPos-iDocPhraseLength,iDocPhraseLength);

				}

			}

		if (iErrorLevel != ENoError)

			EmitErrorMessage();

		}

	}

TChar CParser::ReadChar()

// Reads the next character from the text buffer

	{

// 	TChar charToTest;

	TText charToTest;

	iTextBuf->Read(iReadPos,&charToTest,KCharLength);

	if (charToTest == (TText)KLineFeed)

		iLineNo++;				   	// Info used only by error messages

	return charToTest;

	}

void CParser::ProcessTextL(TChar aChar)

// 1) Check text is in a paragraph

// 2) Check for escape characters

// 3) Check for tabs

// 4) Add to paragraph

	{

	if (!iParagraphIsOpen)

		{

		if (!(aChar.IsControl()))

			iErrorLevel = EUnparagraphedText;	// Text not contained by a paragraph - error!!

		}

	else

		{

		if (aChar == '/')	// Escape character for <

			{

			TChar tempChar;

			iTextBuf->Read(iReadPos+KCharLength,&tempChar,1);	// doesn't increment line counter

			if (tempChar == '<')

				{

				AddCharToParaL(tempChar);

				iReadPos+=2*KCharLength;				  	// Skip escape character

				}

			else

				AddCharToParaL(aChar);

			}

		else if (aChar == KTabChar)

			AddCharToParaL(aChar);

		else if (!(aChar.IsControl()))		// if it's not a control char add it 

			AddCharToParaL(aChar);			//		(this includes spaces)

		}

	}

void CParser::AddCharToParaL(TChar aChar)

	{ 

	// Add char to RichText doc...

	iRichTextDoc->InsertL(iDocInsertPos, aChar);

	iDocInsertPos++;

	iDocParaLength++;

	if (iPhraseOpen)

		iDocPhraseLength++;

	// and also write it to screen

	TBuf<4> screenBuf;				// Buffer for text to be written to console

	screenBuf.Append(aChar);		

	OutputToScreen(screenBuf);

	}

void CParser::ProcessTagL()

	{

	TChar tagChar;

	iReadPos+=KCharLength;

	tagChar = ReadTagChar();	  	// Read in tag type

	ClassifyTagL(tagChar);		  	

	if (iTagType == EError)

		iErrorLevel = EUnknownTagType;

	else

		{

		ClassifyArgumentsL();

		}

	}

TChar CParser::ReadTagChar()

	{ // Returns tag character capitalised - therefore case-insensitive

 	TChar charToTest;

	charToTest = ReadChar();

	charToTest.UpperCase();

	return charToTest;

	}

void CParser::ClassifyArgumentsL()

// reads tag one argument at a time, dealing with each arg as it is read

// If and argument is followed by a value (ie a=4) it is processed in two passes.

	{

	TChar tagChar(0);

	iArgStored = EFalse;

	iArgValueExpected = EFalse;		// Initialise

	iCancelArg = EFalse;

	while ((tagChar != '>')&&(iErrorLevel == ENoError))	// ">" is end of tag

		{

		iReadPos+=KCharLength;

		tagChar = ReadTagChar();	// Read in next bit of tag

		if (iTagType != EComment)	// text of comments is ignored

			{

			if (tagChar.IsSpace())	// spaces separate args

				ProcessArgBufL();

			if (tagChar == '=')

				{

				iArgValueExpected = ETrue;

				ProcessArgBufL();

				}

			if (tagChar == '!')

				{

				iCancelArg = ETrue;

				OutputToScreen(_L("!"));

				}

			if (tagChar == ',')

				AppendToArgBuf(tagChar);

			if (tagChar.IsAlphaDigit())

				{

				AppendToArgBuf(tagChar);

				}

			}

		}

	if (tagChar == '>')				// Is it end of tag?

		{

		if (iTagType != EComment)

			{

			ProcessArgBufL();

			if ((iTagType == EControl)||(iTagType == EGlobal))	// Control & global style formatting is applied "on the spot"

				SetFormatLayerL();								// While char & paragraph are applied retrospectively

			}

		}

	}

void CParser::AppendToArgBuf(TChar aTagChar)

	{

	iArgType.Append(aTagChar);	   	// assume it'll fit

	}

void CParser::ProcessArgBufL()

	{

	if (iArgValueExpected)

		{

		if (iArgStored)

			{

			TBuf<32> tempArgBuf;				// Swap the buffers	back as an arg and its value have been stored

			tempArgBuf = iArgType;

			EmptyBuffer(iArgType);

			iArgType = iArgValue;

			EmptyBuffer(iArgValue);

			iArgValue = tempArgBuf;

			TranslateTagArgL();				// Translate the tag argument

			iArgStored = EFalse;			// Reset the flags and buffers

			iArgValueExpected = EFalse;

			EmptyBuffer(iArgType);

			EmptyBuffer(iArgValue);

			}

		else

			{

			iArgValue = iArgType;		 	// Swap the buffers ready to store the value of the arg

			EmptyBuffer(iArgType);			// Empty buffer

			iArgStored = ETrue;

			}

		}

	else

		{

		TranslateTagArgL();			// match to list

		EmptyBuffer(iArgType);

		EmptyBuffer(iArgValue);

		}

	}

void CParser::EmptyBuffer(TDes &aBuf)

	{

	aBuf.SetLength(0);

	}

void CParser::ClassifyTagL(TChar aTagChar)

	{

	switch (aTagChar)

		{

		case 'G':

			iTagType = EGlobal;

			break;

		case 'P':

			{

			iTagType = EParagraph;

			if (iParagraphIsOpen)

				{

				iRichTextDoc->InsertL(iDocInsertPos,CEditableText::EParagraphDelimiter);  // insert para delimiter

				WriteNewLine();				// Write new line to console

				iDocInsertPos++;			// Paragraph delimiters occupy 1 character space

				iDocParaLength++;

				if (iPhraseOpen)

					iDocPhraseLength++;

				SetFormatLayerL();			// apply formatting to old para before starting to fill new one

				}

			else

				iParagraphIsOpen = ETrue;

			break;

			}

		case 'C':

			{

			iTagType = ECharacter;

			if (iPhraseOpen)                                                      

				SetFormatLayerL();	// apply formatting to old phrase retrospectively 			    

			else 

				iPhraseOpen = ETrue;		

			break;

			}

		case 'X':

			iTagType = EControl;

			break;

		case '!':

			iTagType = EComment;

			break;

		default:

			iTagType = EError;

			break;

		}

	}

void CParser::SetFormatLayerL()

// Apply format & mask that have been set in the tag to a Layer

// Apply the layer to the RichText doc

	{

	if (iTagType == EGlobal)

		{

		iGlobalParaFormatLayer->SetL(iGlobalParaFormat, iGlobalParaFormatMask);

		iGlobalCharFormatLayer->SetL(iGlobalCharFormat, iGlobalCharFormatMask);

		iRichTextDoc->SetGlobalParaFormat(iGlobalParaFormatLayer);

		iRichTextDoc->SetGlobalCharFormat(iGlobalCharFormatLayer);

		WriteNewLine();

		}

	if (iTagType == EParagraph)

		{

		iParaFormatLayer->SetL(iParaFormat, iParaFormatMask);

		iRichTextDoc->ApplyParaFormatL(iParaFormat,iParaFormatMask,iDocInsertPos-iDocParaLength,iDocParaLength);

		iCharFormatLayer->SetL(iCharFormat, iCharFormatMask);

		if (iDocPhraseLength > 0)

			iRichTextDoc->ApplyCharFormatL(iCharFormat,iCharFormatMask,iDocInsertPos-iDocPhraseLength,iDocPhraseLength);

		iDocParaLength = 0;			// reset ready for new paragraph

		iDocPhraseLength = 0;

		}

	if (iTagType == ECharacter)

		{

		iCharFormatLayer->SetL(iCharFormat, iCharFormatMask);

		if (iDocPhraseLength > 0)

			iRichTextDoc->ApplyCharFormatL(iCharFormat,iCharFormatMask,iDocInsertPos-iDocPhraseLength,iDocPhraseLength);

		iDocPhraseLength = 0;

		}

	}

TInt CParser::GetArgValue()

// converts numerals in iArgValue to a TInt, 

// first checking that the buffer is totally numeric in content

 	{

	TInt value = 0;

	if (BufIsNumeric(iArgValue))

		{

		TLex tmpLex(iArgValue);

		tmpLex.Val(value);

		}

	else iErrorLevel = EIllegalAttribValue;

	return value;

	}