/*

* 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 file contains the header file of the CStifFileParser.

*

*/

#ifndef STIF_FILE_PARSER_H

#define STIF_FILE_PARSER_H

//  INCLUDES

#include <f32file.h>

#include <e32std.h>

#include <e32base.h>

#include "cstackdeprecated.h"

#include <StifTestModule.h>

#include "StifParser.h"

// CONSTANTS

_LIT(KIncludeKeyword, "INCLUDE");

// MACROS

// None

// DATA TYPES

// None

// FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// CLASS DECLARATION

// DESCRIPTION

// CStifFileParser is a STIF Test Framework StifParser class.

// Class contains a configuration file parsing operations without loading it into memory.

NONSHARABLE_CLASS (CStifFileParser) : public CBase

{

    public:     // Enumerations

		// Indication what kind of char sequence is to be found

        enum TWhatToFind

      	{

        	EStart,             // '//' or '/*' or '"' signs

        	EQuota,             // '"' sign

        	EEndOfComment       // '*/' sequence

    	};

		// Indication if beginning or end of section is to be found

        enum TSectionFind

        {

        	ESectionStart,

        	ESectionEnd

        };

    private:    // Enumerations

    public:     // Constructors and destructor

        /**

        * Two-phased constructor.

        * Creating parser with given handle to file. For default all

        * information will be parsed(ENoComments).

        */

        static CStifFileParser* NewL(RFs& aFs,

                                     RFile &aFile,

                                     TBool aIsUnicode,

                                     CStifParser::TCommentType aCommentType = CStifParser::ENoComments);

        /**

        * Destructor.

        */

        ~CStifFileParser();

    public:     // New functions

        /**

        * Open and read configuration source and parses a required section.

        * This method will parse next section after the earlier section if

        * aSeeked parameter is equal 1.

        * If configuration file includes several sections with both start and

        * end tags so aSeeked parameter seeks the required section. The aSeeked

        * parameters indicates section that will be parsed.

        * If start tag is not given, returned section begins from the beginning of

        * the file. If end tag is not given, returned sections ends at the end of

        * the file.

        * If section is not found and first occurence of section is seeked, function

        * will return NULL, but if second (or further) occurence is seeked, function

        * will leave with KErrNotFound (for compability with CStifParser::NextSectionL

		* reason).

        */

		HBufC* NextSectionL(const TDesC& aStartTag,

                            const TDesC& aEndTag,

                            TInt& aOffset,

                            TInt aSeeked = 1,TBool aIsHasEndTag=ETrue);

    public:     // Functions from base classes

    protected:  // New functions

    protected:  // Functions from base classes

    private:

        /**

        * C++ default constructor.

        */

        CStifFileParser(CStifParser::TCommentType aCommentType);

        /**

        * By default Symbian OS constructor is private.

        */

        void ConstructL(RFs& aFs,

                        RFile &aFile,

                        TBool aIsUnicode);

        /**

        * Reads configuration source and returns a complete line.

        * This method will return also and end of line sequence.

        */

		TBool ReadLineL(TPtr& aLineBuffer,

		                TPtr& aEndOfLineBuffer);

        /**

        * Parses a given line and removes all c-style comments from it (and #-style comments).

        * Result is passed in destination buffer.

        */

		void ReplaceCommentsLineL(TPtr& aSrcBufPtr,

		                          TPtr& aDstBufPtr,

								  TWhatToFind& aFind);

        /**

        * Parses a given line and removes all #-style comments.

        * Result is passed in destination buffer.

        */

	 	void ReplaceHashCommentsLineL(TPtr& aSrcBufPtr,

 	                                  TPtr& aDstBufPtr);

        /**

        * Closes all files on file stack and clears the stack.

        */

 	    void ClearFileStack(void);

        /**

        * Pops RFile handle from file stack and sets correct current file handle.

        */

        void PopFromFileStack(void);

        /**

        * Opens file and pushes it to stack.

        */

        void PushFileToStackL(const TDesC& aFileName);

        /**

        * Deletes all descriptors assigned to array and empties array.

        */

        void ClearSectionLinesArray(void);

    public:     // Data

    protected:  // Data

    private:    // Data

        /**

        * For file opening.

        */

        RFs         iFileServer;

        /**

        * For file opening. This is the first (base) file. Later other files may be opened if

        * they are included to base one.

        */

        RFile       iBaseFile;

        /**

        * Comment type's indication.

        */

        CStifParser::TCommentType iCommentType;

        /**

        * Flag indicating if file is unicode.

        */

        TBool       iIsUnicode;

        /**

        * How many bytes per char in file (2 for unicode, 1 for non-unicode).

        */

        TInt 		iBytesPerChar;

        /**

        * Handle to file which is currently read.

        */

        RFile*      iCurrentFile;

        /**

        * Stack of opened files (it does not contain base file).

        */

        CStackDeprecated<RFile, EFalse>* iFileStack;

        /**

        * Array of lines belonging to seeked section.

        */

		RPointerArray<HBufC> iSectionLines;

		/**

		* Array of already included files (to avoid loop in includes).

		*/

		RPointerArray<HBufC> iFileNames;

		/**

		* Buffer with eol sequence. Filled when include found and used after last line of inlcuded file.

		*/

		TBuf<2>     iEolBuf;

    public:     // Friend classes

    protected:  // Friend classes

    private:    // Friend classes

};

#endif      // STIF_FILE_PARSER_H

// End of File