--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uitools_plat/cdl_api/inc/CdlCompilerToolkit/CdlTkProcess.h Thu Dec 17 09:14:18 2009 +0200
@@ -0,0 +1,429 @@
+/*
+* 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