/*

* Copyright (c) 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: This module contains implementation of CStifParser 

* class member functions.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "StifFileParser.h"

#include "StifTestInterface.h"

#include "ParserTracing.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

// None

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

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: CStifFileParser

    Description: Default constructor

    C++ default constructor can NOT contain any code, that

    might leave.

    Parameters: TCommentType aCommentType: in: Comment type's indication

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

CStifFileParser::CStifFileParser(CStifParser::TCommentType aCommentType)

	{

    iCommentType = aCommentType;

	}

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Sets variables.

    Parameters: RFs& aFs:        in: Handle to valid file server

                RFile& aFile:    in: Handle to the source file

                TBool aIsUnicode in: Is file in unicode format

    Return Values: None

    Errors/Exceptions:  None

    Status: Proposal

-------------------------------------------------------------------------------

*/

void CStifFileParser::ConstructL(RFs& aFs,

                                 RFile& aFile,

                                 TBool aIsUnicode)

	{

	//Initialization

	iFileServer = aFs;

	iBaseFile = aFile;

	iCurrentFile = &aFile;

	iIsUnicode = aIsUnicode;

	iBytesPerChar = iIsUnicode ? 2 : 1;

	//Create file stack (INCLUDE feature)

	iFileStack = new (ELeave) CStackDeprecated<RFile, EFalse>;

	//Add base file to file names array

	TFileName fn;

	iCurrentFile->FullName(fn);

	HBufC* newFile = fn.AllocLC();

	User::LeaveIfError(iFileNames.Append(newFile));

	CleanupStack::Pop(newFile);

	}

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: NewL

    Description: Two-phased constructor.

    Starting creating parser with path and file information.

    Parameters: RFs& aFs:                  in: Handle to file server

                RFile& aFile:              in: Source path definition

                TBool aIsUnicode           in: Is file in unicode format

                TCommentType aCommentType: in: Comment type's indication

    Return Values: CStifFileParser* : pointer to CStifFileParser object

    Errors/Exceptions: Leaves if ConstructL leaves

    Status: Proposal

-------------------------------------------------------------------------------

*/

CStifFileParser* CStifFileParser::NewL(RFs& aFs,

                                       RFile& aFile,

                                       TBool aIsUnicode,

                                       CStifParser::TCommentType aCommentType)

	{

    // Create CStifParser object

    CStifFileParser* parser = new (ELeave) CStifFileParser(aCommentType);

    CleanupStack::PushL(parser);

    parser->ConstructL(aFs, aFile, aIsUnicode);

    CleanupStack::Pop(parser);

    return parser;

	}

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: ~CStifFileParser

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Proposal

-------------------------------------------------------------------------------

*/

CStifFileParser::~CStifFileParser()

	{

	//Close file stack

	ClearFileStack();

	delete iFileStack;

	//Close section lines array

	ClearSectionLinesArray();

	iSectionLines.Close();

	//Close fila names array

	while(iFileNames.Count() > 0)

		{

		delete iFileNames[0];

		iFileNames.Remove(0);

		}

	iFileNames.Close();

	}

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: ReadLineL

    Description: Reads line from source file

    Parameters: TPtr& aLineBuffer:      in: Descriptor in which line loads

                TPtr& aEndOfLineBuffer: in: Descriptor in which end of line sequence is loaded (0x0A or 0x0D 0x0A)

    Return Values: TBool: determines whether line was readed or not

    Errors/Exceptions:  Leaves if seek command leaves

    					Leaves if buffer is too small

    Status: Proposal

-------------------------------------------------------------------------------

*/

TBool CStifFileParser::ReadLineL(TPtr& aLineBuffer,

                                 TPtr& aEndOfLineBuffer)

	{

	//Variables

	TBuf8<128> buf8;

	TBuf16<128> buf16;

	TPtrC16 buf;

	TInt pos;

	TInt offset;

	TChar char0x0A = 0x000A;

	TChar char0x0D = 0x000D;

	TBuf<1> b0x0A;

	b0x0A.Append(char0x0A);

	//Reset buffers

	aLineBuffer.Zero();

	aEndOfLineBuffer.Zero();

	//Read from source

	User::LeaveIfError(iCurrentFile->Read(buf8));

	buf16.Copy(buf8);

	if(iIsUnicode)

		buf.Set((TUint16 *)(buf8.Ptr()), buf8.Length() / 2);

	else

		buf.Set(buf16.Ptr(), buf16.Length());

	while(buf.Length())

		{

		//Search for end of line char

		pos = buf.Find(b0x0A);

		//If found, append readed data to output descriptor and move back file offset to correct position

		if(pos >= 0)

			{

			offset = -((buf.Length() - pos - 1) * iBytesPerChar);

			User::LeaveIfError(iCurrentFile->Seek(ESeekCurrent, offset));

			buf.Set(buf.Ptr(), pos + 1);

			aLineBuffer.Append(buf);

			break;

			}

		//Otherwise, append whole buffer to output descriptor

		else

			{

			aLineBuffer.Append(buf);

			}

		//Read next part of data

		User::LeaveIfError(iCurrentFile->Read(buf8));

		buf16.Copy(buf8);

		if(iIsUnicode)

			{

			buf.Set((TUint16 *)(buf8.Ptr()), buf8.Length() / 2);

			}

		else

			{

			buf.Set(buf16.Ptr(), buf16.Length());

			}

		}

	//Set correct end of line buffer

	if(buf.Length() > 1)

		{

		if(buf[buf.Length() - 2] == char0x0D)

			{

			aEndOfLineBuffer.Append(char0x0D);

			}

		}

	if(buf.Length() > 0)

		{

		if(buf[buf.Length() - 1] == char0x0A)

			{

			aEndOfLineBuffer.Append(char0x0A);

			}

		else

			{

			aEndOfLineBuffer.Zero();

			}

		}

	if(aEndOfLineBuffer.Length())

		{

		aLineBuffer.SetLength(aLineBuffer.Length() - aEndOfLineBuffer.Length());

		}

	//If no data was found, try to get previous file from stack

	if(aLineBuffer.Length() + aEndOfLineBuffer.Length() == 0)

		{

		//Pop file from stack. If stack is empty, then we achieved end of base file

		if(!iFileStack->IsEmpty())

			{

			PopFromFileStack();

			aEndOfLineBuffer.Copy(iEolBuf);

			return aEndOfLineBuffer.Length();

			}

		}

	//Check if this is include line

	else

		{

		if(aLineBuffer.Find(KIncludeKeyword) == 0)

			{

			TFileName fn;

			TLex lex(aLineBuffer);

			fn.Copy(lex.NextToken()); //get INCLUDE keyword

			fn.Copy(lex.NextToken()); //get cfg file name

			if(fn.Length() > 0)

				{

				TStifUtil::CorrectFilePathL( fn );

				PushFileToStackL(fn);

				iEolBuf.Copy(aEndOfLineBuffer);

				}

			else

				{

				__TRACE(KError, (_L("No filename was given after INCLUDE. Ignoring")));

				}

			//Read next line

			return ReadLineL(aLineBuffer, aEndOfLineBuffer);

			}

		}

	return aLineBuffer.Length() + aEndOfLineBuffer.Length();

	}

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: ReplaceCommentsLineL

    Description: Replaces comments with spaces from line and copy it to destination buffer

    Parameters: TPtr& aSrcBufPtr:        in:  Source line with comments

                TPtr& aDstBufPtr:       out:  Destination line without comments

                TWhatToFind& aFind:  in out:  Determines what method currently is looking for

    Return Values: None

    Errors/Exceptions:  None

    Status: Proposal

-------------------------------------------------------------------------------

*/

void CStifFileParser::ReplaceCommentsLineL(TPtr& aSrcBufPtr,

                                           TPtr& aDstBufPtr,

										   TWhatToFind& aFind)

	{

	//Variables

	TLex lex(aSrcBufPtr);

	TChar ch;

	TChar chSpace(' ');

	TChar chSlash('/');

	TChar chQuota('\"');

	TChar chMulti('*');

	TChar chHash('#');

	//Clean buffer

	aDstBufPtr.Zero();

	while(!lex.Eos())

		{

		ch = lex.Get();

		//If the end of line, exit

		if(!ch)

			{

			break;

			}

		//We're looking for start od quoted text or comment

		if(aFind == EStart)

			{

			//Special character readed

			if(ch == chQuota)

				{

				aFind = EQuota;

				aDstBufPtr.Append(chSpace);

				}

			//Possible start of comment

			else if(ch == chSlash)

				{

				//Comment to the end of line found

				if(lex.Peek() == chSlash)

					{

					break;

					}

				//Beginning of a comment found

				else if(lex.Peek() == chMulti)

					{

					aFind = EEndOfComment;

					ch = lex.Get();

					aDstBufPtr.Append(chSpace);

					aDstBufPtr.Append(chSpace);

					}

				//No start of comment - add read slash

				else

					{

					aDstBufPtr.Append(ch);

					}

				}

			//Start of hash comment (to the end of line)

			else if(ch == chHash)

				{

				break;

				}

			//Append readed character to the destination buffer

			else

				{

				aDstBufPtr.Append(ch);

				}

			}

		//We're looking for the end of quoted text

		else if(aFind == EQuota)

			{

			if(ch == chQuota)

				{

				aFind = EStart;

				aDstBufPtr.Append(chSpace);

				}

			else

				{

				aDstBufPtr.Append(chSpace);

				}

			}

		//We're looking for the end of comment

		else if(aFind == EEndOfComment)

			{

			//It may be the end of a comment

			if(ch == chMulti)

				{

				ch = lex.Peek();

				//It is the end of a comment

				if(ch == chSlash)

					{

					aFind = EStart;

					ch = lex.Get();

					aDstBufPtr.Append(chSpace);

					aDstBufPtr.Append(chSpace);

					}

				//It is not the end of a comment, add this character to the destinaton buffer

				else

					{

					aDstBufPtr.Append(chSpace);

					}

				}

			//It is not the end of a comment, add this character to the destinaton buffer

			else

				{

				aDstBufPtr.Append(chSpace);

				}

			}

		}

	}

/*

-------------------------------------------------------------------------------

    Class: CStifFileParser

    Method: ReplaceHashCommentsLineL

    Description: Copy line to destination buffer and deletes #-style comments

    Parameters: TPtr& aSrcBufPtr:     in:  Source line with comments

                TPtr& aDstBufPtr:    out: Destination line without comments

    Return Values: None

    Errors/Exceptions:  None

    Status: Proposal

-------------------------------------------------------------------------------

*/

void CStifFileParser::ReplaceHashCommentsLineL(TPtr& aSrcBufPtr,

                                               TPtr& aDstBufPtr)

	{

	//Variables

	TLex lex(aSrcBufPtr);

	TChar ch;

	TChar chHash('#');

	//Prepare destination buffer

	aDstBufPtr.Zero();

	//Copy source line to destination until # char is found

	while(!lex.Eos())

		{

		ch = lex.Get();

		//If the end of line, exit

		if(!ch)

			{

			break;

			}

		if(ch == chHash)

			{

			break;

			}

		else

			{