// XTPSyntaxEditLexParser.h // // This file is a part of the XTREME TOOLKIT PRO MFC class library. // (c)1998-2012 Codejock Software, All Rights Reserved. // // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN // CONSENT OF CODEJOCK SOFTWARE. // // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED // IN THE XTREME SYNTAX EDIT LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A // SINGLE COMPUTER. // // CONTACT INFORMATION: // support@codejock.com // http://www.codejock.com // ////////////////////////////////////////////////////////////////////// //{{AFX_CODEJOCK_PRIVATE #if !defined(__XTPSYNTAXEDITLEXPARSER_H__) #define __XTPSYNTAXEDITLEXPARSER_H__ //}}AFX_CODEJOCK_PRIVATE #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 class CXTPSyntaxEditColorTheme; class CXTPNotifySink; class CXTPNotifyConnection; class CXTPSyntaxEditBufferManager; class CXTPNotifyConnectionMT; //////////////////////////////////////////////////////////////////////////// //{{AFX_CODEJOCK_PRIVATE typedef CList CXTPSyntaxEditTextBlockList; typedef CArray CXTPSyntaxEditTextBlockArray; //}}AFX_CODEJOCK_PRIVATE namespace XTPSyntaxEditLexAnalyser { class CXTPSyntaxEditLexObj_ActiveTags; class CXTPSyntaxEditLexClass; class CXTPSyntaxEditLexClassInfoArray; class CXTPSyntaxEditLexOnScreenParseCnt; //======================================================================== // Summary: // Enumerates flags which indicate results of parse functions calls. // See also: // CXTPSyntaxEditLexClass, CXTPSyntaxEditLexTextSchema //======================================================================== enum XTPSyntaxEditLexParseResult { xtpEditLPR_Unknown = 0, // Undefined value. xtpEditLPR_StartFound = 0x001, // Start text block was found xtpEditLPR_EndFound = 0x002, // End text block was found xtpEditLPR_Iterated = 0x010, // Indicate that current text position has already moved to the next char inside a function call. xtpEditLPR_TBpop1 = 0x020, // Indicate that new found text block should be inserted before previous one and as a parent of it. xtpEditLPR_Error = 0x100, // Iterated parse process breaked due to some error. See trace for details. xtpEditLPR_RunFinished = 0x200, // Run iterated parse process (or some big part of it) is finished. xtpEditLPR_RunBreaked = 0x400, // Run iterated parse process (or some big part of it) is breaked. xtpEditLPR_RunRestart = 0x800, // Restart run children from the beginning. //xtpEditLPR_NeedFullReparse = 0x1000, // Cannot reparse only specified piece of text. Full reparse is necessary. }; //======================================================================== // Summary: // This class is designed to store coordinates of text region. // See also: // XTP_EDIT_LINECOL //======================================================================== class _XTP_EXT_CLASS CXTPSyntaxEditTextRegion { public: XTP_EDIT_LINECOL m_posStart; // start position in document coordinates. XTP_EDIT_LINECOL m_posEnd; // end position in document coordinates. //-------------------------------------------------------------------- // Summary: // Clears coordinates. //-------------------------------------------------------------------- void Clear(); //-------------------------------------------------------------------- // Summary: // Sets coordinates. // Parameters: // pLCStart : [in] start position in document coordinates. // pLCEnd : [in] end position in document coordinates. //-------------------------------------------------------------------- void Set(const XTP_EDIT_LINECOL* pLCStart, const XTP_EDIT_LINECOL* pLCEnd); }; //{{AFX_CODEJOCK_PRIVATE typedef CArray CXTPSyntaxEditInvalidZoneArray; //}}AFX_CODEJOCK_PRIVATE //=========================================================================== // Summary: // This class stores tokens definition: a list of tokens and corresponding // lists of start and end tokens separators. //=========================================================================== class _XTP_EXT_CLASS CXTPSyntaxEditLexTokensDef { public: //----------------------------------------------------------------------- // Summary: // Default object constructor. //----------------------------------------------------------------------- CXTPSyntaxEditLexTokensDef(){}; //----------------------------------------------------------------------- // Summary: // Copy object constructor. // Parameters: // rSrc : [in] Reference to source CXTPSyntaxEditLexTokensDef object. //----------------------------------------------------------------------- CXTPSyntaxEditLexTokensDef(const CXTPSyntaxEditLexTokensDef& rSrc); //----------------------------------------------------------------------- // Summary: // Object destructor. Handles clean up and deallocations. //----------------------------------------------------------------------- virtual ~CXTPSyntaxEditLexTokensDef(); //----------------------------------------------------------------------- // Summary: // Assignment operator for class. // Parameters: // rSrc : [in] Reference to source CXTPSyntaxEditLexTokensDef object. // Returns: // Reference to CXTPSyntaxEditLexTokensDef object. //----------------------------------------------------------------------- const CXTPSyntaxEditLexTokensDef& operator=(const CXTPSyntaxEditLexTokensDef& rSrc); CStringArray m_arTokens; // Stores list of tokens. CStringArray m_arStartSeps; // Stores list of start separators. CStringArray m_arEndSeps; // Stores list of end separators. }; //{{AFX_CODEJOCK_PRIVATE typedef CArray CXTPSyntaxEditLexTokensDefArray; //}}AFX_CODEJOCK_PRIVATE //======================================================================== // Summary: // This class is designed to easily manipulate parser options. //======================================================================== class _XTP_EXT_CLASS CXTPSyntaxEditLexParserSchemaOptions : public CXTPCmdTarget { public: //----------------------------------------------------------------------- // Summary: // Default object constructor. //----------------------------------------------------------------------- CXTPSyntaxEditLexParserSchemaOptions(); //----------------------------------------------------------------------- // Summary: // Object constructor. // Parameters: // rSrc : [in] Reference to source CXTPSyntaxEditLexParserSchemaOptions. //----------------------------------------------------------------------- CXTPSyntaxEditLexParserSchemaOptions(const CXTPSyntaxEditLexParserSchemaOptions& rSrc); //----------------------------------------------------------------------- // Summary: // Overloaded equals operator. // Parameters: // rSrc : [in] Reference to source CXTPSyntaxEditLexParserSchemaOptions. //----------------------------------------------------------------------- const CXTPSyntaxEditLexParserSchemaOptions& operator=(const CXTPSyntaxEditLexParserSchemaOptions& rSrc); //global: BOOL m_bFirstParseInSeparateThread; // {0,1} default=1 BOOL m_bEditReparceInSeparateThread; // {0,1} default=1 BOOL m_bConfigChangedReparceInSeparateThread; // {0,1} default=1 DWORD m_dwMaxBackParseOffset; // default=100; maximum back buffer size. Some times parser look back for the text from current position. DWORD m_dwEditReparceTimeout_ms; // default=500 ms; time out for start reparse after last key was pressed. DWORD m_dwOnScreenSchCacheLifeTime_sec; // default=180 sec; time out for on screen parsed pices of text. for memory using optimization. DWORD m_dwParserThreadIdleLifeTime_ms; // default=60 sec; time out for existing of parser thread when parser idle (no parse requests). }; //{{AFX_CODEJOCK_PRIVATE //======================================================================= // Summary: // //======================================================================= class _XTP_EXT_CLASS CXTPSyntaxEditLexClassSchema : public CXTPCmdTarget { friend class CXTPSyntaxEditLexTextSchema; public: //----------------------------------------------------------------------- // Summary: // Default object constructor. //----------------------------------------------------------------------- CXTPSyntaxEditLexClassSchema(); //----------------------------------------------------------------------- // Summary: // Object destructor. Handles clean up and deallocations. //----------------------------------------------------------------------- virtual ~CXTPSyntaxEditLexClassSchema(); virtual void AddPreBuildClass(CXTPSyntaxEditLexClass* pClass); virtual BOOL Build(); virtual BOOL Copy(CXTPSyntaxEditLexClassSchema* pDest); virtual void Close(); virtual void RemoveAll(); virtual CXTPSyntaxEditLexClassPtrArray* GetClasses(BOOL bShortSch); virtual CXTPSyntaxEditLexClassPtrArray* GetPreBuildClasses(); virtual CXTPSyntaxEditLexClass* GetPreBuildClass(const CString& strName); virtual CXTPSyntaxEditLexClass* GetNewClass(BOOL bForFile); virtual CXTPSyntaxEditLexObj_ActiveTags* GetActiveTagsFor(CXTPSyntaxEditLexClass* pTopClass); //virtual CXTPSyntaxEditLexObj_ActiveTags* GetActiveTags(BOOL bShortSch); protected: virtual BOOL Build_ChildrenFor(BOOL bDynamic, CXTPSyntaxEditLexClass* pCBase, CStringArray& rarAdded, int& rnNextClassID, int nLevel = 0); virtual CXTPSyntaxEditLexClassPtrArray* GetChildrenFor(CXTPSyntaxEditLexClass* pClass, BOOL& rbSelfChild); virtual CXTPSyntaxEditLexClassPtrArray* GetDynChildrenFor(CXTPSyntaxEditLexClass* pClass, BOOL& rbSelfChild); virtual void GetDynParentsList(CXTPSyntaxEditLexClass* pClass, CStringArray& rarDynParents, CStringArray& rarProcessedClasses); virtual int CanBeParentDynForChild(CString strParentName, CXTPSyntaxEditLexClass* pCChild); virtual BOOL Build_ShortTree(); virtual BOOL PostBuild_Step(CXTPSyntaxEditLexClassPtrArray* pArClasses); virtual BOOL CopyChildrenFor(BOOL bShort, CXTPSyntaxEditLexClass* pCDest, CXTPSyntaxEditLexClass* pCSrc, int nLevel); CXTPSyntaxEditLexClassPtrArray m_arPreBuildClassesList; CXTPSyntaxEditLexClassPtrArray m_arClassesTreeShort; CXTPSyntaxEditLexClassPtrArray m_arClassesTreeFull; //CXTPSyntaxEditLexObj_ActiveTags m_arAllActiveTagsShort; //CXTPSyntaxEditLexObj_ActiveTags m_arAllActiveTagsFull; }; //}}AFX_CODEJOCK_PRIVATE //=========================================================================== // Summary: // CXTPSyntaxEditLexTextBlock class represents a pice (block) of text which // corresponds some lex class in a text schema. // It stores start position, end position, pointer to the lex class // object in a class schema and some other information. // Text blocks organized as a bidirectional list and as tree structure. //=========================================================================== class _XTP_EXT_CLASS CXTPSyntaxEditLexTextBlock : public CXTPCmdTarget { //{{AFX_CODEJOCK_PRIVATE friend class CXTPSyntaxEditLexTextSchema; friend class CXTPSyntaxEditLexClass; friend class CXTPSyntaxEditLexClass_file; //}}AFX_CODEJOCK_PRIVATE public: //----------------------------------------------------------------------- // Summary: // Default object constructor. //----------------------------------------------------------------------- CXTPSyntaxEditLexTextBlock(); //----------------------------------------------------------------------- // Summary: // Object destructor. Handles clean up and deallocations. //----------------------------------------------------------------------- virtual ~CXTPSyntaxEditLexTextBlock(); CXTPSyntaxEditLexClassPtr m_ptrLexClass; // Pointer to the LexClass object. CXTPSyntaxEditLexTextBlockPtr m_ptrParent; // Pointer to the parent block object. CXTPSyntaxEditLexTextBlockPtr m_ptrPrev; // Pointer to the previous block. CXTPSyntaxEditLexTextBlockPtr m_ptrNext; // Pointer to the next block. XTP_EDIT_LINECOL m_PosStartLC; // Text block start position. XTP_EDIT_LINECOL m_PosEndLC; // Text block start position. BOOL m_bEndByParent; // Text block ended when the parent block ended. //-------------------------------------------------------------------- // Summary: // Get Text block end position. // Parameters: // bMaxIfInvalid - [in] If TRUE returns XTP_EDIT_LINECOL::MAXPOS for // invalid position. If FALSE returns // XTP_EDIT_LINECOL::MINPOS for invalid position. // Returns: // Value of m_PosEndLC if it is valid, otherwise maximum or minimum // value depends on parameter bMaxIfInvalid. // See Also: // XTP_EDIT_LINECOL, m_PosEndLC, m_PosStartLC. //-------------------------------------------------------------------- XTP_EDIT_LINECOL GetPosEndLC(BOOL bMaxIfInvalid = TRUE); //-------------------------------------------------------------------- // Summary: // Get text block start tag end position in the text. // Returns: // Text block start tag end position in XLC form. // See Also: // XTP_EDIT_LINECOL::GetXLC(), XTP_EDIT_XLC() macros. //-------------------------------------------------------------------- DWORD GetStartTagEndXLC(); //-------------------------------------------------------------------- // Summary: // Get text block end tag begin position in the text. // Returns: // Text block end tag begin position in XLC form. // See Also: // XTP_EDIT_LINECOL::GetXLC(), XTP_EDIT_XLC() macros. //-------------------------------------------------------------------- DWORD GetEndTagBeginXLC(); //-------------------------------------------------------------------- // Summary: // Get text block end tag end position in the text. // Returns: // Text block end tag end position in XLC form. // See Also: // XTP_EDIT_LINECOL::GetXLC(), XTP_EDIT_XLC() macros. //-------------------------------------------------------------------- DWORD GetEndTagEndXLC(); //-------------------------------------------------------------------- // Summary: // Release references to other objects. // Remarks: // This method is used in text schema destruction process. // See Also: // CXTPSyntaxEditLexTextSchema::Close(). //-------------------------------------------------------------------- virtual void Close(); //virtual void Close(BOOL bWithPrev = FALSE, BOOL bWithNext = FALSE); //-------------------------------------------------------------------- // Summary: // This methods compare lex classes names for 2 text blocks. // Parameters: // pTB2 - [in] Second text block to compare. // Returns: // TRUE if lex classes names for 2 text blocks are equal, // FALSE otherwise. //-------------------------------------------------------------------- virtual BOOL IsEqualLexClasses(CXTPSyntaxEditLexTextBlock* pTB2) const; //-------------------------------------------------------------------- // Summary: // This method determine is the specified text block included // in the current text block. // Parameters: // pTB2 - [in] Text block pointer. // Returns: // TRUE if the specified text block included in the current text // block, FALSE otherwise. //-------------------------------------------------------------------- virtual BOOL IsInclude(CXTPSyntaxEditLexTextBlock* pTB2) const; //-------------------------------------------------------------------- // Summary: // This method determine is text block look like closed or // partly closed. // Returns: // TRUE if some or all references to other objects are NULL, // FALSE otherwise. //---------------------------------------------------------------- virtual BOOL IsLookLikeClosed() const; //-------------------------------------------------------------------- // Summary: // This method set end position to not ended children blocks. // Parameters: // pTxtSch - [in] Text schema pointer to send notifications. // bEndByParent - BOOL flag // Returns: // Ended children blocks count. //---------------------------------------------------------------- virtual int EndChildren(CXTPSyntaxEditLexTextSchema* pTxtSch = NULL, BOOL bEndByParent = TRUE); //-------------------------------------------------------------------- // Summary: // This method searches previous child block for the specified // child. This block is parent. // Parameters: // pChild - [in] Child block pointer. // bWithAddRef : [in] If TRUE - InternalAddRef() is called before // Returns: // Previous child block pointer or NULL. //---------------------------------------------------------------- virtual CXTPSyntaxEditLexTextBlock* GetPrevChild(CXTPSyntaxEditLexTextBlock* pChild, BOOL bWithAddRef); #ifdef _DEBUG virtual void Dump(CDumpContext& dc) const; #endif protected: int m_nStartTagLen; // Start tag length. int m_nEndTagXLCLen; // End tag length in XLC form. CXTPSyntaxEditLexTextBlockPtr m_ptrLastChild; // for internal use only. not always contains correct value }; //=========================================================================== // Summary: // CXTPSyntaxEditLexTextSchema class is used to store data which necessary to // parse a text and parsing results. It also contains methods to run // lex classes from a class schema, methods to update text schema // when text is edited, methods to reparse text, to get information // which is necessary to draw colorized text and other helper methods. //=========================================================================== class _XTP_EXT_CLASS CXTPSyntaxEditLexTextSchema : public CXTPCmdTarget { //{{AFX_CODEJOCK_PRIVATE friend class CXTPSyntaxEditLexClass; friend class CXTPSyntaxEditLexClass_file; friend class CXTPSyntaxEditLexTextBlock; friend class CXTPSyntaxEditLexParser; //}}AFX_CODEJOCK_PRIVATE public: //----------------------------------------------------------------------- // Summary: // Default object constructor. // Parameters: // pcszSchName - [in] Schema name. //----------------------------------------------------------------------- CXTPSyntaxEditLexTextSchema(LPCTSTR pcszSchName); //----------------------------------------------------------------------- // Summary: // Object destructor. Handles clean up and deallocations. //----------------------------------------------------------------------- virtual ~CXTPSyntaxEditLexTextSchema(); //----------------------------------------------------------------------- // Summary: // Get text schema name. // Returns: // Text schema name string. //----------------------------------------------------------------------- virtual CString GetSchName() const; //----------------------------------------------------------------------- // Summary: // Destroy all interlocked objects references and free all // stored objects. // Remarks: // Call this method to delete schema. // See Also: // RemoveAll(), CXTPSyntaxEditLexClassSchema::Close(). //----------------------------------------------------------------------- virtual void Close(); //----------------------------------------------------------------------- // Summary: // Destroy text blocks list. // Parameters: // pFirst - A pointer to the first element in the list to destroy. // Remarks: // This helper method is called to destroy separately stored text // blocks list (text schema). // See Also: // CXTPSyntaxEditLexTextBlock::Close(). //----------------------------------------------------------------------- static void AFX_CDECL Close(CXTPSyntaxEditLexTextBlock* pFirst); //----------------------------------------------------------------------- // Summary: // Remove all text block from the schema. // Remarks: // Schema object is not destroyed, just only blocks are removed. // See Also: // RemoveAll(), CXTPSyntaxEditLexClassSchema::Close(). //----------------------------------------------------------------------- virtual void RemoveAll(); //----------------------------------------------------------------------- // Summary: // Create a new text schema object and init its internal // infrastructure (like class schema) from the current schema. // Remarks: // Text blocks are not copied. The class schema is copied. // Returns: // A new text schema object. //----------------------------------------------------------------------- virtual CXTPSyntaxEditLexTextSchema* Clone(); //----------------------------------------------------------------------- // Summary: // Returns notification connection. // Returns: // CXTPNotifyConnectionPtr pointer. //----------------------------------------------------------------------- virtual CXTPNotifyConnection* GetConnection(); //----------------------------------------------------------------------- // Summary: // This method run parse for the text. // Parameters: // bShort - [in] If TRUE the short (global blocks only) // class schema is used, otherwise full // (global and onscreen blocks) class schema // is used. // pTxtIter - [in] Text iterator object. // pLCStart - [in] Start text position for parse/reparse. // pLCEnd - [in] End text position for parse/reparse. // bSendProgressEvents - [in] If TRUE the progress parsing events // will be sent using connection object. // Remarks: // Special parameters values: // pLCStart = NULL, pLCEnd = NULL // - parse from the last parsed block to the end of the text // // pLCStart = XTP_EDIT_LINECOL::Pos1, pLCEnd = NULL // - parse (reparse) all text from the begin // Returns: // Parse result as flag from enum XTPSyntaxEditLexParseResult. //----------------------------------------------------------------------- virtual int RunParseUpdate(BOOL bShort, CTextIter* pTxtIter, const XTP_EDIT_LINECOL* pLCStart = NULL, const XTP_EDIT_LINECOL* pLCEnd = NULL, BOOL bSendProgressEvents = FALSE); //----------------------------------------------------------------------- // Summary: // Returns text region for which schema was updated during last // parse/reparse operation. // Returns: // CXTPSyntaxEditTextRegion object. //----------------------------------------------------------------------- virtual const CXTPSyntaxEditTextRegion& GetUpdatedTextRegion() const; //----------------------------------------------------------------------- // Summary: // This method run parse for the text on screen. // Parameters: // pTxtIter - [in] Text iterator object. // nRowStart - [in] Start row for parse. // nRowEnd - [in] End row for parse. // rPtrScreenSchFirstTB - [out] Reference to store first text // block of text schema which is built. // Remarks: // This method perform full parsing for the specified text region // using previously parsed short text schema (or global blocks schema). // Returns: // TRUE if successful, FALSE otherwise //----------------------------------------------------------------------- virtual BOOL RunParseOnScreen(CTextIter* pTxtIter, int nRowStart, int nRowEnd, CXTPSyntaxEditLexTextBlockPtr& rPtrScreenSchFirstTB ); //----------------------------------------------------------------------- // Summary: // This method get row as list of blocks with different colors // to draw. // Parameters: // pTxtIter - [in] Text iterator object. // nRow - [in] Row number. // nColFrom - [in] Row col to get colors from. // nColTo - [in] Row col to get colors to. // clrDefault - [in] Default colors. // rBlocks - [out] List of color blocks. // pptrTBStartCache - [in out] Cached text block to start search. // May be NULL. // pFirstSchTB - [in] External text schema first block or NULL. // Used for OnScreen schemas. // Remarks: // This method build list of color blocks for the specified row // using external or internal text schema. //----------------------------------------------------------------------- virtual void GetRowColors(CTextIter* pTxtIter, int nRow, int nColFrom, int nColTo, const XTP_EDIT_COLORVALUES& clrDefault, CXTPSyntaxEditTextBlockList* rBlocks, CXTPSyntaxEditLexTextBlockPtr* pptrTBStartCache = NULL, CXTPSyntaxEditLexTextBlock* pFirstSchTB = NULL); //----------------------------------------------------------------------- // Summary: // This method get row as list of collapsible blocks which // include this row. // Parameters: // nRow - [in] Row number. By Leva: passing nRow < 0 will cause // to return block for all rows // rArBlocks - [out] List of collapsible blocks which // include this row. // pptrTBStartCache - [in out] Cached text block to start search. // May be NULL. // Remarks: // This method build list of collapsible blocks which include // the specified row using external or internal text schema. //----------------------------------------------------------------------- virtual void GetCollapsableBlocksInfo(int nRow, CXTPSyntaxEditRowsBlockArray& rArBlocks, CXTPSyntaxEditLexTextBlockPtr* pptrTBStartCache = NULL); //----------------------------------------------------------------------- // Summary: // This helper method read attributes of the text from lex class // of specified text block. // Parameters: // rTB - [out] Draw text block object to fill text attributes. // pTextBlock - [in] Text block object. //----------------------------------------------------------------------- virtual void GetTextAttributes(XTP_EDIT_TEXTBLOCK& rTB, CXTPSyntaxEditLexTextBlock* pTextBlock); //----------------------------------------------------------------------- // Summary: // Apply color theme to the text schema. // Parameters: // pTheme - [in] A pointer to Color Theme object. //----------------------------------------------------------------------- virtual void ApplyTheme(CXTPSyntaxEditColorTheme* pTheme); //-------------------------------------------------------------------- // Summary: // Load class schema. // Parameters: // arClassInfo - [in] A reference to CXTPSyntaxEditLexClassInfoArray array. // Returns: // TRUE if successful, FALSE otherwise //-------------------------------------------------------------------- BOOL LoadClassSchema(CXTPSyntaxEditLexClassInfoArray* arClassInfo); //-------------------------------------------------------------------- // Summary: // Determine is this schema support specified file extension. // Parameters: // strExt - [in] Extension string. // Remarks: // Extension string format: ".ext" // For example: ".cpp" // Returns: // TRUE if specified file extension is supported, FALSE otherwise. //-------------------------------------------------------------------- BOOL IsFileExtSupported(const CString& strExt); //-------------------------------------------------------------------- // Summary: // Call this member function before using schema object. // Remarks: // To make edit control startup faster - schemas do not built // during loading. This member function build the schema if necessary // (or do nothing). //-------------------------------------------------------------------- void BuildIfNeed(); //-------------------------------------------------------------------- // Summary: // Get top lex class for specified file extension. // Parameters: // strExt - [in] Extension string. // Remarks: // Extension string format: ".ext" // For example: ".cpp" // InternalAddRef() is called for the returned object. // Returns: // Pointer to the lex class or NULL. //-------------------------------------------------------------------- CXTPSyntaxEditLexClass* GetTopClassForFileExt(const CString& strExt); //-------------------------------------------------------------------- // Summary: // Get text block by ID. Used together with xtpEditOnTextBlockParsed // notification. // Parameters: // dwID - [in] ID from xtpEditOnTextBlockParsed notification. // Remarks: // InternalAddRef() is called for the returned object. // Returns: // Pointer to the text block or NULL. //-------------------------------------------------------------------- virtual CXTPSyntaxEditLexTextBlock* GetLastParsedBlock(WPARAM dwID = 0); //-------------------------------------------------------------------- // Summary: // Get first text schema block.. // Remarks: // InternalAddRef() is called for the returned object. // Returns: // Pointer to the text block or NULL. //-------------------------------------------------------------------- CXTPSyntaxEditLexTextBlock* GetBlocks(); //-------------------------------------------------------------------- // Summary: // Get critical section object to lock schema data (text blocks and others). // Returns: // Pointer to the critical section object. //-------------------------------------------------------------------- CMutex* GetDataLoker(); //-------------------------------------------------------------------- // Summary: // Get critical section object to lock class schema. // Returns: // Pointer to the critical section object. //-------------------------------------------------------------------- CMutex* GetClassSchLoker(); //-------------------------------------------------------------------- // Summary: // Get event object to break parsing process. // Returns: // Pointer to the event object. //-------------------------------------------------------------------- CEvent* GetBreakParsingEvent(); //{{AFX_CODEJOCK_PRIVATE static void AFX_CDECL TraceClrBlocks(CXTPSyntaxEditTextBlockArray& arBlocks); void TraceTxtBlocks(BOOL bFull); // for DEBUG only //}}AFX_CODEJOCK_PRIVATE protected: //======================================================================== // Summary: // This enum describes set of UpdateTextBlocks() return results. //======================================================================== enum XTPSyntaxEditUpdateTBRes { xtpEditUTBNothing = 0, // void result xtpEditUTBError = 0x0001, // Error result. xtpEditUTBReparse = 0x0002, // one or few global blocks changed and reparse is need. xtpEditUTBNearestUpdated = 0x0100, // This flag returned from UpdateTBNearest() only. }; //-------------------------------------------------------------------- // Summary: // Get Class Schema for this text schema.. // Remarks: // InternalAddRef() is called for the returned object. // Returns: // Pointer to the Class Schema object. //-------------------------------------------------------------------- CXTPSyntaxEditLexClassSchema* GetClassSchema(); //----------------------------------------------------------------------- // Summary: // Apply color theme to specified lex classes. // Parameters: // pTheme - [in] A pointer to Color Theme object. // ptrClasses - [in] A pointer to lex classes array. // See Also: // ApplyTheme(). //----------------------------------------------------------------------- virtual void ApplyThemeRecursive(CXTPSyntaxEditColorTheme* pTheme, CXTPSyntaxEditLexClassPtrArray* ptrClasses); //----------------------------------------------------------------------- // Summary: // Update text schema positions after editing action. // Parameters: // posFrom - [in] Start editing position. // posTo - [in] End editing position. // eEditAction - [in] Edit action. See XTPSyntaxEditEditAction. // Returns: // Update result - values from enum XTPSyntaxEditUpdateTBRes. //----------------------------------------------------------------------- int UpdateTextBlocks(XTP_EDIT_LINECOL posFrom, XTP_EDIT_LINECOL posTo, int eEditAction); //{{AFX_CODEJOCK_PRIVATE virtual int RunChildren(CTextIter* pTxtIter, CXTPSyntaxEditLexTextBlockPtr ptrTxtBlock, CXTPSyntaxEditLexClass* pBase, CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt = NULL); virtual CXTPSyntaxEditLexTextBlock* GetPrevBlock(BOOL bWithAddRef = TRUE); virtual CXTPSyntaxEditLexTextBlock* GetNewBlock(); //}}AFX_CODEJOCK_PRIVATE private: int UpdateTBNearest(CXTPSyntaxEditLexTextBlock* pNarestTB1, int nLineDiff, int nColDiff, XTP_EDIT_LINECOL posFrom, XTP_EDIT_LINECOL posTo, int eEditAction ); //------------------------------- CXTPSyntaxEditLexTextBlock* FindNearestTextBlock(XTP_EDIT_LINECOL posText); virtual BOOL InitScreenSch(CTextIter* pTxtIter, int nRowStart, int nRowEnd, CXTPSyntaxEditLexTextBlockPtr& rPtrScreenSchFirstTB, CXTPSyntaxEditLexTextBlockPtr& rPtrTBParentToRun); virtual CXTPSyntaxEditLexTextBlockPtr InitScreenSch_RunTopClass(CTextIter* pTxtIter); virtual CXTPSyntaxEditLexTextBlock* CopyShortTBtoFull(CXTPSyntaxEditLexTextBlock* pTB); virtual CXTPSyntaxEditLexClass* FindLexClassByID(CXTPSyntaxEditLexClassPtrArray* pClassesAr, int nClassID); virtual int Run_OnScreenTBStack(CTextIter* pTxtIter, CXTPSyntaxEditLexTextBlock* pTBParentToRun, CXTPSyntaxEditLexOnScreenParseCnt* pRunCnt); virtual void UpdateLastSchBlock(CXTPSyntaxEditLexTextBlock* pLastTB, BOOL bPermanently = FALSE); virtual CXTPSyntaxEditLexTextBlock* GetLastSchBlock(BOOL bWithAddRef = TRUE); virtual UINT SendEvent_OnTextBlockParsed(CXTPSyntaxEditLexTextBlock* pTB); virtual int Run_ParseUpdate0(BOOL bShort, CTextIter* pTxtIter, const XTP_EDIT_LINECOL* pLCStart, const XTP_EDIT_LINECOL* pLCEnd, BOOL bSendProgressEvents); virtual int Run_ClassesUpdate1(CTextIter* pTxtIter, CXTPSyntaxEditLexTextBlockPtr ptrStartTB, BOOL bStarted); virtual int Run_ClassesUpdate2(CTextIter* pTxtIter, CXTPSyntaxEditLexClassPtrArray* pArClasses, CXTPSyntaxEditLexTextBlockPtr ptrParentTB, CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt = NULL); virtual BOOL IsBlockStartStillHere(CTextIter* pTxtIter, CXTPSyntaxEditLexTextBlock* pTB); virtual void FinishNewChain(BOOL bByBreak, BOOL bEOF); virtual void UpdateNewChainParentsChildren(); virtual void EndBlocksByParent(CXTPSyntaxEditLexTextBlock* pTBStart, CXTPSyntaxEditLexTextBlock* pTBEnd); virtual void SeekNextEx(CTextIter* pTxtIter, CXTPSyntaxEditLexClass* pRunClass = NULL, CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt = NULL, int nChars = 1 ); static void AFX_CDECL AddClrBlock(XTP_EDIT_TEXTBLOCK& rClrB, CXTPSyntaxEditTextBlockArray& arBlocks); //==== Run parse update context members ==== CXTPSyntaxEditTextRegion m_curInvalidZone; CXTPSyntaxEditLexTextBlockPtr m_ptrNewChainTB1; CXTPSyntaxEditLexTextBlockPtr m_ptrNewChainTB2; CXTPSyntaxEditLexTextBlockPtr m_ptrOldChainTBFirst; typedef CMap CXTPSyntaxEditLexID2TBmap; CXTPSyntaxEditLexID2TBmap m_mapLastParsedBlocks; CXTPSyntaxEditLexTextBlockPtr m_ptrLastParsedBlock; BOOL m_bSendProgressEvents; int m_nNoEndedClassesCount; //==== END Run parse update context members ==== private: //CCriticalSection m_csData; //CCriticalSection m_csClassSch; CMutex m_lockData; CMutex m_lockClassSch; CEvent m_evBreakParsing; CXTPSyntaxEditLexClassSchema* m_pClassSchema; CXTPSyntaxEditLexTextBlockPtr m_ptrFirstBlock; CXTPSyntaxEditLexTextBlockPtr m_ptrLastSchBlock; int m_nSeekNext_TagWaitChars; CString m_strSchName; CXTPNotifyConnectionMT* m_pConnectMT; }; //=========================================================================== // Summary: // This class used to 'run' lex schema parsing in separate thread. // It also control this working thread and provide interthread interaction. //=========================================================================== class _XTP_EXT_CLASS CXTPSyntaxEditLexParser : public CXTPCmdTarget { public: //----------------------------------------------------------------------- // Summary: // Default object constructor. //----------------------------------------------------------------------- CXTPSyntaxEditLexParser(); //----------------------------------------------------------------------- // Summary: // Object destructor. Handles clean up and deallocations. //----------------------------------------------------------------------- virtual ~CXTPSyntaxEditLexParser(); //------------------------------------------------------------------------- // Summary: // Use this member function to stop parsing, destroy working thread and // unadvise from all events. // See Also: CloseParseThread, StopParseInThread //------------------------------------------------------------------------- virtual void Close(); //------------------------------------------------------------------------- // Summary: // Use this member function to stop parsing, destroy working thread. // See Also: Close, StopParseInThread //------------------------------------------------------------------------- virtual void CloseParseThread(); //----------------------------------------------------------------------- // Summary: // Use this member function to start parsing of specified text range // in separate (working) thread. If parser already running and parse // other text range, the new range added to a queue. // Parameters: // pBuffer - A pointer to CXTPSyntaxEditBufferManager object. // pLCStart - Start text position to reparse or NULL to start from begin. // pLCEnd - End text position to reparse or NULL to parse until end. // eEdinAction - Zero (0) or value from XTPSyntaxEditEditAction enum. // bRunWithoutWait - Start parse immediately or wait a timeout specified // in global schema options. // See Also: StopParseInThread, CloseParseThread //----------------------------------------------------------------------- virtual void StartParseInThread(CXTPSyntaxEditBufferManager* pBuffer, const XTP_EDIT_LINECOL* pLCStart = NULL, const XTP_EDIT_LINECOL* pLCEnd = NULL, int eEdinAction = 0, BOOL bRunWithoutWait = FALSE); //------------------------------------------------------------------------- // Summary: // Use this member function to stop parsing. // See Also: Close, StartParseInThread //------------------------------------------------------------------------- virtual void StopParseInThread(); //------------------------------------------------------------------------- // Summary: // Use this member function to stop parsing in thread before call // OnEditChanged. // See Also: OnEditChanged //------------------------------------------------------------------------- virtual void OnBeforeEditChanged(); //----------------------------------------------------------------------- // Summary: // Use this member function to reparse text after editing. // Parameters: // posFrom - Start position for edit action. // posTo - End position for edit action. // eEditAction - Value from XTPSyntaxEditEditAction enum. // pBuffer - A pointer to CXTPSyntaxEditBufferManager object. // See Also: OnBeforeEditChanged //----------------------------------------------------------------------- virtual void OnEditChanged(const XTP_EDIT_LINECOL& posFrom, const XTP_EDIT_LINECOL& posTo, int eEditAction, CXTPSyntaxEditBufferManager* pBuffer); //----------------------------------------------------------------------- // Summary: // Use this member function to get active text shema. // Returns: // A pointer to CXTPSyntaxEditLexTextSchema. // See Also: SetTextSchema //----------------------------------------------------------------------- virtual CXTPSyntaxEditLexTextSchema* GetTextSchema(); //----------------------------------------------------------------------- // Summary: // Use this member function to set active text shema. // Parameters: // pTextSchema - A pointer to CXTPSyntaxEditLexTextSchema. // See Also: GetTextSchema //----------------------------------------------------------------------- virtual void SetTextSchema(CXTPSyntaxEditLexTextSchema* pTextSchema); //----------------------------------------------------------------------- // Summary: // Use this member function to get text shema global options. // Parameters: // strExt - A file extension to lookup schema. // Returns: // A pointer to CXTPSyntaxEditLexParserSchemaOptions. //----------------------------------------------------------------------- virtual const CXTPSyntaxEditLexParserSchemaOptions* GetSchemaOptions(const CString& strExt); //----------------------------------------------------------------------- // Summary: // Get priority for a working thread. // Returns: // A working thread priority. // See Also: SetParseThreadPriority, CWinThread::GetThreadPriority //----------------------------------------------------------------------- virtual int GetParseThreadPriority(); //----------------------------------------------------------------------- // Summary: // Set priority for a working thread. // Parameters: // nPriority - A new working thread priority. // Returns: // TRUE if successful, FALSE otherwise. // See Also: // GetParseThreadPriority, CWinThread::GetThreadPriority //----------------------------------------------------------------------- virtual BOOL SetParseThreadPriority(int nPriority); //----------------------------------------------------------------------- // Summary: // Use this member function to get Auto Complete words for active // text shema. // Parameters: // rArTokens - An array to store Auto Complete words. // bAppend - If this parameter TRUE - array will be appended, // otherwise previous items will be removed from array. // Returns: // TRUE if successful, FALSE otherwise. //----------------------------------------------------------------------- virtual BOOL GetTokensForAutoCompleate(CXTPSyntaxEditLexTokensDefArray& rArTokens, BOOL bAppend); //----------------------------------------------------------------------- // Summary: // Returns notification connection. // Returns: // CXTPNotifyConnectionPtr pointer. //----------------------------------------------------------------------- virtual CXTPNotifyConnection* GetConnection(); protected: //{{AFX_CODEJOCK_PRIVATE class CXTPSyntaxEditParseThreadParams { public: CXTPSyntaxEditParseThreadParams(); void AddParseZone(const CXTPSyntaxEditTextRegion& rZone); //--------------------------------- CMutex lockThreadParams; CXTPSyntaxEditBufferManager* ptrBuffer; CXTPSyntaxEditInvalidZoneArray arInvalidZones; CEvent evParseRun; CEvent evRunWithoutWait; CEvent evExitThread; }; virtual CXTPSyntaxEditParseThreadParams* GetParseInThreadParams(); //}}AFX_CODEJOCK_PRIVATE //{{AFX_CODEJOCK_PRIVATE virtual void SelfCloseParseThread(); static UINT AFX_CDECL ThreadParseProc(LPVOID); CCriticalSection m_csParserData; CWinThread* m_pParseThread; int m_nParseThreadPriority; // Saved priority to the parse thread CXTPSyntaxEditParseThreadParams m_PThreadParams; CXTPSyntaxEditLexTextSchema* m_ptrTextSchema; typedef CMap CXTPSyntaxEditLexParserSchemaOptionsMap; CXTPSyntaxEditLexParserSchemaOptionsMap m_mapSchOptions; CXTPSyntaxEditLexParserSchemaOptions* m_pSchOptions_default; CXTPNotifyConnection* m_pConnection; CXTPNotifySink* m_pSinkMT; //}}AFX_CODEJOCK_PRIVATE //{{AFX_CODEJOCK_PRIVATE virtual void OnParseEvent_NotificationHandler(XTP_NOTIFY_CODE Event, WPARAM wParam, LPARAM lParam); virtual void GetStrsFromLVArray(CXTPSyntaxEditLexVariant* pLVArray, CStringArray& rArStrs) const; virtual BOOL ReadSchemaOptions(const CString& strExt, CXTPSyntaxEditLexTextSchema* pTextSchema, CXTPSyntaxEditLexParserSchemaOptions* pOpt); //}}AFX_CODEJOCK_PRIVATE private: void RemoveAllOptions(); }; //}}AFX_CODEJOCK_PRIVATE //////////////////////////////////////////////////////////////////////////// AFX_INLINE const CXTPSyntaxEditTextRegion& CXTPSyntaxEditLexTextSchema::GetUpdatedTextRegion() const { return m_curInvalidZone; } AFX_INLINE CMutex* CXTPSyntaxEditLexTextSchema::GetDataLoker() { return &m_lockData; } AFX_INLINE CMutex* CXTPSyntaxEditLexTextSchema::GetClassSchLoker() { return &m_lockClassSch; } AFX_INLINE CEvent* CXTPSyntaxEditLexTextSchema::GetBreakParsingEvent() { return &m_evBreakParsing; } AFX_INLINE XTP_EDIT_LINECOL CXTPSyntaxEditLexTextBlock::GetPosEndLC(BOOL bMaxIfInvalid) { if(!m_PosEndLC.IsValidData()) { return bMaxIfInvalid ? XTP_EDIT_LINECOL::MAXPOS : XTP_EDIT_LINECOL::MINPOS; } return m_PosEndLC; } AFX_INLINE DWORD CXTPSyntaxEditLexTextBlock::GetStartTagEndXLC() { return m_PosStartLC.GetXLC() + m_nStartTagLen; } AFX_INLINE DWORD CXTPSyntaxEditLexTextBlock::GetEndTagBeginXLC() { return m_PosEndLC.GetXLC() - (m_nEndTagXLCLen > 0 ? m_nEndTagXLCLen : 0); } AFX_INLINE DWORD CXTPSyntaxEditLexTextBlock::GetEndTagEndXLC() { return m_PosEndLC.GetXLC() - (m_nEndTagXLCLen < 0 ? m_nEndTagXLCLen : 0); } } //////////////////////////////////////////////////////////////////////////// //#pragma warning(pop) //////////////////////////////////////////////////////////////////////////// #endif // !defined(__XTPSYNTAXEDITLEXPARSER_H__)