/*

* 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:

*

*/

#ifndef CDLTKPROCESS_H

#define CDLTKPROCESS_H

#include <CdlCompilerToolkit/CdlTkInterface.h>

#include <CdlCompilerToolkit/CdlTkInstance.h>

#include <fstream>

namespace CdlCompilerToolkit {

/**

* CCdlTkProcess

* Does very little yet.

*/

class CCdlTkProcess

	{

public:

	/**

    * destructor

    */

	virtual ~CCdlTkProcess();

	/**

    * virtual method to invoke processing

    */

	virtual void Process() = 0;

public:

	static std::string CdlBaseNameAndPath(const CCdlTkInterface& aCdl);

	static void AssertInterfaceNotExtended(const CCdlTkInterface& aCdl);

	};

/**

* Base class for processes that write source files

*/

class CCdlTkSourceFileWriter : public CCdlTkProcess

	{

public:

	/**

    * destructor

    */

	~CCdlTkSourceFileWriter();

protected:

	/**

    * Writes an opening namespace declaration for a CDL interface to a stream

    * @param aCdl the CDL interface defining the namespace

	* @param aStream the stream to write to

    */

	void WriteNamespaceStart(const CCdlTkInterface& aCdl, std::ofstream& aStream) const;

	/**

    * Writes a closing namespace declaration for a CDL interface to a stream

    * @param aCdl the CDL interface defining the namespace

	* @param aStream the stream to write to

    */

	void WriteNamespaceEnd(const CCdlTkInterface& aCdl, std::ofstream& aStream) const;

	/**

    * Calculates a header guard identifier for a file

    * @param aFileName the file to be protected by the header guard

    * @return the header guard identifer

    */

	std::string HeaderGuardName(const std::string& aFileName) const;

	/**

    * Writes the starting declarations for a header file guard

    * @param aName the file to be protected by the header guard

	* @param aStream the stream to write to

    * @return 

    */

	void WriteHeaderGuardStart(const std::string& aName, std::ofstream& aStream) const;

	/**

    * Writes the ending declaration for a header file guard

    * @param aName the file to be protected by the header guard

	* @param aStream the stream to write to

    * @return 

    */

	void WriteHeaderGuardEnd(const std::string& aName, std::ofstream& aStream) const;

	};

/**

* Process for writing a common definitions header file (.cdl.common.h)

*/

class CCdlTkWriteCommonDefs : public CCdlTkSourceFileWriter

	{

public:

	static void ExportCommonDefs(const CCdlTkInterface& aCdl, const std::string& aFileName);

private:

	/**

    * constructor

    * @param aCdl the interface to write. 

	* @param aStream the stream to write to

    */

	CCdlTkWriteCommonDefs(const CCdlTkInterface& aCdl, std::ofstream& aStream, const std::string& aFileName);

	/**

    * Creates and writes a common definitions header file (.cdl.common.h)

    */

	void Process();

	void ProcessHRH(std::ofstream& aStream);

private:

	void WriteApiEnum();

	void WriteApiTypedefs();

	std::string TypedefForApi(const CCdlTkApi& aApi) const;

	std::ofstream& Stream();

private:

	const CCdlTkInterface& iCdl;

	std::ofstream* iStream;

	const std::string& iFileName;

	};

/**

* Process for writing a C++ client header file for a C++ interface

*/

class CCdlTkWriteClientHeader : public CCdlTkSourceFileWriter

	{

public:

	/**

    * constructor

    * @param aCdl The interface to write

    */

	CCdlTkWriteClientHeader(const CCdlTkInterface& aCdl);

	/**

    * destructor

    */

	~CCdlTkWriteClientHeader();

	/**

    * Creates and writes the header files required by a C++ client to use

	* a CDL interface.

    */

	void Process();

protected:

	std::string ClientReturnType(const CCdlTkApi& aApi) const;

private:

	void ProcessApi(std::ofstream& aStream, const std::string& aFileName) const;

	void WriteApi(const CCdlTkApi& aApi, std::ofstream& aStream, bool aCInstanceMember, const std::string& aIndent) const;

protected:

	const CCdlTkInterface& iCdl;

	};

/**

* Process for syntax checking a CDL interface

*/

class CCdlTkSyntaxCheck : public CCdlTkWriteClientHeader

	{

	/**

    * constructor

    * @param aCdl the interface to check

    */

	CCdlTkSyntaxCheck(const CCdlTkInterface& aCdl);

	/**

    * destructor

    */

	~CCdlTkSyntaxCheck();

	/**

    * Sets parameters to pass to the C++ compiler which will do the syntax check

    * @param aParams the parameters for the compiler

    */

	void SetParams(std::string aParams);

	/**

    * Runs the syntax checking process

    */

	void Process();

private: // syntax checking

	void WriteSyntaxCheckCpp(std::string aName) const;

	void DoSyntaxCheckBuild(std::string aName) const;

	void WriteSyntaxCheckApi(const CCdlTkApi& aApi, std::ofstream& aStream) const;

private:

	std::string iParams;

	};

/**

* A process for writing a customisation instance to C++ source files

*/

class CCdlTkWriteInstance : public CCdlTkSourceFileWriter

	{

public:

	/**

    * constructor

    * @param aInstance The instance to write

    */

	CCdlTkWriteInstance(const CCdlTkInstance& aInstance);

	/**

    * destructor

    */

	~CCdlTkWriteInstance();

	/**

    * Run the process of creating and writing the C++ source files for a

	* customisation instance.

    */

	void Process();

private:

	void ProcessCdl() const;

	void ProcessInstanceApi(std::ofstream& aStream, const std::string& aFileName) const;

	void ProcessInstance(std::ofstream& aStream, const std::string& aHeaderName) const;

	void ProcessInstanceHeader(std::ofstream& aStream, const std::string& aFileName) const;

	void ProcessInstanceHrh(std::ofstream& aStream, const std::string& aFileName) const;

	void InitReplace(const std::string& aHeaderName);

private:

	const CCdlTkInstance& iInstance;

	const CCdlTkInterface& iCdl;

	CdlTkUtil::CReplaceSet iReplace;

	};

/**

* A process to write the source and build files for a DLL

*/

class CCdlTkWriteDll : public CCdlTkSourceFileWriter

	{

public:

	/**

    * constructor

    * @param aDll the DLL to create source and build files for

    */

	CCdlTkWriteDll(const CCdlTkDll& aDll);

	/**

    * destructor

    */

	~CCdlTkWriteDll();

	/**

    * Runs the process of creating and writing source and build files for a DLL

    */

	void Process();

private:

	void WriteBldInf() const;

	void WriteMmp() const;

	void WriteMainCpp() const;

	void WriteInstanceIdHeader() const;

	void WriteEcomRss() const;

	void WriteEcomDetailRss() const;

private:

	const CCdlTkDll& iDll;

	};

/**

* Process for writing a CDL file

*/

class CCdlTkWriteCdlFile : public CCdlTkProcess

	{

public:

	/**

    * constructor

    * @param aCdl the CDL interface to write

    */

	CCdlTkWriteCdlFile(const CCdlTkInterface& aCdl);

	/**

    * destructor

    */

	~CCdlTkWriteCdlFile();

	/**

    * Run the process of writing the CDL interface to a CDL file

    */

	void Process();

private:

	void WriteHeaderComment();

	void WriteHeader();

	void WriteSeparator(const std::string& aSection);

	void WriteCpp();

	void WriteTranslation();

	void WriteApi();

private:

	const CCdlTkInterface* iCdl;

	std::ofstream iOut;

	};

/**

* A process for reading a CDL file

*/

class CCdlTkCdlFileParser : public CCdlTkProcess

	{

public:

	/**

    * constructor

    * @param aFileName the name of the CDL file to be read

    * @return 

    */

	CCdlTkCdlFileParser(const std::string& aFileName);

	/**

    * destructor

    */

	~CCdlTkCdlFileParser();

	/**

    * Loads and parses a CDL file

    * @param aMergeExtensions tells the parser whether to merge and interface

	* extensions to form a monolithic API

    * @return an auto pointer to the CDL interface read from the CDL file

    */

	std::auto_ptr<CCdlTkInterface> LoadAndParse(bool aMergeExtensions);

	/**

    * virtual Process method from CCdlTkProcess

	* this function is not to be used

    */

	void Process();

private:

	enum TParseState {EHeader, ECpp, ETranslation, EApi, EEnd, EParseStateCount};

private:

	void OpenStream();

	void ParseStream(CCdlTkInterface& aCdl);

	void CloseStream();

	void ParseHeader(CCdlTkInterface& aCdl, const std::string& aLine);

	void ParseCpp(CCdlTkInterface& aCdl, const std::string& aLine);

	void ParseTranslationLine(CCdlTkInterface& aCdl, const std::string& aLine);

	void ParseApi(CCdlTkInterface& aCdl, const std::string& aLine);

	std::auto_ptr<CCdlTkApi> CreateApi(CCdlTkInterface& aCdl, std::string& aLine);

	void ParseApiParams(CCdlTkApiParams& aParams, std::string& aList);

	void ParseNameTypeAndDefaultValue(std::string& aStr, std::string& aName, std::string& aType, std::string& aDefaultValue);

	void ParseTranslationText(CCdlTkDataTypeTranslation& aTrans, std::string& aLine);

	std::string GetLine();

	bool IsSectionBoundary(const std::string& aLine, TParseState& aState);

	bool MatchLineStart(const std::string& aLine, const std::string& aHeader, std::string& aVal);

	void StripComments(std::string& aStr, std::string& aComment);

	void SyntaxError(const std::string& aErr);

private:

	std::string iFileName;

	std::ifstream iIn;

	TParseState iState;

	int iCurrentSourceLineNum;

	std::string iApiBuf;			// buffer for collecting API declarations

	std::string iComment;			// buffer for collecting comments

	};

/**

* Observer mixin interface for the interface checking process

*/

class MCdlTkApiCheckObserver

	{

public:

	/**

    * Called when an interface check is started

    */

	virtual void StartCheck() = 0;

	/**

    * Called when an interface check is complete

    */

	virtual void CheckComplete() = 0;

	/**

    * Called when an API is found that appears in both interfaces

    */

	virtual void ApiInBoth(const CCdlTkApi& aApi) = 0;

	/**

    * Called when an API is found that is only in the right hand interface

    */

	virtual void ApiNotInLeft(const CCdlTkApi& aApi) = 0;

	/**

    * Called when an API is found that is only in the left hand interface

    */

	virtual void ApiNotInRight(const CCdlTkApi& aApi) = 0;

	};

/**

* process for checking (diffing) two CDL interfaces' APIs

*/

class CCdlTkApiChecker : public CCdlTkProcess

	{

public:

	/**

    * constructor

    * @param aLeft a CDL interface to check

    * @param aRight another CDL interface to check

    * @param aObserver the observer of the results of the check

    */

	CCdlTkApiChecker(const CCdlTkInterface& aLeft, 

					 const CCdlTkInterface& aRight, 

					 MCdlTkApiCheckObserver& aObserver);

	/**

    * destructor

    */

	~CCdlTkApiChecker();

	/**

    * Run the process of checking the interfaces' APIs

    */

	void Process();

private:

	typedef CCdlTkApiList::const_iterator CApiListIter;

	void FailLeft(CApiListIter& aFrom, const CApiListIter& aTo) const;

	void FailRight(CApiListIter& aFrom, const CApiListIter& aTo) const;

	void ReSync(CApiListIter& posLeft, CApiListIter& posRight, 

				const CApiListIter& leftEnd, const CApiListIter& rightEnd) const;

private:

	const CCdlTkInterface& iLeft;

	const CCdlTkInterface& iRight;

	MCdlTkApiCheckObserver& iObserver;

	};

}	// end of namespace CdlCompilerToolkit

#endif