开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPSyntaxEditLexParser.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：118k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditLexParser.cpp：源码内容
  1. // XTPSyntaxEditLexParser.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME SYNTAX EDIT LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. //////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. // common includes
  24. #include "Common/XTPNotifyConnection.h"
  25. #include "Common/XTPSmartPtrInternalT.h"
  27. // syntax editor includes
  28. #include "XTPSyntaxEditDefines.h"
  29. #include "XTPSyntaxEditStruct.h"
  30. #include "XTPSyntaxEditLexPtrs.h"
  31. #include "XTPSyntaxEditLexClassSubObjT.h"
  32. #include "XTPSyntaxEditTextIterator.h"
  33. #include "XTPSyntaxEditSectionManager.h"
  34. #include "XTPSyntaxEditLexCfgFileReader.h"
  35. #include "XTPSyntaxEditLexClassSubObjDef.h"
  36. #include "XTPSyntaxEditLexClass.h"
  37. #include "XTPSyntaxEditLexParser.h"
  38. #include "XTPSyntaxEditLexColorFileReader.h"
  39. #include "XTPSyntaxEditBufferManager.h"
  40. #include "XTPSyntaxEditCtrl.h"
  42. #include <afxmt.h>
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. #ifdef _DEBUG
  51. //  #define DBG_TRACE_LOAD_CLASS_SCH
  53. // Trace text blocks start,end when parser running;
  54. //  #define DBG_TRACE_PARSE_START_STOP TRACE
  56. // Trace text blocks start,end when parser running;
  57. //  #define DBG_TRACE_PARSE_RUN_BLOCKS TRACE
  59. // Trace updating schema mechanism when parser running;
  60. //  #define DBG_TRACE_PARSE_RUN_UPDATE TRACE
  62. //  #define DBG_TRACE_PARSE_RUN_RESULTS
  64. //  #define DBG_TRACE_PARSE_TIME
  65. //  #define DBG_TRACE_PARSE_TIME_DLG
  67. //  #define DBG_TRACE_DRAW_BLOCKS
  68. #endif
  70. #ifndef DBG_TRACE_PARSE_RUN_BLOCKS
  71. #define DBG_TRACE_PARSE_RUN_BLOCKS
  72. #endif
  73. #ifndef DBG_TRACE_PARSE_RUN_UPDATE
  74. #define DBG_TRACE_PARSE_RUN_UPDATE
  75. #endif
  76. #ifndef DBG_TRACE_PARSE_START_STOP
  77. #define DBG_TRACE_PARSE_START_STOP
  78. #endif
  80. ////////////////////////////////////////////////////////////////////////////
  81. #ifdef _DEBUG
  82. #define DBG_TRACE_TIME_BEGIN(nID) DWORD dbg_TT_##nID##_dwTime_0 = ::GetTickCount();
  84. #define DBG_TRACE_TIME_END(nID, strComment) { DWORD dwTime1 = ::GetTickCount(); 
  85. TRACE(_T("%s (%.3f sec) n"), strComment, labs(dwTime1-dbg_TT_##nID##_dwTime_0)/1000.0); }
  87. class C_DBG_Time {
  88. CString m_strComment;
  89. DWORD m_dwTime0;
  91. public:
  92. C_DBG_Time(LPCTSTR lpcszComment)
  93. {
  94. m_dwTime0 = ::GetTickCount();
  95. m_strComment = lpcszComment;
  96. };
  97. ~C_DBG_Time()
  98. {
  99. DWORD dwTime1 = ::GetTickCount();
  100. TRACE(_T("%s (%.3f sec) n"), (LPCTSTR)m_strComment, labs(dwTime1-m_dwTime0)/1000.0);
  101. };
  102. };
  103. //#define DBG_TRACE_TIME(nID, strComment) C_DBG_Time dbg_TT_##nID(strComment);
  104. #endif
  106. #ifndef DBG_TRACE_TIME
  107. #define DBG_TRACE_TIME(nID, strComment)
  108. #endif
  110. ////////////////////////////////////////////////////////////////////////////
  111. using namespace XTPSyntaxEditLexAnalyser;
  113. namespace XTPSyntaxEditLexAnalyser
  114. {
  115. extern CXTPSyntaxEditLexAutomatMemMan* XTPGetLexAutomatMemMan();
  117. extern void ConcatenateLVArrays(CXTPSyntaxEditLexVariantPtrArray* pArDest,
  118. CXTPSyntaxEditLexVariantPtrArray* pAr2, int nMaxCount = INT_MAX);
  120. extern BOOL SortTagsInLexVarArray(CXTPSyntaxEditLexVariantPtrArray& rarTags,
  121. BOOL bAscending, BOOL bNoCase);
  123. int FindStrCount(const CStringArray& rarData, LPCTSTR pcszStr, BOOL bCase = FALSE)
  124. {
  125. int nStrCount = 0;
  126. int nCount = (int)rarData.GetSize();
  127. for (int i = 0; i < nCount; i++)
  128. {
  129. const CString& strI = rarData[i];
  131. if (bCase)
  132. {
  133. if (strI.Compare(pcszStr) == 0)
  134. {
  135. nStrCount++;
  136. }
  137. }
  138. else
  139. {
  140. if (strI.CompareNoCase(pcszStr) == 0)
  141. {
  142. nStrCount++;
  143. }
  144. }
  145. }
  146. return nStrCount;
  147. }
  149. int FindStr(const CStringArray& rarData, LPCTSTR pcszStr, BOOL bCase = FALSE)
  150. {
  151. int nCount = (int)rarData.GetSize();
  152. for (int i = 0; i < nCount; i++)
  153. {
  154. const CString& strI = rarData[i];
  156. if (bCase)
  157. {
  158. if (strI.Compare(pcszStr) == 0)
  159. {
  160. return i;
  161. }
  162. }
  163. else
  164. {
  165. if (strI.CompareNoCase(pcszStr) == 0)
  166. {
  167. return i;
  168. }
  169. }
  170. }
  171. return -1;
  172. }
  174. int Find_noCase(CStringArray& rarData, LPCTSTR strData)
  175. {
  176. return FindStr(rarData, strData, FALSE);
  177. }
  179. void AddIfNeed_noCase(CStringArray& rarData, LPCTSTR strNew)
  180. {
  181. int nFIdx = Find_noCase(rarData, strNew);
  182. if (nFIdx < 0)
  183. {
  184. rarData.Add(strNew);
  185. }
  186. }
  188. void ConcatenateArrays_noCase(CStringArray& rarDest, CStringArray& rarSrc)
  189. {
  190. int nCount = (int)rarSrc.GetSize();
  191. for (int i = 0; i < nCount; i++)
  192. {
  193. CString strI = rarSrc[i];
  194. AddIfNeed_noCase(rarDest, strI);
  195. }
  197. }
  199. BOOL IsEventSet(HANDLE hEvent)
  200. {
  201. DWORD dwRes = ::WaitForSingleObject(hEvent, 0);
  202. return dwRes == WAIT_OBJECT_0;
  203. }
  205. BOOL IsMutexLocked(CMutex* pMu)
  206. {
  207. if (!pMu)
  208. {
  209. ASSERT(FALSE);
  210. return FALSE;
  211. }
  212. BOOL bEntered = pMu->Lock(0);
  213. if (bEntered)
  214. {
  215. pMu->Unlock();
  216. }
  217. return !bEntered;
  218. }
  221. CString DBG_TraceIZone(const XTP_EDIT_LINECOL* pLCStart, const XTP_EDIT_LINECOL* pLCEnd)
  222. {
  223. CString sDBGpos, sTmp;
  224. if (pLCStart && !pLCEnd && pLCStart->GetXLC() == XTP_EDIT_XLC(1, 0) )
  225. {
  226. sDBGpos = _T("All:(1,0 - NULL)");
  227. }
  228. else if (pLCStart || pLCEnd)
  229. {
  230. sDBGpos = _T("Part:(");
  232. sTmp = _T("NULL");
  233. if (pLCStart)
  234. {
  235. sTmp.Format(_T("%d,%d"), pLCStart->nLine, pLCStart->nCol);
  236. }
  237. sDBGpos += sTmp + _T(" - ");
  239. sTmp = _T("NULL");
  240. if (pLCEnd)
  241. {
  242. sTmp.Format(_T("%d,%d"), pLCEnd->nLine, pLCEnd->nCol);
  243. }
  244. sDBGpos += sTmp;
  246. sDBGpos += _T(")");
  248. } else {
  249. sDBGpos = _T("Rest(NULL - NULL)");
  250. }
  251. return sDBGpos;
  252. }
  254. CString DBG_TraceTB_StartEndCls(CXTPSyntaxEditLexTextBlock* pTB)
  255. {
  256. if (!pTB)
  257. {
  258. return _T("?<NULL> (? - ?) - ?");
  259. }
  260. CString str;
  261. str.Format(_T("(%d,%d - %d,%d) - %s"), pTB->m_PosStartLC.nLine,
  262. pTB->m_PosStartLC.nCol, pTB->m_PosEndLC.nLine, pTB->m_PosEndLC.nCol,
  263. pTB->m_ptrLexClass ? (LPCTSTR)pTB->m_ptrLexClass->GetClassName() : _T("???<NULL>") );
  264. return str;
  265. }
  267. }
  269. //BEGIN_IMPLEMENT_XTPSINK(CXTPSyntaxEditLexParser, m_SinkMT)
  270. //  ON_XTP_NOTIFICATION(xtpEditOnParserStarted,     OnParseEvent_NotificationHandler)
  271. //  ON_XTP_NOTIFICATION(xtpEditOnTextBlockParsed,   OnParseEvent_NotificationHandler)
  272. //  ON_XTP_NOTIFICATION(xtpEditOnParserEnded,       OnParseEvent_NotificationHandler)
  273. //END_IMPLEMENT_XTPSINK
  275. ////////////////////////////////////////////////////////////////////////////
  276. // CXTPSyntaxEditLexTextSchema
  278. void CXTPSyntaxEditTextRegion::Clear()
  279. {
  280. m_posStart.Clear();
  281. m_posEnd.Clear();
  282. }
  284. void CXTPSyntaxEditTextRegion::Set(const XTP_EDIT_LINECOL* pLCStart, const XTP_EDIT_LINECOL* pLCEnd)
  285. {
  286. m_posStart.nLine = INT_MAX;
  287. m_posStart.nCol = 0;
  289. m_posEnd.Clear();
  291. if (pLCStart)
  292. {
  293. m_posStart = *pLCStart;
  294. }
  295. if (pLCEnd)
  296. {
  297. m_posEnd = *pLCEnd;
  298. }
  299. }
  301. CXTPSyntaxEditLexTokensDef::~CXTPSyntaxEditLexTokensDef()
  302. {
  303. }
  305. CXTPSyntaxEditLexTokensDef::CXTPSyntaxEditLexTokensDef(const CXTPSyntaxEditLexTokensDef& rSrc)
  306. {
  307. m_arTokens.Copy(rSrc.m_arTokens);
  308. m_arStartSeps.Copy(rSrc.m_arStartSeps);
  309. m_arEndSeps.Copy(rSrc.m_arEndSeps);
  310. }
  312. const CXTPSyntaxEditLexTokensDef& CXTPSyntaxEditLexTokensDef::operator=(const CXTPSyntaxEditLexTokensDef& rSrc)
  313. {
  314. m_arTokens.RemoveAll();
  315. m_arStartSeps.RemoveAll();
  316. m_arEndSeps.RemoveAll();
  318. m_arTokens.Append(rSrc.m_arTokens);
  319. m_arStartSeps.Append(rSrc.m_arStartSeps);
  320. m_arEndSeps.Append(rSrc.m_arEndSeps);
  322. return *this;
  323. }
  325. CXTPSyntaxEditLexTextSchema::CXTPSyntaxEditLexTextSchema(LPCTSTR pcszSchName):
  326. m_evBreakParsing(FALSE, TRUE)
  327. {
  328. //m_CloserManager.SetParentObject(this);
  330. m_pClassSchema = new CXTPSyntaxEditLexClassSchema();
  331. m_pConnectMT = new CXTPNotifyConnectionMT();
  333. m_nNoEndedClassesCount = 0;
  335. m_curInvalidZone.Clear();
  337. m_mapLastParsedBlocks.InitHashTable(101);
  339. m_nSeekNext_TagWaitChars = 0;
  341. m_strSchName = pcszSchName;
  343. m_bSendProgressEvents = FALSE;
  344. }
  346. CXTPSyntaxEditLexTextSchema::~CXTPSyntaxEditLexTextSchema()
  347. {
  348. Close();
  350. CMDTARGET_RELEASE(m_pClassSchema);
  351. CMDTARGET_RELEASE(m_pConnectMT);
  352. }
  354. CString CXTPSyntaxEditLexTextSchema::GetSchName() const
  355. {
  356. return m_strSchName;
  357. }
  359. //CXTPSyntaxEditLexTextSchemaCloserManPtr CXTPSyntaxEditLexTextSchema::GetCloserManager()
  360. //{
  361. //  CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  362. //  CSingleLock singleLock(GetDataLoker(), TRUE);
  363. //
  364. //  ASSERT(m_CloserManager.m_ptrParentObj || m_CloserManager.m_dwRef == 0);
  365. //  ASSERT(this == (CXTPSyntaxEditLexTextSchema*)m_CloserManager.m_ptrParentObj || !m_CloserManager.m_ptrParentObj);
  366. //
  367. //  m_CloserManager.SetParentObject(this);
  368. //
  369. //  CXTPSyntaxEditLexTextSchemaCloserManPtr ptrRes(&m_CloserManager, TRUE);
  370. //  return ptrRes;
  371. //}
  373. CXTPNotifyConnection* CXTPSyntaxEditLexTextSchema::GetConnection()
  374. {
  375. return m_pConnectMT;
  376. }
  378. CXTPSyntaxEditLexClassSchema* CXTPSyntaxEditLexTextSchema::GetClassSchema()
  379. {
  380. return m_pClassSchema;
  381. }
  383. CXTPSyntaxEditLexTextSchema* CXTPSyntaxEditLexTextSchema::Clone()
  384. {
  385. CXTPSyntaxEditLexTextSchema* ptrNewSch = new CXTPSyntaxEditLexTextSchema(m_strSchName);
  386. if (!ptrNewSch)
  387. {
  388. return NULL;
  389. }
  391. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  392. CSingleLock singleLock(GetDataLoker(), TRUE);
  394. if (!m_pClassSchema->Copy(ptrNewSch->m_pClassSchema))
  395. {
  396. ptrNewSch->InternalRelease();
  397. return NULL;
  398. }
  400. return ptrNewSch;
  401. }
  403. void CXTPSyntaxEditLexTextSchema::Close()
  404. {
  405. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  406. CSingleLock singleLock(GetDataLoker(), TRUE);
  408. RemoveAll();
  409. m_pClassSchema->Close();
  410. }
  412. void CXTPSyntaxEditLexTextSchema::RemoveAll()
  413. {
  414. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  415. CSingleLock singleLock(GetDataLoker(), TRUE);
  417. Close(m_ptrFirstBlock);
  419. m_ptrFirstBlock = NULL;
  421. m_mapLastParsedBlocks.RemoveAll();
  422. m_ptrLastParsedBlock = NULL;
  423. }
  425. void CXTPSyntaxEditLexTextSchema::Close(CXTPSyntaxEditLexTextBlock* pFirst)
  426. {
  427. CXTPSyntaxEditLexTextBlockPtr ptrChTB(pFirst, TRUE);
  429. while (ptrChTB)
  430. {
  431. CXTPSyntaxEditLexTextBlockPtr ptrChTBnext = ptrChTB->m_ptrNext;
  433. ptrChTB->Close();
  435. ptrChTB = ptrChTBnext;
  436. }
  437. }
  439. BOOL CXTPSyntaxEditLexTextSchema::IsBlockStartStillHere(CTextIter* pTxtIter, CXTPSyntaxEditLexTextBlock* pTB)
  440. {
  441. if (!pTxtIter || !pTB || !pTB->m_ptrLexClass)
  442. {
  443. ASSERT(FALSE);
  444. return FALSE;
  445. }
  447. if (!pTxtIter->SeekPos(pTB->m_PosStartLC, m_evBreakParsing))
  448. {
  449. return FALSE;
  450. }
  452. CXTPSyntaxEditLexTextBlockPtr ptrTBtmp;
  454. int nPres = pTB->m_ptrLexClass->RunParse(pTxtIter, this, ptrTBtmp);
  456. BOOL bStarted = (nPres & xtpEditLPR_StartFound) != 0;
  458. return bStarted;
  459. }
  461. // DEBUG ////////////////////////////////////////////////////////////////
  462. #ifdef DBG_TRACE_PARSE_RUN_RESULTS
  463. #define DBG_TRACE_PARSE_RUN_RESULTS_PROC(bFull) TraceTxtBlocks(bFull);
  464. #else
  465. #define DBG_TRACE_PARSE_RUN_RESULTS_PROC(bFull)
  466. #endif
  467. // END DEBUG ////////////////////////////////////////////////////////////
  469. void CXTPSyntaxEditLexTextSchema::TraceTxtBlocks(BOOL bFull)
  470. {
  471. TRACE(_T("n*** DBG_TRACE_PARSE_RUN_RESULTS *** --( %s )---------n"),
  472. bFull ? _T("FULL") : _T("updated part") );
  474. CXTPSyntaxEditLexTextBlockPtr ptrTB = bFull ? m_ptrFirstBlock : m_ptrNewChainTB1;
  476. for (int i = 0; ptrTB && (bFull || ptrTB->m_ptrPrev != m_ptrNewChainTB2); i++)
  477. {
  478. TRACE(_T("(%05d) startPos=(%d,%d) endPos=(%d,%d), [%s]n"), i,
  479. ptrTB->m_PosStartLC.nLine, ptrTB->m_PosStartLC.nCol,
  480. ptrTB->m_PosEndLC.nLine, ptrTB->m_PosEndLC.nCol,
  481. (LPCTSTR)ptrTB->m_ptrLexClass->m_strClassName);
  483. ptrTB = ptrTB->m_ptrNext;
  484. }
  486. }
  488. int CXTPSyntaxEditLexTextSchema::RunParseUpdate(BOOL bShort, CTextIter* pTxtIter,
  489.   const XTP_EDIT_LINECOL* pLCStart,
  490.   const XTP_EDIT_LINECOL* pLCEnd,
  491.   BOOL bSendProgressEvents)
  492. {
  493. CSingleLock singleLock(GetDataLoker(), TRUE);
  494. m_mapLastParsedBlocks.RemoveAll();
  495. singleLock.Unlock();
  497. if (bSendProgressEvents)
  498. {
  499. m_pConnectMT->PostEvent(xtpEditOnParserStarted, 0, 0,
  500.  xtpNotifyGuarantyPost | xtpNotifyDirectCallForOneThread);
  501. }
  503. int nParseRes = Run_ParseUpdate0(bShort, pTxtIter, pLCStart, pLCEnd, bSendProgressEvents);
  505. if (bSendProgressEvents)
  506. {
  507. m_pConnectMT->PostEvent(xtpEditOnParserEnded, nParseRes, 0,
  508.  xtpNotifyGuarantyPost|xtpNotifyDirectCallForOneThread);
  509. }
  511. return nParseRes;
  512. }
  514. int CXTPSyntaxEditLexTextSchema::Run_ParseUpdate0(BOOL bShort, CTextIter* pTxtIter,
  515. const XTP_EDIT_LINECOL* pLCStart,
  516. const XTP_EDIT_LINECOL* pLCEnd,
  517. BOOL bSendProgressEvents)
  518. {
  519. if (!pTxtIter)
  520. {
  521. ASSERT(FALSE);
  522. return xtpEditLPR_Error;
  523. }
  524. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  526. //-------------------------
  527. m_curInvalidZone.Set(pLCStart, pLCEnd);
  529. m_ptrNewChainTB1 = NULL;
  530. m_ptrNewChainTB2 = NULL;
  531. m_ptrOldChainTBFirst = NULL;
  532. m_nNoEndedClassesCount = 0;
  534. m_bSendProgressEvents = bSendProgressEvents;
  536. int nParseRes = 0;
  537. //** (1) ** -------------------------
  538. CXTPSyntaxEditLexTextBlockPtr ptrStartTB = FindNearestTextBlock(m_curInvalidZone.m_posStart);
  539. if (ptrStartTB)
  540. {
  541. nParseRes = Run_ClassesUpdate1(pTxtIter, ptrStartTB, FALSE);
  542. if (nParseRes != -1)
  543. {
  544. if (nParseRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked|xtpEditLPR_RunFinished))
  545. {
  546. DBG_TRACE_PARSE_RUN_RESULTS_PROC(TRUE);
  547. DBG_TRACE_PARSE_RUN_RESULTS_PROC(FALSE);
  549. if (m_ptrNewChainTB1)
  550. {
  551. BOOL bByBreak = (nParseRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked)) != 0;
  552. FinishNewChain(bByBreak, pTxtIter->IsEOF());
  553. }
  554. return nParseRes;
  555. }
  556. }
  557. }
  559. if (!pLCStart || *pLCStart == XTP_EDIT_LINECOL::Pos1 ||
  560. nParseRes == -1 || !ptrStartTB )
  561. {
  562. nParseRes = 0;
  563. m_ptrOldChainTBFirst = m_ptrFirstBlock ? m_ptrFirstBlock->m_ptrNext : NULL;
  565. //** (2) ** -------------------------
  566. CXTPSyntaxEditLexClassPtrArray* ptrArClasses = m_pClassSchema->GetClasses(bShort);
  567. int nCCount = ptrArClasses ? (int)ptrArClasses->GetSize() : 0;
  568. CXTPSyntaxEditLexClassPtr ptrTopClass = nCCount ? ptrArClasses->GetAt(0) : NULL;
  569. BOOL bRunEOF = TRUE;
  571. while (nCCount && (!pTxtIter->IsEOF() || bRunEOF) )
  572. {
  573. bRunEOF = !pTxtIter->IsEOF();
  575. nParseRes = Run_ClassesUpdate2(pTxtIter, ptrArClasses, m_ptrFirstBlock);
  577. if (nParseRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked|xtpEditLPR_RunFinished))
  578. {
  579. DBG_TRACE_PARSE_RUN_RESULTS_PROC(TRUE);
  580. DBG_TRACE_PARSE_RUN_RESULTS_PROC(FALSE);
  582. if (m_ptrNewChainTB1)
  583. {
  584. BOOL bByBreak = (nParseRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked)) != 0;
  585. FinishNewChain(bByBreak, pTxtIter->IsEOF());
  586. }
  587. return nParseRes;
  588. }
  590. //** -------------------------------------------------------------
  591. if (!pTxtIter->IsEOF() && nCCount && !(nParseRes & xtpEditLPR_Iterated))
  592. {
  593. if (IsEventSet(m_evBreakParsing))
  594. {
  595. return xtpEditLPR_RunBreaked;
  596. }
  598. SeekNextEx(pTxtIter, ptrTopClass);
  599. }
  600. }
  601. }
  603. DBG_TRACE_PARSE_RUN_RESULTS_PROC(TRUE);
  604. DBG_TRACE_PARSE_RUN_RESULTS_PROC(FALSE);
  606. if (m_ptrNewChainTB1)
  607. {
  608. BOOL bByBreak = (nParseRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked)) != 0;
  609. FinishNewChain(bByBreak, pTxtIter->IsEOF());
  610. }
  612. return xtpEditLPR_RunFinished;
  613. }
  615. int CXTPSyntaxEditLexTextSchema::Run_ClassesUpdate1(CTextIter* pTxtIter,
  616.   CXTPSyntaxEditLexTextBlockPtr ptrStartTB,
  617.   BOOL bStarted)
  618. {
  619. if (!pTxtIter || !ptrStartTB || !ptrStartTB->m_ptrLexClass)
  620. {
  621. return xtpEditLPR_Error;
  622. }
  624. BOOL bIterated = FALSE;
  626. int nPres = 0;
  628. BOOL bRunEOF = TRUE;
  629. BOOL bEnded = FALSE;
  630. BOOL bStarted1 = bStarted;
  632. if (!bStarted)
  633. {
  634. CXTPSyntaxEditLexTextBlockPtr ptrTB = ptrStartTB;
  635. XTP_EDIT_LINECOL posStart = ptrStartTB->m_PosStartLC;
  637. bStarted1 = IsBlockStartStillHere(pTxtIter, ptrTB);
  639. while (!bStarted1 && ptrTB->m_ptrPrev)
  640. {
  641. ptrTB = ptrTB->m_ptrPrev;
  643. posStart = ptrTB->m_PosStartLC;
  645. bStarted1 = IsBlockStartStillHere(pTxtIter, ptrTB);
  647. if (IsEventSet(m_evBreakParsing))
  648. {
  649. return xtpEditLPR_RunBreaked;
  650. }
  651. }
  653. if (!bStarted1)
  654. {
  655. return -1; // Full reparse
  656. }
  658. if (m_curInvalidZone.m_posEnd.IsValidData() &&
  659. ptrTB->m_PosEndLC > m_curInvalidZone.m_posEnd)
  660. {
  661. if (ptrTB->m_ptrParent || !ptrTB->m_ptrNext)
  662. {
  663. m_curInvalidZone.m_posEnd = ptrTB->m_PosEndLC;
  664. }
  665. else
  666. { // level: file
  667. ASSERT(ptrTB->m_ptrNext);
  668. if (ptrTB->m_ptrNext->m_PosEndLC > m_curInvalidZone.m_posEnd)
  669. {
  670. m_curInvalidZone.m_posEnd = ptrTB->m_ptrNext->m_PosEndLC;
  671. }
  672. }
  673. }
  674. m_curInvalidZone.m_posStart = posStart;
  676. DBG_TRACE_PARSE_RUN_BLOCKS(_T("nREPARSE will start from pos =(%d,%d), Run class [%s] {%d}-noEndedStack n"),
  677. posStart.nLine, posStart.nCol,
  678. ptrTB->m_ptrParent ?
  679. (ptrTB->m_ptrParent->m_ptrLexClass ?
  680. ptrTB->m_ptrParent->m_ptrLexClass->m_strClassName : _T("?<NULL> (parent)") )
  681. :( ptrTB->m_ptrLexClass ?
  682. ptrTB->m_ptrLexClass->m_strClassName : _T("?<NULL>") )
  683. , m_nNoEndedClassesCount );
  685. CString sDBGzone = DBG_TraceIZone(&m_curInvalidZone.m_posStart, &m_curInvalidZone.m_posEnd);
  686. DBG_TRACE_PARSE_RUN_UPDATE(_T("- Parser change invalid Zone [ %s ] n"), sDBGzone);
  688. // Seek iterator to begin of the block
  689. if (!pTxtIter->SeekPos(posStart, m_evBreakParsing))
  690. {
  691. return xtpEditLPR_Error;
  692. }
  694. if (IsEventSet(m_evBreakParsing))
  695. {
  696. return xtpEditLPR_RunBreaked;
  697. }
  699. ASSERT(!m_ptrNewChainTB1);
  701. m_ptrNewChainTB1 = ptrTB;
  703. if (ptrTB->m_ptrPrev)
  704. {
  705. m_ptrNewChainTB1 = ptrTB->m_ptrPrev;
  706. }
  707. m_ptrOldChainTBFirst = m_ptrNewChainTB1->m_ptrNext;
  709. DBG_TRACE_PARSE_RUN_UPDATE(_T("    NewChainTB1: %s n"), DBG_TraceTB_StartEndCls(m_ptrNewChainTB1));
  710. DBG_TRACE_PARSE_RUN_UPDATE(_T("    OldChainTBFirst: %s n"), DBG_TraceTB_StartEndCls(m_ptrOldChainTBFirst));
  712. ptrStartTB = ptrTB;
  713. }
  715. CXTPSyntaxEditLexClassPtr ptrRunClass = ptrStartTB->m_ptrLexClass;
  717. //** 1 **// Run existing block with children until block end
  718. while (bStarted && !bEnded && (bRunEOF || !pTxtIter->IsEOF()) )
  719. {
  720. if (IsEventSet(m_evBreakParsing))
  721. {
  722. return xtpEditLPR_RunBreaked;
  723. }
  725. bRunEOF = !pTxtIter->IsEOF();
  727. BOOL bSkipIterate = FALSE;
  729. nPres = ptrRunClass->RunParse(pTxtIter, this, ptrStartTB);
  731. if (nPres & (xtpEditLPR_Error|/*xtpEditLPR_RunBreaked|*/xtpEditLPR_RunFinished))
  732. {
  733. return nPres;
  734. }
  736. //---------------------------------------------------------------------------
  737. if (nPres & xtpEditLPR_Iterated)
  738. {
  739. bSkipIterate = TRUE;
  740. bIterated = TRUE;
  741. }
  743. //---------------------------------------------------------------------------
  744. bEnded = (nPres & xtpEditLPR_EndFound) != 0;
  746. if (bEnded)
  747. {
  748. CSingleLock singleLock(GetDataLoker(), TRUE);
  750. m_nNoEndedClassesCount--;
  752. int nECount = ptrStartTB->EndChildren(this);
  753. m_nNoEndedClassesCount -= nECount;
  755. //*** VALIDATION (when reparsing)
  756. if (m_ptrNewChainTB2 && m_ptrNewChainTB2->m_ptrNext)
  757. {
  758. while (m_ptrNewChainTB2->m_ptrNext &&
  759. m_ptrNewChainTB2->m_ptrNext->m_PosStartLC < ptrStartTB->m_PosEndLC)
  760. {
  761. m_ptrNewChainTB2->m_ptrNext = m_ptrNewChainTB2->m_ptrNext->m_ptrNext;
  762. }
  763. }
  765. DBG_TRACE_PARSE_RUN_BLOCKS(_T("(%08x) ENDED startPos=(%d,%d) endPos=(%d,%d), [%s] {%d}-noEndedStack n"),
  766. (CXTPSyntaxEditLexTextBlock*)ptrStartTB,
  767. ptrStartTB->m_PosStartLC.nLine, ptrStartTB->m_PosStartLC.nCol, ptrStartTB->m_PosEndLC.nLine,
  768. ptrStartTB->m_PosEndLC.nCol, ptrStartTB->m_ptrLexClass->m_strClassName, m_nNoEndedClassesCount);
  770. SendEvent_OnTextBlockParsed(ptrStartTB);
  771. }
  773. //---------------------------------------------------------------------------
  774. if (!bEnded && !bSkipIterate)
  775. {
  776. if (IsEventSet(m_evBreakParsing))
  777. {
  778. return xtpEditLPR_RunBreaked;
  779. }
  780. SeekNextEx(pTxtIter, ptrRunClass);
  781. }
  782. }
  783. //** end run existing **//
  784. if (bStarted && !bEnded && pTxtIter->IsEOF())
  785. {
  786. CXTPSyntaxEditLexTextBlock* pTB2end = ptrStartTB;
  787. for (; pTB2end; pTB2end = pTB2end->m_ptrParent)
  788. {
  789. pTB2end->m_PosEndLC = pTxtIter->GetPosLC();
  790. }
  791. return xtpEditLPR_RunFinished;
  792. }
  794. if (bStarted && bEnded || pTxtIter->IsEOF())
  795. {
  796. return xtpEditLPR_RunFinished;
  797. }
  799. //===========================================================================
  800. CXTPSyntaxEditLexTextBlockPtr ptrTBrun = ptrStartTB;
  801. if (ptrStartTB->m_ptrParent)
  802. {
  803. ptrTBrun = ptrStartTB->m_ptrParent;
  804. bEnded = FALSE;
  806. if (ptrTBrun->m_PosEndLC >= m_curInvalidZone.m_posStart &&
  807. ptrTBrun->m_PosEndLC <= m_curInvalidZone.m_posEnd)
  808. {
  809. m_nNoEndedClassesCount++;
  810. }
  811. }
  813. if (!bEnded && !pTxtIter->IsEOF())
  814. {
  815. if (IsEventSet(m_evBreakParsing))
  816. {
  817. return xtpEditLPR_RunBreaked;
  818. }
  820. nPres = Run_ClassesUpdate1(pTxtIter, ptrTBrun, bStarted1);
  822. if (nPres & (xtpEditLPR_Error|xtpEditLPR_RunBreaked|xtpEditLPR_RunFinished))
  823. {
  824. return nPres;
  825. }
  826. //---------------------------------
  827. if (nPres & xtpEditLPR_Iterated)
  828. {
  829. bIterated = TRUE;
  830. }
  831. }
  832. //---------------------------------------------------------------------------
  833. return (bIterated ? xtpEditLPR_Iterated : 0) | (pTxtIter->IsEOF() ? xtpEditLPR_RunFinished : 0);
  834. }
  836. int CXTPSyntaxEditLexTextSchema::Run_ClassesUpdate2(CTextIter* pTxtIter,
  837. CXTPSyntaxEditLexClassPtrArray* pArClasses,
  838. CXTPSyntaxEditLexTextBlockPtr ptrParentTB,
  839. CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt)
  840. {
  841. int nCCount = (int)pArClasses->GetSize();
  842. BOOL bIterated = FALSE;
  843. int nReturn = 0;
  845. for (int i = 0; i < nCCount; i++)
  846. {
  847. CXTPSyntaxEditLexClass* pClass = pArClasses->GetAt(i, FALSE);
  848. ASSERT(pClass);
  849. if (!pClass)
  850. continue;
  851. CXTPSyntaxEditLexTextBlockPtr ptrTB = NULL;
  853. int nPres = 0;
  854. BOOL bStarted = FALSE;
  855. BOOL bEnded = FALSE;
  856. BOOL bRunEOF = FALSE;
  858. do
  859. {
  860. if (IsEventSet(m_evBreakParsing))
  861. {
  862. return xtpEditLPR_RunBreaked;
  863. }
  865. bRunEOF = !pTxtIter->IsEOF();
  867. BOOL bSkipIterate = FALSE;
  869. nPres = pClass->RunParse(pTxtIter, this, ptrTB, pOnScreenRunCnt);
  871. if (nPres & (xtpEditLPR_Error|/*xtpEditLPR_RunBreaked|*/xtpEditLPR_RunFinished))
  872. {
  873. return nPres;
  874. }
  876. //---------------------------------------------------------------------------
  877. if ((nPres & xtpEditLPR_StartFound) && ptrTB && !ptrTB->m_ptrPrev)
  878. {
  879. bStarted = TRUE;
  881. CSingleLock singleLock(GetDataLoker(), TRUE);
  883. ptrTB->m_ptrParent = ptrParentTB;
  884. if (ptrTB->m_ptrParent)
  885. {
  886. ptrTB->m_ptrParent->m_ptrLastChild = ptrTB;
  887. }
  889. if (!pOnScreenRunCnt)
  890. {
  891. //*** VALIDATION (when reparsing)
  892. if (m_ptrNewChainTB2 && m_ptrNewChainTB2->m_ptrNext)
  893. {
  894. while (m_ptrNewChainTB2->m_ptrNext &&
  895. m_ptrNewChainTB2->m_ptrNext->m_PosStartLC < ptrTB->m_PosStartLC)
  896. {
  897. m_ptrNewChainTB2->m_ptrNext = m_ptrNewChainTB2->m_ptrNext->m_ptrNext;
  898. }
  900. if (m_ptrNewChainTB2->m_ptrNext && m_curInvalidZone.m_posEnd.IsValidData() )
  901. {
  902. DBG_TRACE_PARSE_RUN_UPDATE(_T("n    <VALIDATE> TB current: %s n"), DBG_TraceTB_StartEndCls(ptrTB));
  903. DBG_TRACE_PARSE_RUN_UPDATE(_T("    <VALIDATE> TB next OLD: %s [NoEndedStack=%d]n"),
  904. DBG_TraceTB_StartEndCls(m_ptrNewChainTB2->m_ptrNext), m_nNoEndedClassesCount);
  906. if (m_ptrNewChainTB2->m_ptrNext->m_PosStartLC == ptrTB->m_PosStartLC &&
  907. ptrTB->IsEqualLexClasses(m_ptrNewChainTB2->m_ptrNext) &&
  908. m_curInvalidZone.m_posEnd.IsValidData() &&
  909. m_ptrNewChainTB2->m_ptrNext->m_PosStartLC > m_curInvalidZone.m_posEnd)
  910. {
  911. // BREAK.
  912. if (m_nNoEndedClassesCount <= 0)
  913. {
  914. FinishNewChain(FALSE, pTxtIter->IsEOF());
  915. return xtpEditLPR_RunFinished;
  916. }
  917. }
  918. }
  919. }
  920. //***
  922. m_nNoEndedClassesCount++;
  923. //**************************
  924. if (!m_ptrNewChainTB1)
  925. {
  926. // Full reparse
  927. m_ptrNewChainTB1 = ptrTB;
  928. m_ptrNewChainTB2 = NULL;
  930. //ASSERT(m_ptrFirstBlock == NULL);
  931. m_ptrFirstBlock = ptrTB;
  933. DBG_TRACE_PARSE_RUN_UPDATE(_T("    NewChainTB1 (&FirstBlock): %s n"), DBG_TraceTB_StartEndCls(m_ptrNewChainTB1));
  934. }
  935. else if (!m_ptrNewChainTB2)
  936. {
  937. m_ptrNewChainTB2 = m_ptrNewChainTB1;
  938. }
  940. if (nPres&xtpEditLPR_TBpop1)
  941. {
  942. if (m_ptrNewChainTB2)
  943. {
  944. if (m_ptrNewChainTB2->m_ptrPrev)
  945. {
  946. m_ptrNewChainTB2->m_ptrPrev->m_ptrNext = ptrTB;
  947. }
  948. ptrTB->m_ptrPrev = m_ptrNewChainTB2->m_ptrPrev;
  949. ptrTB->m_ptrNext = m_ptrNewChainTB2;
  951. m_ptrNewChainTB2->m_ptrPrev = ptrTB;
  952. m_ptrNewChainTB2->m_ptrParent = ptrTB;
  953. }
  954. else
  955. {
  956. m_ptrNewChainTB2 = ptrTB; //SetPrevBlock(ptrTB);
  957. }
  958. }
  959. else
  960. {
  961. if (m_ptrNewChainTB2)
  962. {
  963. ptrTB->m_ptrNext = m_ptrNewChainTB2->m_ptrNext;
  964. ptrTB->m_ptrPrev = m_ptrNewChainTB2; //GetPrevBlock(); //
  965. m_ptrNewChainTB2->m_ptrNext = ptrTB;
  966. }
  967. m_ptrNewChainTB2 = ptrTB; //SetPrevBlock(ptrTB);
  968. }
  969. //**************************
  970. }
  971. else
  972. {
  973. if (nPres&xtpEditLPR_TBpop1)
  974. {
  975. if (pOnScreenRunCnt->m_ptrTBLast)
  976. {
  977. if (pOnScreenRunCnt->m_ptrTBLast->m_ptrPrev)
  978. {
  979. pOnScreenRunCnt->m_ptrTBLast->m_ptrPrev->m_ptrNext = ptrTB;
  980. }
  981. ptrTB->m_ptrPrev = pOnScreenRunCnt->m_ptrTBLast->m_ptrPrev;
  982. ptrTB->m_ptrNext = pOnScreenRunCnt->m_ptrTBLast;
  984. pOnScreenRunCnt->m_ptrTBLast->m_ptrPrev = ptrTB;
  985. pOnScreenRunCnt->m_ptrTBLast->m_ptrParent = ptrTB;
  986. }
  987. else
  988. {
  989. pOnScreenRunCnt->m_ptrTBLast = ptrTB;
  990. }
  991. }
  992. else
  993. {
  994. ptrTB->m_ptrPrev = pOnScreenRunCnt->m_ptrTBLast;
  995. if (pOnScreenRunCnt->m_ptrTBLast)
  996. {
  997. pOnScreenRunCnt->m_ptrTBLast->m_ptrNext = ptrTB;
  998. }
  999. pOnScreenRunCnt->m_ptrTBLast = ptrTB;
  1000. }
  1001. }
  1003. // DEBUG ////////////////////////////////////////////////////////////////
  1004. DBG_TRACE_PARSE_RUN_BLOCKS(_T("(%08x) START startPos=(%d,%d), ______________ [%s] {%d}-noEndedStack n"),
  1005. (CXTPSyntaxEditLexTextBlock*)ptrTB,
  1006. ptrTB->m_PosStartLC.nLine, ptrTB->m_PosStartLC.nCol,
  1007. ptrTB->m_ptrLexClass->m_strClassName, m_nNoEndedClassesCount);
  1008. // END DEBUG ////////////////////////////////////////////////////////////
  1009. }
  1011. //---------------------------------------------------------------------------
  1012. if (nPres & xtpEditLPR_Iterated)
  1013. {
  1014. bSkipIterate = TRUE;
  1015. bIterated = TRUE;
  1016. }
  1018. //---------------------------------------------------------------------------
  1019. bEnded = (nPres & xtpEditLPR_EndFound) != 0;
  1021. if (bEnded)
  1022. {
  1023. CSingleLock singleLock(GetDataLoker(), TRUE);
  1025. m_nNoEndedClassesCount--;
  1027. int nECount = ptrTB->EndChildren(pOnScreenRunCnt ? NULL : this);
  1028. m_nNoEndedClassesCount -= nECount;
  1030. // DEBUG ////////////////////////////////////////////////////////////////
  1031. DBG_TRACE_PARSE_RUN_BLOCKS(_T("(%08x) ENDED startPos=(%d,%d) endPos=(%d,%d), [%s] {%d}-noEndedStack n"),
  1032. (CXTPSyntaxEditLexTextBlock*)ptrTB,
  1033. ptrTB->m_PosStartLC.nLine, ptrTB->m_PosStartLC.nCol,
  1034. ptrTB->m_PosEndLC.nLine, ptrTB->m_PosEndLC.nCol,
  1035. ptrTB->m_ptrLexClass->m_strClassName, m_nNoEndedClassesCount);
  1036. // END DEBUG ////////////////////////////////////////////////////////////
  1038. if (!pOnScreenRunCnt)
  1039. {
  1040. SendEvent_OnTextBlockParsed(ptrTB);
  1041. }
  1042. }
  1043. if (nPres & xtpEditLPR_RunBreaked)
  1044. {
  1045. return nPres;
  1046. }
  1048. //---------------------------------------------------------------------------
  1049. if (bStarted && !bEnded && !bSkipIterate)
  1050. {
  1051. if (IsEventSet(m_evBreakParsing))
  1052. {
  1053. return xtpEditLPR_RunBreaked;
  1054. }
  1056. SeekNextEx(pTxtIter, pClass, pOnScreenRunCnt);
  1057. bIterated = TRUE;
  1058. }
  1060. //---------------------------------------------------------------------------
  1061. if (pOnScreenRunCnt)
  1062. {
  1063. XTP_EDIT_LINECOL lcTextPos = pTxtIter->GetPosLC();
  1064. if (lcTextPos.nLine > pOnScreenRunCnt->m_nRowEnd)
  1065. {
  1066. return xtpEditLPR_RunFinished;
  1067. }
  1068. }
  1069. }
  1070. while (bStarted && !bEnded && (bRunEOF || !pTxtIter->IsEOF()) );
  1072. if (bEnded && pClass->IsRestartRunLoop())
  1073. {
  1074. nReturn |= xtpEditLPR_RunRestart;
  1075. break;
  1076. }
  1077. }
  1079. return nReturn | (bIterated ? xtpEditLPR_Iterated : 0);
  1080. }
  1082. UINT CXTPSyntaxEditLexTextSchema::SendEvent_OnTextBlockParsed(CXTPSyntaxEditLexTextBlock* pTB)
  1083. {
  1084. CSingleLock singleLock(GetDataLoker(), TRUE);
  1086. if (!m_bSendProgressEvents)
  1087. {
  1088. return 0;
  1089. }
  1091. CXTPSyntaxEditLexTextBlockPtr ptrTB(pTB, TRUE);
  1092. WPARAM dwTBid = (WPARAM)pTB;
  1094. m_mapLastParsedBlocks[dwTBid] = ptrTB;
  1095. m_ptrLastParsedBlock.SetPtr(pTB, TRUE);
  1097. BOOL bIsSubscribers = m_pConnectMT->PostEvent(xtpEditOnTextBlockParsed, dwTBid,
  1098. 0, xtpNotifyDirectCallForOneThread);
  1099. if (bIsSubscribers)
  1100. {
  1101. // WARNING: Why? EventsWnd must call GetLastParsedBlock()
  1102. // to withdraw objects from the map!
  1103. //ASSERT(m_mapLastParsedBlocks.GetCount() < 10*1000);
  1104. static BOOL s_bAssert = FALSE;
  1105. if (!s_bAssert && m_mapLastParsedBlocks.GetCount() > 10*1000)
  1106. {
  1107. s_bAssert = TRUE;
  1108. ASSERT(FALSE);
  1109. }
  1111. }
  1112. else
  1113. {
  1114. m_mapLastParsedBlocks.RemoveAll();
  1115. }
  1117. return 0;
  1118. }
  1120. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::GetLastParsedBlock(WPARAM dwID)
  1121. {
  1122. CSingleLock singleLock(GetDataLoker(), TRUE);
  1124. if (dwID)
  1125. {
  1126. CXTPSyntaxEditLexTextBlockPtr ptrTB;
  1127. if (m_mapLastParsedBlocks.Lookup(dwID, ptrTB))
  1128. {
  1129. m_mapLastParsedBlocks.RemoveKey(dwID);
  1131. return ptrTB.Detach();
  1132. }
  1133. }
  1134. else
  1135. {
  1136. return m_ptrLastParsedBlock.GetInterface(TRUE);
  1137. }
  1139. //  ASSERT(FALSE);
  1140. return NULL;
  1141. }
  1143. void CXTPSyntaxEditLexTextSchema::FinishNewChain(BOOL bByBreak, BOOL bEOF)
  1144. {
  1145. CSingleLock singleLock(GetDataLoker(), TRUE);
  1147. CXTPSyntaxEditLexTextBlockPtr ptrTBOldLast = NULL;
  1149. DBG_TRACE_PARSE_RUN_UPDATE(_T("    <F> NewChainTB1: %s n"), DBG_TraceTB_StartEndCls(m_ptrNewChainTB1));
  1151. if (m_ptrNewChainTB2)
  1152. {
  1153. DBG_TRACE_PARSE_RUN_UPDATE(_T("    <F> NewChainTB2-raw: %s n"), DBG_TraceTB_StartEndCls(m_ptrNewChainTB2));
  1154. if (bByBreak && !bEOF)
  1155. {
  1156. // roll back no-ended blocks
  1157. while ( !m_ptrNewChainTB2->m_PosEndLC.IsValidData() &&
  1158. m_ptrNewChainTB2->m_ptrPrev &&
  1159. m_ptrNewChainTB2 != m_ptrNewChainTB1)
  1160. {
  1161. CXTPSyntaxEditLexTextBlockPtr ptrTBclose = m_ptrNewChainTB2;
  1162. m_ptrNewChainTB2 = m_ptrNewChainTB2->m_ptrPrev;
  1163. m_ptrNewChainTB2->m_ptrNext = ptrTBclose->m_ptrNext;
  1165. DBG_TRACE_PARSE_RUN_UPDATE(_T("       <F> CLOSE TB-RollBacked: %s n"), DBG_TraceTB_StartEndCls(ptrTBclose));
  1166. ptrTBclose->Close();
  1167. }
  1168. DBG_TRACE_PARSE_RUN_UPDATE(_T("    <F> NewChainTB2-RollBacked: %s n"), DBG_TraceTB_StartEndCls(m_ptrNewChainTB2));
  1169. }
  1171. // end no-ended blocks
  1172. EndBlocksByParent(m_ptrNewChainTB1, m_ptrNewChainTB2);
  1174. if (m_ptrNewChainTB2 == m_ptrNewChainTB1)
  1175. {
  1176. UpdateLastSchBlock(m_ptrNewChainTB2);
  1177. m_ptrOldChainTBFirst = NULL;
  1178. return;
  1179. }
  1181. // synchronize new and old chains
  1182. while (m_ptrNewChainTB2->m_ptrNext &&
  1183. (m_ptrNewChainTB2->m_ptrNext->m_PosStartLC < m_ptrNewChainTB2->m_PosStartLC ||
  1184.  m_ptrNewChainTB2->m_ptrNext->m_PosStartLC == m_ptrNewChainTB2->m_PosStartLC &&
  1185.  m_ptrNewChainTB2->m_ptrNext->IsEqualLexClasses(m_ptrNewChainTB2) )
  1186. )
  1187. {
  1188. m_ptrNewChainTB2->m_ptrNext = m_ptrNewChainTB2->m_ptrNext->m_ptrNext;
  1189. }
  1191. if (m_ptrNewChainTB2->m_ptrNext)
  1192. {
  1193. m_ptrNewChainTB2->m_ptrNext->m_ptrPrev = m_ptrNewChainTB2;
  1195. m_curInvalidZone.m_posEnd = m_ptrNewChainTB2->m_ptrNext->m_PosStartLC;
  1196. }
  1197. else
  1198. {
  1199. m_curInvalidZone.m_posEnd = m_ptrNewChainTB2->m_PosStartLC;
  1200. }
  1201. if (!bEOF)
  1202. {
  1203. ptrTBOldLast = m_ptrNewChainTB2->m_ptrNext;
  1204. }
  1205. }
  1206. else if (bByBreak)
  1207. {
  1208. if (m_ptrNewChainTB2)
  1209. {
  1210. UpdateLastSchBlock(m_ptrNewChainTB2);
  1211. }
  1213. m_ptrOldChainTBFirst = NULL;
  1214. m_ptrNewChainTB1 = NULL;
  1215. m_ptrNewChainTB2 = NULL;
  1216. m_nNoEndedClassesCount = 0;
  1217. return;
  1218. }
  1219. else
  1220. {
  1221. // No new blocks found after chain branch.
  1222. // (All rest blocks where deleted)
  1223. if (m_ptrNewChainTB1)
  1224. {
  1225. m_ptrNewChainTB1->m_ptrNext = NULL;
  1226. UpdateLastSchBlock(m_ptrNewChainTB1, TRUE);
  1227. }
  1228. else if (m_ptrFirstBlock)
  1229. {
  1230. m_ptrFirstBlock->m_ptrNext = NULL;
  1231. UpdateLastSchBlock(m_ptrFirstBlock, TRUE);
  1232. }
  1233. }
  1235. DBG_TRACE_PARSE_RUN_UPDATE(_T("    <F> OldChainTBFirst: %s n"), DBG_TraceTB_StartEndCls(m_ptrOldChainTBFirst));
  1236. DBG_TRACE_PARSE_RUN_UPDATE(_T("    <F> TBOldLast: %s n"), DBG_TraceTB_StartEndCls(ptrTBOldLast));
  1237. CXTPSyntaxEditLexTextBlockPtr ptrTBOld = m_ptrOldChainTBFirst;
  1238. while (ptrTBOld && ptrTBOld != ptrTBOldLast)
  1239. {
  1240. CXTPSyntaxEditLexTextBlockPtr ptrTBclose = ptrTBOld;
  1241. ptrTBOld = ptrTBOld->m_ptrNext;
  1242. ptrTBclose->Close();
  1243. }
  1245. if (m_ptrNewChainTB2 && m_ptrNewChainTB2->m_ptrNext &&
  1246. m_ptrNewChainTB2->m_ptrNext->IsLookLikeClosed())
  1247. {
  1248. m_ptrNewChainTB2->m_ptrNext = NULL;
  1249. UpdateLastSchBlock(m_ptrNewChainTB2, TRUE);
  1250. }
  1252. //===================================
  1253. if (m_ptrNewChainTB2 && m_ptrNewChainTB1)
  1254. {
  1255. UpdateNewChainParentsChildren();
  1256. }
  1258. //===================================
  1259. if (m_ptrNewChainTB2)
  1260. { // && m_ptrNewChainTB2->m_ptrNext == NULL)
  1261. UpdateLastSchBlock(m_ptrNewChainTB2);
  1262. }
  1264. //-----------------------------------
  1265. m_ptrOldChainTBFirst = NULL;
  1266. m_ptrNewChainTB1 = NULL;
  1267. m_ptrNewChainTB2 = NULL;
  1268. m_nNoEndedClassesCount = 0;
  1269. }
  1271. void CXTPSyntaxEditLexTextSchema::UpdateNewChainParentsChildren()
  1272. {
  1273. CSingleLock singleLock(GetDataLoker(), TRUE);
  1275. if (!m_ptrNewChainTB2 || !m_ptrNewChainTB1)
  1276. {
  1277. return;
  1278. }
  1280. if (m_ptrNewChainTB1 != m_ptrFirstBlock)
  1281. {
  1282. //update children for new chain blocks
  1283. CXTPSyntaxEditLexTextBlock* pTB_chi = m_ptrNewChainTB2->m_ptrNext;
  1284. for (; pTB_chi; pTB_chi = pTB_chi->m_ptrNext)
  1285. {
  1286. if (pTB_chi->m_ptrParent && pTB_chi->m_ptrParent->IsLookLikeClosed())
  1287. {
  1288. CXTPSyntaxEditLexTextBlock* pTB_Par = pTB_chi->m_ptrPrev;
  1289. for (; pTB_Par; pTB_Par = pTB_Par->m_ptrPrev)
  1290. {
  1291. if (pTB_Par->IsInclude(pTB_chi))
  1292. {
  1293. pTB_chi->m_ptrParent.SetPtr(pTB_Par, TRUE);
  1294. ASSERT(!pTB_Par->IsLookLikeClosed());
  1295. break;
  1296. }
  1297. }
  1298. }
  1299. }
  1300. }
  1301. }
  1303. void CXTPSyntaxEditLexTextSchema::EndBlocksByParent(CXTPSyntaxEditLexTextBlock* pTBStart, CXTPSyntaxEditLexTextBlock* pTBEnd)
  1304. {
  1305. CSingleLock singleLock(GetDataLoker(), TRUE);
  1307. if (!pTBStart)
  1308. {
  1309. return;
  1310. }
  1312. CXTPSyntaxEditLexTextBlock* pTB_chi = pTBStart;
  1313. for (; pTB_chi != pTBEnd->m_ptrNext; pTB_chi = pTB_chi->m_ptrNext)
  1314. {
  1315. if (!pTB_chi->m_PosEndLC.IsValidData())
  1316. {
  1317. //ASSERT(pTB_chi->m_ptrParent && pTB_chi->m_ptrParent->m_PosEndLC.IsValidData());
  1318. if (pTB_chi->m_ptrParent && pTB_chi->m_ptrParent->m_PosEndLC.IsValidData())
  1319. {
  1320. pTB_chi->m_PosEndLC = pTB_chi->m_ptrParent->m_PosEndLC;
  1321. }
  1322. }
  1323. }
  1324. }
  1327. int CXTPSyntaxEditLexTextSchema::RunChildren(CTextIter* pTxtIter,
  1328. CXTPSyntaxEditLexTextBlockPtr ptrTxtBlock,
  1329. CXTPSyntaxEditLexClass* pBase,
  1330. CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt)
  1331. {
  1332. if (!pTxtIter || !pBase)
  1333. {
  1334. ASSERT(FALSE);
  1335. return xtpEditLPR_Error;
  1336. }
  1337. int nRes = 0;
  1338. CXTPSyntaxEditLexClassPtrArray* pArClasses[3];
  1339. pArClasses[0] = pBase->GetChildren();
  1340. pArClasses[1] = pBase->GetChildrenDyn();
  1341. pArClasses[2] = pBase->GetChildrenSelfRef();
  1343. for (int i = 0; i < _countof(pArClasses); i++)
  1344. {
  1345. if (pArClasses[i] && pArClasses[i]->GetSize())
  1346. {
  1347. int nResLocal = Run_ClassesUpdate2(pTxtIter, pArClasses[i],
  1348. ptrTxtBlock, pOnScreenRunCnt);
  1349. nRes |= nResLocal;
  1351. if (nRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked|xtpEditLPR_RunFinished|xtpEditLPR_RunRestart))
  1352. {
  1353. break;
  1354. }
  1355. }
  1356. }
  1357. return nRes;
  1358. }
  1360. void CXTPSyntaxEditLexTextSchema::SeekNextEx(CTextIter* pTxtIter,
  1361.    CXTPSyntaxEditLexClass* pRunClass,
  1362.    CXTPSyntaxEditLexOnScreenParseCnt* pOnScreenRunCnt,
  1363.    int nChars )
  1364. {
  1365. if (!pTxtIter || !pRunClass)
  1366. {
  1367. ASSERT(FALSE);
  1368. return;
  1369. }
  1371. pTxtIter->SeekNext(nChars);
  1372. m_nSeekNext_TagWaitChars -= nChars;
  1374. CXTPSyntaxEditLexObj_ActiveTags* pAT = m_pClassSchema->GetActiveTagsFor(pRunClass);
  1375. if (pAT && m_nSeekNext_TagWaitChars)
  1376. {
  1377. int i = 0;
  1378. //BOOL bCase = FALSE; //pRunClass->IsCaseSensitive();
  1380. CString strTmp;
  1381. BOOL bTag = FALSE;
  1383. while (!bTag && !pTxtIter->IsEOF() && m_nSeekNext_TagWaitChars)
  1384. {
  1386. //bTag = CXTPSyntaxEditLexClass::Run_Tags1(pTxtIter, pAT, strTmp, bCase, FALSE);
  1387. //
  1389. bTag = pAT->FindMinWord(pTxtIter->GetText(1024), strTmp, 1024, TRUE, FALSE);
  1391. // for test(DEBUG) Only
  1392. #ifdef DBG_AUTOMAT
  1393. BOOL bCase = FALSE; //pRunClass->IsCaseSensitive();
  1394. CString strTmpX;
  1395. BOOL bTagX = CXTPSyntaxEditLexClass::Run_Tags1(pTxtIter, pAT, strTmpX, bCase, FALSE);
  1396. if (bTagX != bTag)
  1397. {
  1398. //ASSERT(FALSE);
  1400. pAT->BuildAutomat(TRUE);
  1401. bTag = pAT->FindMinWord(pTxtIter->GetText(1024), strTmp, 1024, TRUE, FALSE);
  1402. }
  1404. if (bTag)
  1405. {
  1406. strTmp.Empty();
  1407. bTag = CXTPSyntaxEditLexClass::Run_Tags1(pTxtIter, pAT, strTmp, bCase, FALSE);
  1408. }
  1409. #endif
  1411. if (!bTag)
  1412. {
  1413. pTxtIter->SeekNext(1);
  1414. m_nSeekNext_TagWaitChars--;
  1415. }
  1417. if (++i%10 == 0 && IsEventSet(m_evBreakParsing))
  1418. {
  1419. return;
  1420. }
  1422. if (pOnScreenRunCnt)
  1423. {
  1424. XTP_EDIT_LINECOL lcTextPos = pTxtIter->GetPosLC();
  1425. if (lcTextPos.nLine > pOnScreenRunCnt->m_nRowEnd)
  1426. {
  1427. return;
  1428. }
  1429. }
  1430. }
  1432. ASSERT(bTag || pTxtIter->IsEOF() || !m_nSeekNext_TagWaitChars);
  1433. //----------------------
  1434. if (bTag)
  1435. {
  1436. m_nSeekNext_TagWaitChars = (int)_tcsclen(strTmp);
  1437. ASSERT(m_nSeekNext_TagWaitChars > 0);
  1438. }
  1440. }
  1441. }
  1443. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::GetPrevBlock(BOOL bWithAddRef)
  1444. {
  1445. CSingleLock singleLock(GetDataLoker(), TRUE);
  1447. return m_ptrNewChainTB2.GetInterface(bWithAddRef);
  1448. }
  1450. void CXTPSyntaxEditLexTextSchema::UpdateLastSchBlock(CXTPSyntaxEditLexTextBlock* pLastTB, BOOL bPermanently)
  1451. {
  1452. CSingleLock singleLock(GetDataLoker(), TRUE);
  1454. if (!pLastTB || !m_ptrLastSchBlock || bPermanently)
  1455. {
  1456. m_ptrLastSchBlock.SetPtr(pLastTB, TRUE);
  1457. return;
  1458. }
  1460. if (pLastTB->m_PosStartLC >= m_ptrLastSchBlock->m_PosStartLC)
  1461. {
  1462. m_ptrLastSchBlock.SetPtr(pLastTB, TRUE);
  1463. }
  1464. }
  1466. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::GetLastSchBlock(BOOL bWithAddRef)
  1467. {
  1468. CSingleLock singleLock(GetDataLoker(), TRUE);
  1470. if (m_ptrLastSchBlock && !m_ptrNewChainTB2)
  1471. {
  1472. return m_ptrLastSchBlock.GetInterface(bWithAddRef);
  1473. }
  1475. if (!m_ptrLastSchBlock && m_ptrNewChainTB2)
  1476. {
  1477. return m_ptrNewChainTB2.GetInterface(bWithAddRef);
  1478. }
  1480. if (m_ptrLastSchBlock && m_ptrNewChainTB2)
  1481. {
  1482. if (m_ptrLastSchBlock->m_PosStartLC < m_ptrNewChainTB2->m_PosStartLC)
  1483. {
  1484. return m_ptrNewChainTB2.GetInterface(bWithAddRef);
  1485. }
  1486. else
  1487. {
  1488. return m_ptrLastSchBlock.GetInterface(bWithAddRef);
  1489. }
  1490. }
  1491. return NULL;
  1492. }
  1494. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::GetNewBlock()
  1495. {
  1496. CXTPSyntaxEditLexTextBlock* p = new CXTPSyntaxEditLexTextBlock();
  1497. return p;
  1498. }
  1500. void CXTPSyntaxEditLexTextSchema::GetTextAttributes(XTP_EDIT_TEXTBLOCK& rTB, CXTPSyntaxEditLexTextBlock* pTextBlock)
  1501. {
  1502. if (!pTextBlock || !pTextBlock->m_ptrLexClass)
  1503. {
  1504. return;
  1505. }
  1507. pTextBlock->m_ptrLexClass->GetTextAttributes(rTB);
  1508. }
  1510. void CXTPSyntaxEditLexTextSchema::TraceClrBlocks(CXTPSyntaxEditTextBlockArray& arBlocks)
  1511. {
  1512. // DEBUG ////////////////////////////////////////////////////////////////
  1513. #ifdef DBG_TRACE_DRAW_BLOCKS
  1514. TRACE(_T("n*** bloks --------------------n"));
  1516. for (int i = 0; i < arBlocks.GetSize(); i++)
  1517. {
  1518. XTP_EDIT_TEXTBLOCK BlkI = arBlocks[i];
  1520. TRACE(_T("(%02d) start =%d, ?end=%d, color=%X n"), i, BlkI.nPos,
  1521. BlkI.nNextBlockPos, BlkI.clrBlock.crText);
  1523. }
  1524. TRACE(_T("***n"));
  1525. #else
  1526. UNREFERENCED_PARAMETER(arBlocks);
  1527. #endif
  1528. // END DEBUG ////////////////////////////////////////////////////////////
  1529. }
  1532. void CXTPSyntaxEditLexTextSchema::AddClrBlock(XTP_EDIT_TEXTBLOCK& rClrB,
  1533. CXTPSyntaxEditTextBlockArray& arBlocks)
  1534. {
  1535. #ifdef DBG_TRACE_DRAW_BLOCKS
  1536. TRACE(_T(" --- ADD --- start =%d, ?end=%d, color=%X n"), rClrB.nPos,
  1537. rClrB.nNextBlockPos, rClrB.clrBlock.crText);
  1538. #endif
  1540. int nCount = (int)arBlocks.GetSize();
  1541. //** A. ** new block is included in the existing block
  1542. int i;
  1543. for (i = 0; i < nCount; i++)
  1544. {
  1545. XTP_EDIT_TEXTBLOCK& BlkI = arBlocks[i];
  1546. if (rClrB.nNextBlockPos < BlkI.nPos ||
  1547. rClrB.nPos >= BlkI.nNextBlockPos )
  1548. {
  1549. continue;
  1550. }
  1552. XTP_EDIT_TEXTBLOCK BlkI2;// = BlkI;
  1554. if (rClrB.nPos >= BlkI.nPos &&
  1555. rClrB.nNextBlockPos <= BlkI.nNextBlockPos)
  1556. {
  1557. // override equal block
  1558. if (rClrB.nPos == BlkI.nPos &&
  1559. rClrB.nNextBlockPos == BlkI.nNextBlockPos)
  1560. {
  1561. BlkI = rClrB; //arBlocks[i] = rClrB;
  1562. return;
  1563. }
  1564. // override BEGIN of the existing block
  1565. if (rClrB.nPos == BlkI.nPos &&
  1566. rClrB.nNextBlockPos < BlkI.nNextBlockPos)
  1567. {
  1568. BlkI.nPos = rClrB.nNextBlockPos;
  1569. //arBlocks[i] = BlkI;
  1570. arBlocks.InsertAt(i, rClrB);
  1571. return;
  1572. }
  1573. // override END of the existing block
  1574. if (rClrB.nPos > BlkI.nPos &&
  1575. rClrB.nNextBlockPos == BlkI.nNextBlockPos)
  1576. {
  1577. BlkI.nNextBlockPos = rClrB.nPos;
  1578. //arBlocks[i] = BlkI;
  1579. arBlocks.InsertAt(i+1, rClrB);
  1580. return;
  1581. }
  1583. BlkI2 = BlkI;
  1584. // INSERT inside to the existing block
  1585. BlkI2.nPos = rClrB.nNextBlockPos;
  1586. BlkI.nNextBlockPos = rClrB.nPos;
  1587. //arBlocks[i] = BlkI;
  1588. arBlocks.InsertAt(i+1, BlkI2);
  1589. arBlocks.InsertAt(i+1, rClrB);
  1590. return;
  1591. }
  1592. }
  1594. //** B. ** new block is bigger then existing block
  1595. nCount = (int)arBlocks.GetSize();
  1596. BOOL bInserted = FALSE;
  1597. for (i = nCount-1; i >= 0; i--)
  1598. {
  1599. XTP_EDIT_TEXTBLOCK BlkI = arBlocks[i];
  1601. if (rClrB.nNextBlockPos > BlkI.nPos && rClrB.nNextBlockPos < BlkI.nNextBlockPos)
  1602. {
  1603. BlkI.nPos = rClrB.nNextBlockPos;
  1604. arBlocks[i] = BlkI;
  1605. if (!bInserted)
  1606. {
  1607. arBlocks.InsertAt(i, rClrB);
  1608. bInserted = TRUE;
  1609. }
  1610. } else
  1611. if (rClrB.nPos <= BlkI.nPos && rClrB.nNextBlockPos >= BlkI.nNextBlockPos)
  1612. {
  1613. arBlocks.RemoveAt(i);
  1614. } else
  1615. if (rClrB.nNextBlockPos > BlkI.nPos && rClrB.nNextBlockPos < BlkI.nNextBlockPos )
  1616. {
  1617. BlkI.nNextBlockPos = rClrB.nPos;
  1618. arBlocks[i] = BlkI;
  1619. if (!bInserted)
  1620. {
  1621. arBlocks.InsertAt(i+1, rClrB);
  1622. bInserted = TRUE;
  1623. }
  1624. }
  1625. }
  1627. //----------------
  1628. if (!bInserted)
  1629. {
  1630. arBlocks.Add(rClrB);
  1631. }
  1632. }
  1634. void CXTPSyntaxEditLexTextSchema::GetRowColors(CTextIter* pTxtIter, int nRow,
  1635.  int nColFrom, int nColTo,
  1636.  const XTP_EDIT_COLORVALUES& clrDefault,
  1637.  CXTPSyntaxEditTextBlockList* rBlocks,
  1638.  CXTPSyntaxEditLexTextBlockPtr* pptrTBStartCache,
  1639.  CXTPSyntaxEditLexTextBlock* pFirstSchTB)
  1641. {
  1642. if (!pTxtIter)
  1643. {
  1644. ASSERT(FALSE);
  1645. return;
  1646. }
  1648. XTP_EDIT_TEXTBLOCK tmpBlk;
  1649. tmpBlk.nPos = 0;
  1650. tmpBlk.nNextBlockPos = 0;
  1652. tmpBlk.clrBlock = clrDefault;
  1654. int nLineLen = pTxtIter->GetLineLen(nRow, FALSE);
  1656. if (!nLineLen)
  1657. {
  1658. return;
  1659. }
  1661. XTP_EDIT_LINECOL LCStart= {nRow, nColFrom};
  1662. XTP_EDIT_LINECOL LCEnd = {nRow, nLineLen};
  1663. if (nColTo > 0 && nColTo < nLineLen)
  1664. {
  1665. LCEnd.nCol = nColTo;
  1666. }
  1668. CXTPSyntaxEditTextBlockArray arBlocks;
  1669. arBlocks.SetSize(0, 4096);
  1671. XTP_EDIT_TEXTBLOCK bltTB;
  1672. bltTB.nPos = 0;
  1674. CSingleLock singleLock(GetDataLoker());
  1675. //BOOL bLocked = TryLockCS(&singleLock, GetDataLoker(), 30, 5);
  1676. BOOL bLocked = singleLock.Lock(30);
  1678. //---------------------------------------------------------------------------
  1679. CXTPSyntaxEditLexTextBlockPtr ptrTBfirst, ptrTBstart;
  1680. if (bLocked)
  1681. {
  1682. ptrTBfirst = GetBlocks();
  1683. if (pFirstSchTB)
  1684. {
  1685. ptrTBfirst.SetPtr(pFirstSchTB, TRUE);
  1686. }
  1688. if (pptrTBStartCache)
  1689. {
  1690. ptrTBstart = *pptrTBStartCache;
  1691. }
  1693. if (!ptrTBstart || ptrTBstart == ptrTBfirst ||
  1694. ptrTBstart->IsLookLikeClosed())
  1695. {
  1696. ptrTBstart = ptrTBfirst ? ptrTBfirst->m_ptrNext : NULL;
  1697. }
  1698. }
  1700. //= process first blk ====================================================
  1701. //
  1702. if (ptrTBfirst)
  1703. {
  1704. bltTB.clrBlock = clrDefault;
  1705. bltTB.lf = tmpBlk.lf;
  1706. GetTextAttributes(bltTB, ptrTBfirst);
  1708. bltTB.nPos = 0;
  1709. bltTB.nNextBlockPos = nLineLen;
  1711. AddClrBlock(bltTB, arBlocks);
  1712. TraceClrBlocks(arBlocks);
  1713. }
  1714. //========================================================================
  1715. CXTPSyntaxEditLexTextBlockPtrArray arTBStack;
  1717. CXTPSyntaxEditLexTextBlockPtr ptrTBStartCache;
  1719. for (CXTPSyntaxEditLexTextBlock* pTB = ptrTBstart; pTB; pTB = pTB->m_ptrNext)
  1720. {
  1721. //BOOL bEndValid = pTB->m_PosEndLC.IsValidData();
  1722. //if (bEndValid &&
  1723. //  (pTB->m_PosEndLC < LCStart || pTB->m_PosEndLC < pTB->m_PosStartLC) ||
  1724. //  !bEndValid && pTB->m_ptrParent)
  1725. if (pTB->GetPosEndLC() < LCStart || pTB->m_PosEndLC < pTB->m_PosStartLC)
  1726. {
  1727. continue;
  1728. }
  1730. if (LCEnd < pTB->m_PosStartLC)
  1731. {
  1732. break;
  1733. }
  1735. XTP_EDIT_LINECOL TB_PosEndLC = pTB->m_PosEndLC;
  1736. if (!pTB->m_PosEndLC.IsValidData() && !pTB->m_ptrParent)
  1737. {
  1738. TB_PosEndLC.nLine = nRow;
  1739. TB_PosEndLC.nCol = nLineLen;
  1740. }
  1742. if (!ptrTBStartCache)
  1743. {
  1744. ptrTBStartCache.SetPtr(pTB, TRUE);
  1745. ASSERT(pTB->m_ptrParent);
  1746. }
  1748. CXTPSyntaxEditLexTextBlock* pTBStackLast = NULL;
  1749. while (pTB->m_ptrNext && pTB->m_ptrNext->m_PosStartLC <= pTB->m_PosStartLC &&
  1750. pTB->m_ptrNext->m_PosEndLC.IsValidData() && pTB->m_PosEndLC.IsValidData() &&
  1751. pTB->m_ptrNext->m_PosEndLC > pTB->m_PosEndLC)
  1752. {
  1753. if (arTBStack.GetSize() == 0)
  1754. {
  1755. arTBStack.AddPtr(pTB, TRUE);
  1756. }
  1757. arTBStack.Add(pTB->m_ptrNext);
  1758. pTBStackLast = pTB->m_ptrNext;
  1760. pTB = pTB->m_ptrNext;
  1761. }
  1763. int nStackCount = (int)arTBStack.GetSize();
  1765. for (;nStackCount >= 0;)
  1766. {
  1767. if (nStackCount > 0)
  1768. {
  1769. pTB = arTBStack[nStackCount-1];
  1770. }
  1771. nStackCount--;
  1773. if (nStackCount >= 0)
  1774. {
  1775. arTBStack.RemoveAt(nStackCount);
  1777. TB_PosEndLC = pTB->m_PosEndLC;
  1778. if (!pTB->m_PosEndLC.IsValidData() /*&& !pTB->m_ptrParent*/)
  1779. {
  1780. TB_PosEndLC.nLine = nRow;
  1781. TB_PosEndLC.nCol = nLineLen;
  1782. }
  1783. }
  1785. //restore default values
  1786. bltTB.clrBlock = clrDefault;
  1787. bltTB.lf = tmpBlk.lf;
  1789. GetTextAttributes(bltTB, pTB);
  1791. if (pTB->m_PosStartLC > LCStart)
  1792. {
  1793. bltTB.nNextBlockPos = TB_PosEndLC.nLine == nRow ?
  1794. min(TB_PosEndLC.nCol+1, nLineLen) : nLineLen;
  1795. bltTB.nPos = pTB->m_PosStartLC.nCol;
  1797. AddClrBlock(bltTB, arBlocks);
  1798. TraceClrBlocks(arBlocks);
  1799. }
  1800. else
  1801. {
  1802. bltTB.nNextBlockPos = TB_PosEndLC.nLine == nRow ?
  1803. min(TB_PosEndLC.nCol+1, nLineLen) : nLineLen;
  1804. bltTB.nPos = 0;
  1806. AddClrBlock(bltTB, arBlocks);
  1807. TraceClrBlocks(arBlocks);
  1808. }
  1809. }
  1811. //--------------------
  1812. if (pTBStackLast)
  1813. {
  1814. pTB = pTBStackLast;
  1815. }
  1816. }
  1817. //----------------------------------------
  1818. if (pptrTBStartCache)
  1819. {
  1820. ptrTBstart = *pptrTBStartCache;
  1821. if (!ptrTBstart || ptrTBstart->IsLookLikeClosed())
  1822. {
  1823. *pptrTBStartCache = ptrTBStartCache;
  1824. ASSERT(!ptrTBStartCache || !ptrTBStartCache->IsLookLikeClosed());
  1825. }
  1826. }
  1827. //-----------------------------
  1828. if (bLocked)
  1829. {
  1830. singleLock.Unlock();
  1831. }
  1833. //===========================================================================
  1834. int nPos = 0;
  1835. int i;
  1836. for (i = 0; i < arBlocks.GetSize(); i++)
  1837. {
  1838. XTP_EDIT_TEXTBLOCK BlkI = arBlocks[i];
  1839. if (nPos < BlkI.nPos)
  1840. {
  1841. tmpBlk.nPos = nPos;
  1842. tmpBlk.nNextBlockPos = BlkI.nPos;
  1844. AddClrBlock(tmpBlk, arBlocks);
  1845. TraceClrBlocks(arBlocks);
  1846. i++;
  1847. }
  1848. nPos = BlkI.nNextBlockPos;
  1849. }
  1850. //===========================================================================
  1851. if (arBlocks.GetSize() == 0)
  1852. {
  1853. tmpBlk.nPos = 0;
  1854. tmpBlk.nNextBlockPos = nLineLen;
  1855. arBlocks.Add(tmpBlk);
  1856. }
  1857. else
  1858. {
  1859. //---------------------------------------------------------------------------
  1860. XTP_EDIT_TEXTBLOCK BlkI = arBlocks[arBlocks.GetSize()-1];
  1861. if (BlkI.nNextBlockPos < nLineLen)
  1862. {
  1863. tmpBlk.nPos = BlkI.nNextBlockPos;
  1864. tmpBlk.nNextBlockPos = nLineLen;
  1865. AddClrBlock(tmpBlk, arBlocks);
  1866. TraceClrBlocks(arBlocks);
  1867. }
  1868. }
  1870. //**************************************************************************
  1872. // DEBUG ////////////////////////////////////////////////////////////////
  1873. #ifdef DBG_TRACE_DRAW_BLOCKS
  1874. TRACE(_T("n*** DBG_TRACE_DRAW_BLOCKS *** --------------------n"));
  1875. TRACE(_T("row=%d, row_len = %d n"), nRow, nLineLen);
  1876. #endif
  1877. // END DEBUG ////////////////////////////////////////////////////////////
  1879. for (i = 0; i < arBlocks.GetSize(); i++)
  1880. {
  1881. XTP_EDIT_TEXTBLOCK& BlkI = arBlocks[i];
  1883. rBlocks->AddTail(BlkI);
  1885. // DEBUG ////////////////////////////////////////////////////////////////
  1886. #ifdef DBG_TRACE_DRAW_BLOCKS
  1887. TRACE(_T("(%02d) start =%d, ?end=%d, color=%X n"), i, BlkI.nPos,
  1888. BlkI.nNextBlockPos, BlkI.clrBlock.crText);
  1889. #endif
  1890. // END DEBUG ////////////////////////////////////////////////////////////
  1891. }
  1892. }
  1894. void CXTPSyntaxEditLexTextSchema::GetCollapsableBlocksInfo(int nRow,
  1895. CXTPSyntaxEditRowsBlockArray& rArBlocks,
  1896. CXTPSyntaxEditLexTextBlockPtr* pptrTBStartCache)
  1897. {
  1898. static const CString s_strCollapsedText_def = _T("[..]");
  1900. rArBlocks.RemoveAll();
  1902. CSingleLock singleLock(GetDataLoker());
  1903. //BOOL bLocked = TryLockCS(&singleLock, GetDataLoker(), 30);
  1904. BOOL bLocked = singleLock.Lock(30);
  1905. if (!bLocked)
  1906. {
  1907. return;
  1908. }
  1910. XTP_EDIT_ROWSBLOCK tmpCoBlk;
  1911. //---------------------------------------------------------------------------
  1912. ASSERT(bLocked);
  1913. CXTPSyntaxEditLexTextBlockPtr ptrTBstart;
  1914. if (pptrTBStartCache)
  1915. {
  1916. ptrTBstart = *pptrTBStartCache;
  1917. }
  1918. if (!ptrTBstart || ptrTBstart->IsLookLikeClosed())
  1919. {
  1920. ptrTBstart = GetBlocks();
  1921. }
  1922. CXTPSyntaxEditLexTextBlockPtr ptrTBStartCache;
  1924. for (CXTPSyntaxEditLexTextBlock* pTB = ptrTBstart; pTB; pTB = pTB->m_ptrNext)
  1925. {
  1926. if (nRow >= 0 && nRow < pTB->m_PosStartLC.nLine)
  1927. {
  1928. break;
  1929. }
  1931. XTP_EDIT_LINECOL TB_PosEndLC = pTB->GetPosEndLC(); // pTB->m_PosEndLC;
  1934. if (nRow < 0 || (nRow >= pTB->m_PosStartLC.nLine &&
  1935. nRow <= TB_PosEndLC.nLine) )
  1936. {
  1937. if (!ptrTBStartCache && pTB->m_ptrParent)
  1938. {
  1939. ptrTBStartCache.SetPtr(pTB, TRUE);
  1940. }
  1942. if (pTB->m_PosStartLC.nLine < TB_PosEndLC.nLine &&
  1943. pTB->m_ptrParent )
  1944. {
  1945. CXTPSyntaxEditLexClass* pLexClass = pTB->m_ptrLexClass;
  1946. ASSERT(pLexClass);
  1948. int nCollapsable = pLexClass->IsCollapsable();
  1949. if (pLexClass &&  nCollapsable &&
  1950. (nCollapsable == 2 || !pTB->m_bEndByParent && TB_PosEndLC != XTP_EDIT_LINECOL::MAXPOS))
  1951. {
  1952. tmpCoBlk.lcStart = pTB->m_PosStartLC;
  1953. tmpCoBlk.lcEnd = TB_PosEndLC;
  1955. CXTPSyntaxEditLexVariantPtr ptrLVtext;
  1956. ptrLVtext = pLexClass->GetAttribute(XTPLEX_ATTR_COLLAPSEDTEXT, FALSE);
  1958. if (ptrLVtext && ptrLVtext->IsStrType())
  1959. {
  1960. tmpCoBlk.strCollapsedText = ptrLVtext->GetStr();
  1961. } else {
  1962. tmpCoBlk.strCollapsedText = s_strCollapsedText_def;
  1963. }
  1965. rArBlocks.Add(tmpCoBlk);
  1966. }
  1967. }
  1968. }
  1969. }
  1971. //----------------------------------------
  1972. if (pptrTBStartCache)
  1973. {
  1974. ptrTBstart = *pptrTBStartCache;
  1975. if (!ptrTBstart || ptrTBstart->IsLookLikeClosed())
  1976. {
  1977. *pptrTBStartCache = ptrTBStartCache;
  1978. ASSERT(!ptrTBStartCache || !ptrTBStartCache->IsLookLikeClosed());
  1979. }
  1980. }
  1981. }
  1984. void CXTPSyntaxEditLexTextSchema::ApplyThemeRecursive(CXTPSyntaxEditColorTheme* pTheme,
  1985. CXTPSyntaxEditLexClassPtrArray* ptrClasses)
  1986. {
  1987. // if pTheme == NULL - Restore default values only
  1989. const static CString strAttrPref = XTPLEX_ATTR_TXTPREFIX;
  1991. ASSERT(ptrClasses);
  1992. int nCount = ptrClasses ? (int)ptrClasses->GetSize() : 0;
  1993. for (int i = 0; i < nCount; i++)
  1994. {
  1995. CXTPSyntaxEditLexClassPtr ptrC = ptrClasses->GetAt(i);
  1996. if (!ptrC)
  1997. {
  1998. ASSERT(FALSE);
  1999. continue;
  2000. }
  2001. // Traverse the tree
  2002. ApplyThemeRecursive(pTheme, ptrC->GetChildren());
  2003. ApplyThemeRecursive(pTheme, ptrC->GetChildrenDyn());
  2004. //-------------------------------------------------------
  2006. const CString strCName = ptrC->GetClassName();
  2008. // restore default attributes (colors)
  2009. CXTPSyntaxEditLexClassPtr ptrCDefault = m_pClassSchema->GetPreBuildClass(strCName);
  2010. ASSERT(ptrCDefault);
  2011. if (ptrCDefault)
  2012. {
  2013. ptrC->CopyAttributes(ptrCDefault, XTPLEX_ATTR_TXTPREFIX);
  2014. }
  2016. CXTPSyntaxEditColorInfo* pColors = pTheme ? pTheme->GetColorInfo(strCName, pTheme->GetFileName()) : NULL;
  2017. if (!pColors)
  2018. {
  2019. continue;
  2020. }
  2022. // Apply new attributes (colors)
  2023. POSITION posParam = pColors->GetFirstParamNamePosition();
  2024. while (posParam)
  2025. {
  2026. static const int c_nClrPrefLen = (int)_tcsclen(XTPLEX_ATTR_COLORPREFIX);
  2028. CString strParamName = pColors->GetNextParamName(posParam);
  2029. DWORD dwValue = pColors->GetHexParam(strParamName);
  2030. CString strAttrName = strAttrPref + strParamName;
  2032. if (_tcsnicmp(strAttrName, XTPLEX_ATTR_COLORPREFIX, c_nClrPrefLen) == 0)
  2033. {
  2034. dwValue = XTP_EDIT_RGB_INT2CLR(dwValue);
  2035. }
  2037. CXTPSyntaxEditLexVariant lvAttr((int)dwValue);
  2039. ptrC->SetAttribute(strAttrName, lvAttr);
  2040. }
  2041. }
  2042. }
  2044. void CXTPSyntaxEditLexTextSchema::ApplyTheme(CXTPSyntaxEditColorTheme* pTheme)
  2045. {
  2046. // if pTheme == NULL - Restore default values only
  2048. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  2049. CSingleLock singleLock(GetDataLoker(), TRUE);
  2051. CXTPSyntaxEditLexClassPtrArray* ptrClassesFull = m_pClassSchema->GetClasses(FALSE);
  2052. CXTPSyntaxEditLexClassPtrArray* ptrClassesShort = m_pClassSchema->GetClasses(TRUE);
  2054. ApplyThemeRecursive(pTheme, ptrClassesFull);
  2055. ApplyThemeRecursive(pTheme, ptrClassesShort);
  2057. }
  2059. ////////////////////////////////////////////////////////////////////////////
  2060. // CXTPSyntaxEditLexClassSchema
  2062. CXTPSyntaxEditLexClassSchema::CXTPSyntaxEditLexClassSchema()
  2063. {
  2064. XTPGetLexAutomatMemMan()->Lock();
  2065. }
  2067. CXTPSyntaxEditLexClassSchema::~CXTPSyntaxEditLexClassSchema()
  2068. {
  2069. XTPGetLexAutomatMemMan()->Unlok();
  2070. }
  2072. void CXTPSyntaxEditLexClassSchema::AddPreBuildClass(CXTPSyntaxEditLexClass* pClass)
  2073. {
  2074. CXTPSyntaxEditLexClassPtr ptrC(pClass, TRUE);
  2075. m_arPreBuildClassesList.Add(ptrC);
  2076. }
  2078. CXTPSyntaxEditLexClassPtrArray* CXTPSyntaxEditLexClassSchema::GetChildrenFor(CXTPSyntaxEditLexClass* pClass,
  2079.  BOOL& rbSelfChild)
  2080. {
  2081. rbSelfChild = FALSE;
  2083. CXTPSyntaxEditLexClassPtrArray arChildren;
  2085. BOOL bForFile = pClass == NULL;
  2087. int nChidrenOpt = xtpEditOptChildren_Any;
  2088. CStringArray arChidrenData;
  2089. CString strParentName;
  2091. if (pClass)
  2092. {
  2093. pClass->GetChildrenOpt(nChidrenOpt, arChidrenData);
  2094. strParentName = pClass->GetClassName();
  2095. }
  2097. if (nChidrenOpt == xtpEditOptChildren_No)
  2098. {
  2099. return NULL;
  2100. }
  2102. int nCCount = (int)m_arPreBuildClassesList.GetSize();
  2103. for (int i = 0; i < nCCount; i++)
  2104. {
  2105. CXTPSyntaxEditLexClassPtr ptrC = m_arPreBuildClassesList[i];
  2106. int nParentOpt;
  2107. CStringArray arParentData;
  2108. ptrC->GetParentOpt(nParentOpt, arParentData);
  2109. CString strCName = ptrC->GetClassName();
  2111. if (bForFile && nParentOpt == xtpEditOptParent_file)
  2112. {
  2113. arChildren.Add(ptrC);
  2114. }
  2115. else if (!bForFile && nParentOpt == xtpEditOptParent_direct)
  2116. {
  2117. ASSERT(pClass);
  2119. if (nChidrenOpt == xtpEditOptChildren_List)
  2120. {
  2121. if (Find_noCase(arChidrenData, strCName) < 0)
  2122. {
  2123. continue;
  2124. }
  2125. }
  2127. int nNCount = (int)arParentData.GetSize();
  2128. for (int n = 0; n < nNCount; n++)
  2129. {
  2130. CString strCN = arParentData[n];
  2132. if (strCN.CompareNoCase(strParentName) == 0)
  2133. {
  2134. if (strCName.CompareNoCase(strParentName) == 0)
  2135. {
  2136. rbSelfChild = TRUE;
  2137. }
  2138. else
  2139. {
  2140. arChildren.Add(ptrC);
  2141. }
  2142. break;
  2143. }
  2144. }
  2145. }
  2146. }
  2147. //--------------------------------
  2148. CXTPSyntaxEditLexClassPtrArray* pArChildren = NULL;
  2149. if (arChildren.GetSize())
  2150. {
  2151. pArChildren = new CXTPSyntaxEditLexClassPtrArray;
  2152. if (pArChildren)
  2153. {
  2154. pArChildren->Append(arChildren);
  2155. }
  2156. }
  2157. return pArChildren;
  2158. }
  2160. int CXTPSyntaxEditLexClassSchema::CanBeParentDynForChild(CString strParentName,
  2161. CXTPSyntaxEditLexClass* pCChild)
  2162. {
  2163. if (!pCChild)
  2164. {
  2165. ASSERT(FALSE);
  2166. return FALSE;
  2167. }
  2169. int nParentOpt;
  2170. CStringArray arParentData;
  2171. pCChild->GetParentOpt(nParentOpt, arParentData);
  2172. if (nParentOpt != xtpEditOptParent_dyn)
  2173. {
  2174. return -1;
  2175. }
  2177. int nCCount = (int)m_arPreBuildClassesList.GetSize(), n;
  2178. for (int i = 0; i < nCCount; i++)
  2179. {
  2180. CXTPSyntaxEditLexClassPtr ptrC = m_arPreBuildClassesList[i];
  2182. CString strCName = ptrC->GetClassName();
  2184. int nNCount = (int)arParentData.GetSize();
  2185. for (n = 0; n < nNCount; n++)
  2186. {
  2187. CString strCN = arParentData[n];
  2189. if (strParentName.CompareNoCase(strCN) == 0)
  2190. {
  2191. return TRUE;
  2192. }
  2193. }
  2195. //-------------------------------------------------------
  2196. if (nParentOpt == xtpEditOptParent_dyn )
  2197. {
  2198. int nDataCount = (int)arParentData.GetSize();
  2199. for (n = 0; n < nDataCount; n++)
  2200. {
  2201. CString strCN = arParentData[n];
  2203. if (strCName.CompareNoCase(strCN) == 0)
  2204. {
  2205. BOOL bCanDyn = CanBeParentDynForChild(strParentName, ptrC);
  2206. if (bCanDyn)
  2207. {
  2208. return TRUE;
  2209. }
  2210. }
  2211. }
  2212. }
  2213. }
  2214. return FALSE;
  2215. }
  2217. CXTPSyntaxEditLexClass* CXTPSyntaxEditLexClassSchema::GetPreBuildClass(const CString& strName)
  2218. {
  2219. int nCCount = (int)m_arPreBuildClassesList.GetSize();
  2220. for (int i = 0; i < nCCount; i++)
  2221. {
  2222. CXTPSyntaxEditLexClassPtr ptrC = m_arPreBuildClassesList[i];
  2224. const CString strCName = ptrC->GetClassName();
  2226. if (strName.CompareNoCase(strCName) == 0)
  2227. {
  2228. return ptrC.Detach();
  2229. }
  2230. }
  2231. return NULL;
  2232. }
  2234. void CXTPSyntaxEditLexClassSchema::GetDynParentsList(CXTPSyntaxEditLexClass* pClass,
  2235.    CStringArray& rarDynParents,
  2236.    CStringArray& rarProcessedClasses)
  2237. {
  2238. if (!pClass)
  2239. {
  2240. ASSERT(FALSE);
  2241. return;
  2242. }
  2244. CString strClassName = pClass->GetClassName();
  2245. if (Find_noCase(rarProcessedClasses, strClassName) >= 0)
  2246. {
  2247. return;
  2248. }
  2249. rarProcessedClasses.Add(strClassName);
  2251. int nParentOpt;
  2252. CStringArray arParentData;
  2253. pClass->GetParentOpt(nParentOpt, arParentData);
  2255. if (nParentOpt == xtpEditOptParent_file)
  2256. {
  2257. return;
  2258. }
  2260. ConcatenateArrays_noCase(rarDynParents, arParentData);
  2262. int nNCount = (int)arParentData.GetSize();
  2263. for (int n = 0; n < nNCount; n++)
  2264. {
  2265. CString strParent1 = arParentData[n];
  2267. if (strClassName.CompareNoCase(strParent1) == 0)
  2268. {
  2269. continue;
  2270. }
  2272. CXTPSyntaxEditLexClassPtr ptrC = GetPreBuildClass(strParent1);
  2273. if (ptrC)
  2274. {
  2275. GetDynParentsList(ptrC, rarDynParents, rarProcessedClasses);
  2276. }
  2277. else
  2278. {
  2279. //TRACE
  2280. }
  2281. }
  2282. }
  2284. CXTPSyntaxEditLexClassPtrArray* CXTPSyntaxEditLexClassSchema::GetDynChildrenFor(CXTPSyntaxEditLexClass* pClass,
  2285. BOOL& rbSelfChild)
  2286. {
  2287. rbSelfChild = FALSE;
  2289. int nChidrenOpt = xtpEditOptChildren_Any;
  2290. CStringArray arChidrenData;
  2291. if (pClass)
  2292. {
  2293. pClass->GetChildrenOpt(nChidrenOpt, arChidrenData);
  2294. }
  2296. if (nChidrenOpt == xtpEditOptChildren_No)
  2297. {
  2298. return NULL;
  2299. }
  2300. if (!pClass)
  2301. return NULL;
  2303. CString strMainCName = pClass->GetClassName();
  2305. CStringArray arMainParents;
  2306. CStringArray arProcessedClasses;
  2307. GetDynParentsList(pClass, arMainParents, arProcessedClasses);
  2309. CXTPSyntaxEditLexClassPtrArray arDynChildren;
  2311. int nCCount = (int)m_arPreBuildClassesList.GetSize();
  2312. for (int i = 0; i < nCCount; i++)
  2313. {
  2314. CXTPSyntaxEditLexClassPtr ptrC = m_arPreBuildClassesList[i];
  2315. CString strCName = ptrC->GetClassName();
  2317. if (nChidrenOpt == xtpEditOptChildren_List)
  2318. {
  2319. if (Find_noCase(arChidrenData, strCName) < 0)
  2320. {
  2321. continue;
  2322. }
  2323. }
  2325. int nCanRes = CanBeParentDynForChild(strMainCName, ptrC);
  2326. if (nCanRes > 0)
  2327. {
  2328. if (strMainCName.CompareNoCase(strCName) == 0)
  2329. {
  2330. rbSelfChild = TRUE;
  2331. }
  2332. else
  2333. {
  2334. arDynChildren.Add(ptrC);
  2335. }
  2336. continue;
  2337. }
  2339. if (nCanRes < 0)
  2340. {
  2341. continue;
  2342. }
  2344. int nMPCount = (int)arMainParents.GetSize();
  2345. for (int n = 0; n < nMPCount; n++)
  2346. {
  2347. CString strMPName = arMainParents[n];
  2348. if (CanBeParentDynForChild(strMPName, ptrC))
  2349. {
  2350. arDynChildren.Add(ptrC);
  2351. break;
  2352. }
  2353. }
  2354. }
  2356. //--------------------------------
  2357. CXTPSyntaxEditLexClassPtrArray* pArDynChildren = NULL;
  2358. if (arDynChildren.GetSize())
  2359. {
  2360. pArDynChildren = new CXTPSyntaxEditLexClassPtrArray;
  2361. if (pArDynChildren)
  2362. {
  2363. pArDynChildren->Append(arDynChildren);
  2364. }
  2365. }
  2366. return pArDynChildren;
  2367. }
  2370. CXTPSyntaxEditLexObj_ActiveTags* CXTPSyntaxEditLexClassSchema::GetActiveTagsFor(
  2371. CXTPSyntaxEditLexClass* pTopClass)
  2372. {
  2373. if (!pTopClass)
  2374. {
  2375. ASSERT(FALSE);
  2376. return NULL;
  2377. }
  2378. return pTopClass->GetActiveTags();
  2379. }
  2381. BOOL CXTPSyntaxEditLexClassSchema::Copy(CXTPSyntaxEditLexClassSchema* pDest)
  2382. {
  2383. if (!pDest)
  2384. {
  2385. ASSERT(FALSE);
  2386. return FALSE;
  2387. }
  2388. //------------------------------------------------------------------------
  2389. int nCount = (int)m_arPreBuildClassesList.GetSize();
  2390. int i;
  2391. for (i = 0; i < nCount; i++)
  2392. {
  2393. CXTPSyntaxEditLexClassPtr ptrC0 = m_arPreBuildClassesList.GetAt(i);
  2394. if (!ptrC0)
  2395. {
  2396. continue;
  2397. }
  2398. CXTPSyntaxEditLexClassPtr ptrC0_new = ptrC0->Clone(this);
  2399. if (!ptrC0_new)
  2400. {
  2401. return FALSE;
  2402. }
  2403. pDest->m_arPreBuildClassesList.Add(ptrC0_new);
  2404. }
  2406. //------------------------------------------------------------------------
  2407. nCount = (int)m_arClassesTreeFull.GetSize();
  2408. for (i = 0; i < nCount; i++)
  2409. {
  2410. CXTPSyntaxEditLexClassPtr ptrCfile = m_arClassesTreeFull.GetAt(i);
  2411. if (!ptrCfile)
  2412. {
  2413. continue;
  2414. }
  2417. CXTPSyntaxEditLexClassPtr ptrCFnew = ptrCfile->Clone(this);
  2419. if (!CopyChildrenFor(FALSE, ptrCFnew, ptrCfile, 0))
  2420. {
  2421. return FALSE;
  2422. }
  2424. int nStartCount = 0;
  2425. ptrCFnew->BuildActiveTags(nStartCount);
  2427. // //CXTPSyntaxEditLexVariantPtrArray* ptrAT = ptrCFnew->BuildActiveTags(nStartCount);
  2428. // //ConcatenateLVArrays(&pDest->m_arAllActiveTagsFull, ptrAT, nStartCount);
  2430. pDest->m_arClassesTreeFull.Add(ptrCFnew);
  2431. }
  2433. //------------------------------------------------------------------------
  2434. BOOL bResShortTree = pDest->Build_ShortTree();
  2436. //-* Post Build processing ----------------------------
  2437. if (!PostBuild_Step(&pDest->m_arClassesTreeShort))
  2438. {
  2439. return FALSE;
  2440. }
  2442. if (!PostBuild_Step(&pDest->m_arClassesTreeFull))
  2443. {
  2444. return FALSE;
  2445. }
  2446. return bResShortTree;
  2447. }
  2449. BOOL CXTPSyntaxEditLexClassSchema::Build()
  2450. {
  2451. CXTPSyntaxEditLexClass::CloseClasses(&m_arClassesTreeFull);
  2452. CXTPSyntaxEditLexClass::CloseClasses(&m_arClassesTreeShort);
  2453. int nClassID = 1;
  2455. BOOL bUnused;
  2456. CXTPSyntaxEditLexClassPtrArray* ptrArCfile = GetChildrenFor(NULL, bUnused);
  2458. int nCount = ptrArCfile ? (int)ptrArCfile->GetSize() : 0;
  2459. for (int i = 0; i < nCount; i++)
  2460. {
  2461. CXTPSyntaxEditLexClassPtr ptrCfile = ptrArCfile->GetAt(i);
  2463. CXTPSyntaxEditLexClassPtr ptrCFnew = GetNewClass(TRUE);
  2464. if (!ptrCFnew)
  2465. {
  2466. delete ptrArCfile;
  2467. return FALSE;
  2468. }
  2469. ptrCFnew->CopyFrom(ptrCfile);
  2471. CXTPSyntaxEditLexVariant lvID(nClassID++);
  2472. ptrCFnew->SetAttribute(XTPLEX_ATTRCLASSID, lvID);
  2474. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2475. ptrCFnew->Dump(_T(""));
  2476. #endif
  2478. CString strCNnew = ptrCFnew->GetClassName();
  2480. CStringArray arAddedStack;
  2481. arAddedStack.Add(strCNnew);
  2482. if (!Build_ChildrenFor(FALSE, ptrCFnew, arAddedStack, nClassID, 0))
  2483. {
  2484. delete ptrArCfile;
  2485. return FALSE;
  2486. }
  2488. arAddedStack.RemoveAll();
  2489. if (!Build_ChildrenFor(TRUE, ptrCFnew, arAddedStack, nClassID, 0))
  2490. {
  2491. delete ptrArCfile;
  2492. return FALSE;
  2493. }
  2495. int nStartCount = 0;
  2496. ptrCFnew->BuildActiveTags(nStartCount);
  2497. //CXTPSyntaxEditLexVariantPtrArray* ptrAT = ptrCFnew->BuildActiveTags(nStartCount);
  2498. //ConcatenateLVArrays(&m_arAllActiveTagsFull, ptrAT, nStartCount);
  2500. m_arClassesTreeFull.Add(ptrCFnew);
  2501. }
  2503. delete ptrArCfile;
  2505. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2506. //      m_arAllActiveTagsFull.Dump(_T("AllActiveTags FULL=: "));
  2507. #endif
  2509. if (!Build_ShortTree())
  2510. {
  2511. return FALSE;
  2512. }
  2514. //-* Post Build processing ----------------------------
  2515. if (!PostBuild_Step(&m_arClassesTreeShort))
  2516. {
  2517. return FALSE;
  2518. }
  2520. if (!PostBuild_Step(&m_arClassesTreeFull))
  2521. {
  2522. return FALSE;
  2523. }
  2525. //----------------------
  2526. //BOOL bAsc = TRUE, bNoCase = FALSE;
  2527. //SortTagsInLexVarArray(m_arAllActiveTagsFull, bAsc, bNoCase);
  2528. //SortTagsInLexVarArray(m_arAllActiveTagsShort, bAsc, bNoCase);
  2530. //  m_arAllActiveTagsFull.BuildAutomat();
  2531. //  m_arAllActiveTagsShort.BuildAutomat();
  2532. //-* Post Build END ------------------------------------------------------
  2534. #ifdef _DEBUG
  2535. AfxDump(XTPGetLexAutomatMemMan());
  2536. #endif
  2537. //------------------------------------------------------------------------
  2538. return TRUE;
  2539. }
  2541. BOOL CXTPSyntaxEditLexClassSchema::Build_ShortTree()
  2542. {
  2543. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2544. TRACE(_T("n****************** Short classes Tree ********************** n"));
  2545. #endif
  2547. int nCount = (int)m_arClassesTreeFull.GetSize();
  2548. for (int i = 0; i < nCount; i++)
  2549. {
  2550. CXTPSyntaxEditLexClassPtr ptrCfile = m_arClassesTreeFull.GetAt(i);
  2551. if (!ptrCfile || ptrCfile->GetAttribute_BOOL(XTPLEX_ATTR_PARSEONSCREEN, FALSE))
  2552. {
  2553. continue;
  2554. }
  2556. CXTPSyntaxEditLexClassPtr ptrCFnew = GetNewClass(TRUE);
  2557. if (!ptrCFnew)
  2558. {
  2559. return FALSE;
  2560. }
  2561. ptrCFnew->CopyFrom(ptrCfile);
  2563. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2564. ptrCFnew->Dump(_T(""));
  2565. #endif
  2567. if (!CopyChildrenFor(TRUE, ptrCFnew, ptrCfile, 0))
  2568. {
  2569. return FALSE;
  2570. }
  2572. int nStartCount = 0;
  2573. ptrCFnew->BuildActiveTags(nStartCount);
  2574. //CXTPSyntaxEditLexVariantPtrArray* ptrAT = ptrCFnew->BuildActiveTags(nStartCount);
  2575. //ConcatenateLVArrays(&m_arAllActiveTagsShort, ptrAT, nStartCount);
  2577. m_arClassesTreeShort.Add(ptrCFnew);
  2578. }
  2580. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2581. //      m_arAllActiveTagsShort.Dump(_T("AllActiveTags Short=: "));
  2582. #endif
  2584. return TRUE;
  2585. }
  2587. BOOL CXTPSyntaxEditLexClassSchema::CopyChildrenFor(BOOL bShort, CXTPSyntaxEditLexClass* pCDest,
  2588.    CXTPSyntaxEditLexClass* pCSrc, int nLevel)
  2589. {
  2590. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2591. CString strTraceOffset0, strTraceOffset;
  2592. for (int t = 0; t <= nLevel; t++)
  2593. {
  2594. strTraceOffset0 += _T("   ");
  2595. }
  2596. #endif
  2598. CXTPSyntaxEditLexClassPtrArray* pArClasses[3];
  2599. pArClasses[0] = pCSrc->GetChildren();
  2600. pArClasses[1] = pCSrc->GetChildrenDyn();
  2601. pArClasses[2] = pCSrc->GetChildrenSelfRef();
  2603. for (int nC = 0; nC < _countof(pArClasses); nC++)
  2604. {
  2605. BOOL bDynamic = (nC == 1);
  2606. BOOL bSelf  = (nC == 2);
  2609. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2610. if (bDynamic)
  2611. {
  2612. strTraceOffset = strTraceOffset0 + _T("dyn: ");
  2613. }
  2614. else if (bSelf)
  2615. {
  2616. strTraceOffset = strTraceOffset0 + _T("self: ");
  2617. }
  2618. else
  2619. {
  2620. strTraceOffset = strTraceOffset0;
  2621. }
  2622. #endif
  2624. int nCount = pArClasses[nC] ? (int)pArClasses[nC]->GetSize() : 0;
  2625. for (int i = 0; i < nCount; i++)
  2626. {
  2627. CXTPSyntaxEditLexClassPtr ptrCsrc = pArClasses[nC]->GetAt(i);
  2629. if (!ptrCsrc ||
  2630. bShort && ptrCsrc->GetAttribute_BOOL(XTPLEX_ATTR_PARSEONSCREEN, FALSE))
  2631. {
  2632. continue;
  2633. }
  2635. if (bSelf)
  2636. {
  2637. pCDest->AddChild(pCDest, FALSE);
  2639. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2640. pCDest->Dump(strTraceOffset);
  2641. #endif
  2642. }
  2643. else
  2644. {
  2645. CXTPSyntaxEditLexClassPtr ptrCnew = GetNewClass(FALSE);
  2646. if (!ptrCnew)
  2647. {
  2648. return FALSE;
  2649. }
  2650. ptrCnew->CopyFrom(ptrCsrc);
  2652. pCDest->AddChild(ptrCnew, bDynamic);
  2654. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2655. ptrCnew->Dump(strTraceOffset);
  2656. #endif
  2658. ASSERT(pCSrc != ptrCsrc);
  2660. if (!CopyChildrenFor(bShort, ptrCnew, ptrCsrc, nLevel+1))
  2661. {
  2662. return FALSE;
  2663. }
  2664. }
  2665. }
  2666. }
  2667. return TRUE;
  2668. }
  2670. BOOL CXTPSyntaxEditLexClassSchema::Build_ChildrenFor(BOOL bDynamic,
  2671.    CXTPSyntaxEditLexClass* pCBase,
  2672.    CStringArray& rarAdded,
  2673.    int& rnNextClassID,
  2674.    int nLevel)
  2675. {
  2676. if (!pCBase)
  2677. {
  2678. ASSERT(FALSE);
  2679. return FALSE;
  2680. }
  2682. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2683. CString strTraceOffset;
  2684. for (int t = 0; t <= nLevel; t++)
  2685. {
  2686. strTraceOffset += _T("   ");
  2687. }
  2688. if (bDynamic)
  2689. {
  2690. strTraceOffset += _T("dyn: ");
  2691. }
  2692. #endif
  2694. BOOL bSelfChild = FALSE;
  2695. CXTPSyntaxEditLexClassPtrArray* ptrArChildren;
  2696. if (bDynamic)
  2697. {
  2698. ptrArChildren = GetDynChildrenFor(pCBase, bSelfChild);
  2699. }
  2700. else
  2701. {
  2702. ptrArChildren = GetChildrenFor(pCBase, bSelfChild);
  2703. }
  2705. int nCount = ptrArChildren ? (int)ptrArChildren->GetSize() : 0;
  2706. for (int i = 0; i < nCount; i++)
  2707. {
  2708. CXTPSyntaxEditLexClassPtr ptrCsrc = ptrArChildren->GetAt(i);
  2709. CString strCNsrc = ptrCsrc->GetClassName();
  2711. if (nLevel == 0)
  2712. {
  2713. rarAdded.RemoveAll();
  2714. }
  2715. //int nFIdx = Find_noCase(rarAdded, strCNsrc);
  2716. //if (nFIdx >= 0)
  2717. int nClsCount = FindStrCount(rarAdded, strCNsrc, FALSE);
  2718. int nRecurrenceDepth = ptrCsrc->GetAttribute_int(XTPLEX_ATTR_RECURRENCEDEPTH, TRUE, 1);;
  2720. if (nClsCount >= nRecurrenceDepth)
  2721. {
  2722. //CXTPSyntaxEditLexClassPtr ptrC(pCBase->FindParent(strCNsrc), TRUE);
  2723. //if (ptrC) {
  2724. //  pCBase->GetChildrenSelfRef()->Add(ptrC);
  2725. //#ifdef DBG_TRACE_LOAD_CLASS_SCH
  2726. //  strTraceOffset += _T("self: ");
  2727. //  ptrC->Dump(strTraceOffset);
  2728. //#endif
  2729. //}
  2730. continue;
  2731. }
  2732. rarAdded.Add(strCNsrc);
  2734. CXTPSyntaxEditLexClassPtr ptrCnew = GetNewClass(FALSE);
  2735. if (!ptrCnew)
  2736. {
  2738. delete ptrArChildren;
  2739. return FALSE;
  2740. }
  2741. ptrCnew->CopyFrom(ptrCsrc);
  2743. CXTPSyntaxEditLexVariant lvID(rnNextClassID++);
  2744. ptrCnew->SetAttribute(XTPLEX_ATTRCLASSID, lvID);
  2746. pCBase->AddChild(ptrCnew, bDynamic);
  2748. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2749. ptrCnew->Dump(strTraceOffset);
  2750. #endif
  2752. Build_ChildrenFor(bDynamic, ptrCnew, rarAdded, rnNextClassID, nLevel+1);
  2754. Build_ChildrenFor(!bDynamic, ptrCnew, rarAdded, rnNextClassID, nLevel+1);
  2756. int nStackCount = (int)rarAdded.GetSize();
  2757. if (nStackCount > 0)
  2758. {
  2759. rarAdded.RemoveAt(nStackCount - 1);
  2760. }
  2761. }
  2763. delete ptrArChildren;
  2765. //----------------------------------
  2766. if (bSelfChild)
  2767. {
  2768. if (pCBase->AddChild(pCBase, bDynamic))
  2769. {
  2770. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  2771. strTraceOffset += _T("self: ");
  2772. pCBase->Dump(strTraceOffset);
  2773. #endif
  2774. }
  2775. }
  2776. return TRUE;
  2777. }
  2779. BOOL CXTPSyntaxEditLexClassSchema::PostBuild_Step(CXTPSyntaxEditLexClassPtrArray* pArClasses)
  2780. {
  2781. if (!pArClasses)
  2782. {
  2783. return TRUE;
  2784. }
  2786. int nCount = (int)pArClasses->GetSize();
  2787. for (int i = 0; i < nCount; i++)
  2788. {
  2789. CXTPSyntaxEditLexClassPtr ptrC = pArClasses->GetAt(i);
  2790. ptrC->SortTags();
  2792. CXTPSyntaxEditLexClassPtrArray* ptrCh1 = ptrC->GetChildren();
  2793. CXTPSyntaxEditLexClassPtrArray* ptrCh2 = ptrC->GetChildrenDyn();
  2795. if (!PostBuild_Step(ptrCh1))
  2796. {
  2797. return FALSE;
  2798. }
  2799. if (!PostBuild_Step(ptrCh2))
  2800. {
  2801. return FALSE;
  2802. }
  2803. }
  2805. return TRUE;
  2806. }
  2808. void CXTPSyntaxEditLexClassSchema::Close()
  2809. {
  2810. RemoveAll();
  2811. }
  2813. void CXTPSyntaxEditLexClassSchema::RemoveAll()
  2814. {
  2815. CXTPSyntaxEditLexClass::CloseClasses(&m_arPreBuildClassesList);
  2817. CXTPSyntaxEditLexClass::CloseClasses(&m_arClassesTreeFull);
  2818. CXTPSyntaxEditLexClass::CloseClasses(&m_arClassesTreeShort);
  2819. }
  2821. CXTPSyntaxEditLexClassPtrArray* CXTPSyntaxEditLexClassSchema::GetClasses(BOOL bShortSch)
  2822. {
  2823. return bShortSch? &m_arClassesTreeShort: &m_arClassesTreeFull;
  2824. }
  2826. CXTPSyntaxEditLexClassPtrArray* CXTPSyntaxEditLexClassSchema::GetPreBuildClasses()
  2827. {
  2828. return &m_arPreBuildClassesList;
  2829. }
  2831. CXTPSyntaxEditLexClass* CXTPSyntaxEditLexClassSchema::GetNewClass(BOOL bForFile)
  2832. {
  2833. if (bForFile)
  2834. {
  2835. return new CXTPSyntaxEditLexClass_file();
  2836. }
  2837. return new CXTPSyntaxEditLexClass();
  2838. }
  2840. ////////////////////////////////////////////////////////////////////////////
  2841. // CXTPSyntaxEditLexParseContext
  2842. //class CXTPSyntaxEditLexParseContext : public CXTPInternalUnknown
  2843. //CXTPSyntaxEditLexParseContext::CXTPSyntaxEditLexParseContext(CXTPSyntaxEditLexTextBlock* pBlock) :
  2844. //                  CXTPInternalUnknown(pBlock)
  2845. //{
  2846. //  ASSERT(pBlock);
  2847. //
  2848. //  m_pTextBlock = pBlock;
  2849. //}
  2850. //
  2851. //CXTPSyntaxEditLexParseContext::~CXTPSyntaxEditLexParseContext()
  2852. //{
  2853. //}
  2854. //
  2855. //void CXTPSyntaxEditLexParseContext::Set(LPCTSTR pcszParopPath, CXTPSyntaxEditLexVariant* pVar)
  2856. //{
  2857. //  if (pVar == NULL) {
  2858. //      m_mapVars.RemoveKey(pcszParopPath);
  2859. //
  2860. //  }
  2861. //  else {
  2862. //      CXTPSyntaxEditLexVariantPtr ptrVar = new CXTPSyntaxEditLexVariant(*pVar);
  2863. //
  2864. //      m_mapVars.SetAt(pcszParopPath, ptrVar);
  2865. //  }
  2866. //}
  2867. //
  2868. //CXTPSyntaxEditLexVariant* CXTPSyntaxEditLexParseContext::Get(LPCTSTR pcszParopPath)
  2869. //{
  2870. //  CXTPSyntaxEditLexVariantPtr ptrVar;
  2871. //
  2872. //  if (m_mapVars.Lookup(pcszParopPath, ptrVar)) {
  2873. //      return ptrVar.Detach();
  2874. //  }
  2875. //  return NULL;
  2876. //}
  2877. //
  2878. //
  2879. //CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexParseContext::GetTextBlock()
  2880. //{
  2881. //  if (m_pTextBlock) {
  2882. //      m_pTextBlock->InternalAddRef();
  2883. //  }
  2884. //  return m_pTextBlock;
  2885. //}
  2886. //
  2887. //void CXTPSyntaxEditLexParseContext::Close()
  2888. //{
  2889. //  m_pTextBlock = NULL;
  2890. //  m_mapVars.RemoveAll();
  2891. //}
  2892. ////////////////////////////////////////////////////////////////////////////
  2893. // CXTPSyntaxEditLexTextBlock
  2894. CXTPSyntaxEditLexTextBlock::CXTPSyntaxEditLexTextBlock() //:
  2895. //m_parseContext(this)
  2896. {
  2897. m_PosStartLC.nLine = 0;
  2898. m_PosStartLC.nCol = 0;
  2900. m_PosEndLC.nLine = 0;
  2901. m_PosEndLC.nCol = 0;
  2903. m_nStartTagLen = 0;
  2904. m_nEndTagXLCLen = 0;
  2906. m_bEndByParent = FALSE;
  2907. }
  2909. CXTPSyntaxEditLexTextBlock::~CXTPSyntaxEditLexTextBlock()
  2910. {
  2912. }
  2914. void CXTPSyntaxEditLexTextBlock::Close()
  2915. {
  2916. m_ptrLexClass = NULL;
  2917. m_ptrParent = NULL;
  2919. m_ptrPrev = NULL;
  2920. m_ptrNext= NULL;
  2921. m_ptrLastChild = NULL;
  2922. }
  2924. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextBlock::GetPrevChild(CXTPSyntaxEditLexTextBlock* pChild,
  2925.  BOOL bWithAddRef)
  2926. {
  2927. while (pChild && pChild != this)
  2928. {
  2929. if (!pChild->m_ptrPrev)
  2930. {
  2931. return NULL;
  2932. }
  2934. pChild = pChild->m_ptrPrev;
  2936. if (pChild && (CXTPSyntaxEditLexTextBlock*)pChild->m_ptrParent == this)
  2937. {
  2938. if (bWithAddRef)
  2939. {
  2940. pChild->InternalAddRef();
  2941. }
  2942. return pChild;
  2943. }
  2944. }
  2945. return NULL;
  2946. }
  2948. int CXTPSyntaxEditLexTextBlock::EndChildren(CXTPSyntaxEditLexTextSchema* pTxtSch, BOOL bEndByParent)
  2949. {
  2950. int nCount = 0;
  2951. //CSingleLock singleLock(GetDataLoker(), TRUE);
  2953. CXTPSyntaxEditLexTextBlock* pChTB = m_ptrLastChild;
  2954. while (pChTB)
  2955. {
  2956. if (!pChTB->m_PosEndLC.IsValidData())
  2957. {
  2958. pChTB->m_PosEndLC = m_PosEndLC;
  2959. pChTB->m_nEndTagXLCLen = m_nEndTagXLCLen;
  2960. pChTB->m_bEndByParent = bEndByParent;
  2962. nCount++;
  2964. if (pTxtSch)
  2965. {
  2966. pTxtSch->SendEvent_OnTextBlockParsed(pChTB);
  2967. }
  2968. nCount += pChTB->EndChildren(pTxtSch, bEndByParent);
  2969. }
  2970. pChTB = GetPrevChild(pChTB, FALSE);
  2971. }
  2972. return nCount;
  2973. }
  2975. BOOL CXTPSyntaxEditLexTextBlock::IsLookLikeClosed() const
  2976. {
  2977. if (!m_ptrLexClass && !m_ptrPrev && !m_ptrNext && !m_ptrLastChild &&
  2978. !m_ptrParent)
  2979. {
  2980. return TRUE;
  2981. }
  2982. return FALSE;
  2983. }
  2985. BOOL CXTPSyntaxEditLexTextBlock::IsInclude(CXTPSyntaxEditLexTextBlock* pTB2) const
  2986. {
  2987. if (!pTB2)
  2988. {
  2989. ASSERT(FALSE);
  2990. return FALSE;
  2991. }
  2992. ASSERT(m_PosStartLC.IsValidData() && pTB2->m_PosStartLC.IsValidData());
  2994. if (m_PosStartLC <= pTB2->m_PosStartLC && m_PosEndLC >= pTB2->m_PosEndLC &&
  2995. m_PosEndLC.IsValidData() && pTB2->m_PosEndLC.IsValidData() )
  2996. {
  2997. return TRUE;
  2998. }
  2999. return FALSE;
  3000. }
  3002. BOOL CXTPSyntaxEditLexTextBlock::IsEqualLexClasses(CXTPSyntaxEditLexTextBlock* pTB2) const
  3003. {
  3004. if (!m_ptrLexClass || !pTB2 || !pTB2->m_ptrLexClass)
  3005. {
  3006. ASSERT(FALSE);
  3007. return FALSE;
  3008. }
  3009. CString strThisClass = m_ptrLexClass->GetClassName();
  3010. CString strTB2Class = pTB2->m_ptrLexClass->GetClassName();
  3011. int nCmpRes = strThisClass.CompareNoCase(strTB2Class);
  3013. return nCmpRes==0;
  3014. }
  3016. ////////////////////////////////////////////////////////////////////////////
  3017. // CXTPSyntaxEditLexAnalyser
  3019. CXTPSyntaxEditLexParser::CXTPSyntaxEditLexParser()
  3020. {
  3021. m_pParseThread = NULL;
  3022. m_nParseThreadPriority = THREAD_PRIORITY_NORMAL;
  3023. // THREAD_PRIORITY_BELOW_NORMAL
  3024. // THREAD_PRIORITY_ABOVE_NORMAL;
  3026. //  m_SinkMT.SetOuter(this);
  3027. m_pConnect = new CXTPNotifyConnection;
  3029. m_ptrTextSchema = 0;
  3031. m_pSchOptions_default = new CXTPSyntaxEditLexParserSchemaOptions();
  3032. }
  3034. CXTPSyntaxEditLexParser::~CXTPSyntaxEditLexParser()
  3035. {
  3036. Close();
  3037. ASSERT(m_ptrTextSchema == 0);
  3039. #ifdef XTP_DBG_DUMP_OBJ
  3040. afxDump.SetDepth( 1 );
  3041. #endif
  3042. CMDTARGET_RELEASE(m_pConnect);
  3043. CMDTARGET_RELEASE(m_pSchOptions_default);
  3045. RemoveAllOptions();
  3046. }
  3048. void CXTPSyntaxEditLexParser::RemoveAllOptions()
  3049. {
  3050. POSITION pos = m_mapSchOptions.GetStartPosition();
  3051. while(pos)
  3052. {
  3053. CXTPSyntaxEditLexParserSchemaOptions* pOptions = NULL;
  3054. CString key;
  3056. m_mapSchOptions.GetNextAssoc(pos, key, pOptions);
  3057. CMDTARGET_RELEASE(pOptions);
  3058. }
  3059. m_mapSchOptions.RemoveAll();
  3060. }
  3062. CXTPNotifyConnection* CXTPSyntaxEditLexParser::GetConnection()
  3063. {
  3064. return m_pConnect;
  3065. }
  3067. CXTPSyntaxEditLexParser::CXTPSyntaxEditParseThreadParams::CXTPSyntaxEditParseThreadParams()
  3068. {
  3069. ptrBuffer = NULL;
  3070. }
  3072. void CXTPSyntaxEditLexParser::CXTPSyntaxEditParseThreadParams::AddParseZone(const CXTPSyntaxEditTextRegion& rZone)
  3073. {
  3074. const int cnEpsilon = XTP_EDIT_XLC(3, 0);
  3076. int nCount = (int)arInvalidZones.GetSize();
  3077. for (int i = 0; i < nCount; i++)
  3078. {
  3079. CXTPSyntaxEditTextRegion zoneI = arInvalidZones[i];
  3081. if (rZone.m_posEnd >= zoneI.m_posStart &&
  3082. rZone.m_posStart <= zoneI.m_posStart
  3083. ||
  3084. rZone.m_posEnd.GetXLC()+cnEpsilon >= zoneI.m_posStart.GetXLC() &&
  3085. rZone.m_posStart <= zoneI.m_posStart
  3086. )
  3087. {
  3088. zoneI.m_posStart = rZone.m_posStart;
  3089. arInvalidZones[i] = zoneI;
  3090. return;
  3091. }
  3092. else if (rZone.m_posStart <= zoneI.m_posEnd &&
  3093. rZone.m_posEnd >= zoneI.m_posEnd
  3094. ||
  3095. rZone.m_posStart.GetXLC()-cnEpsilon <= zoneI.m_posEnd.GetXLC() &&
  3096. rZone.m_posEnd >= zoneI.m_posEnd
  3097. )
  3098. {
  3099. zoneI.m_posEnd = rZone.m_posEnd;
  3100. arInvalidZones[i] = zoneI;
  3101. return;
  3102. }
  3103. else if (rZone.m_posStart >= zoneI.m_posStart
  3104. && rZone.m_posEnd <= zoneI.m_posEnd)
  3105. {
  3106. return; //nothing
  3107. }
  3108. }
  3109. arInvalidZones.Add(rZone);
  3110. }
  3112. void CXTPSyntaxEditLexParser::Close()
  3113. {
  3114. CSingleLock singLockMain(&m_csParserData);
  3116. CloseParseThread();
  3118. m_SinkMT.UnadviseAll();
  3120. CMDTARGET_RELEASE(m_ptrTextSchema);
  3121. }
  3123. void CXTPSyntaxEditLexParser::SelfCloseParseThread()
  3124. {
  3125. ASSERT(m_pParseThread);
  3127. if (m_pParseThread)
  3128. {
  3129. m_pParseThread = NULL;
  3131. m_PThreadParams.evExitThread.ResetEvent();
  3132. ASSERT(m_PThreadParams.arInvalidZones.GetSize() == 0);
  3134. if (m_ptrTextSchema)
  3135. {
  3136. m_ptrTextSchema->GetBreakParsingEvent()->ResetEvent();
  3137. }
  3138. }
  3139. }
  3141. //===========================================================================
  3142. //#pragma warning(push)
  3143. #pragma warning(disable: 4702)   // warning C4702: unreachable code
  3144. //----------------------------
  3145. void CXTPSyntaxEditLexParser::CloseParseThread()
  3146. {
  3147. StopParseInThread();
  3149. CSingleLock singLockMain(&m_csParserData);
  3151. if (m_pParseThread)
  3152. {
  3153. HANDLE hThread = NULL;
  3155. try
  3156. {
  3157. hThread = m_pParseThread->m_hThread;
  3158. }
  3159. catch (...)
  3160. {
  3161. TRACE(_T("ERROR! Parse Thread is not exist. [CloseParseThread()]n"));
  3162. }
  3163. m_pParseThread = NULL;
  3165. DWORD dwThreadRes = WAIT_TIMEOUT;
  3166. for (int i = 0; i < 10 && dwThreadRes == WAIT_TIMEOUT; i++)
  3167. {
  3168. m_PThreadParams.evParseRun.ResetEvent();
  3169. m_PThreadParams.evExitThread.SetEvent();
  3171. if (m_ptrTextSchema)
  3172. {
  3173. m_ptrTextSchema->GetBreakParsingEvent()->SetEvent();
  3174. }
  3176. if (hThread)
  3177. {
  3178. dwThreadRes = ::WaitForSingleObject(hThread, 20*1000);
  3179. }
  3180. else
  3181. {
  3182. Sleep(5000);
  3183. break;
  3184. }
  3185. }
  3186. if (dwThreadRes == WAIT_TIMEOUT && hThread)
  3187. {
  3188. ::TerminateThread(hThread, 0);
  3189. TRACE(_T("ERROR! Parser thread was not ended by normal way. It was terminated. n"));
  3190. }
  3191. m_PThreadParams.evExitThread.ResetEvent();
  3192. m_PThreadParams.arInvalidZones.RemoveAll();
  3194. if (m_ptrTextSchema)
  3195. {
  3196. m_ptrTextSchema->GetBreakParsingEvent()->ResetEvent();
  3197. }
  3198. }
  3199. }
  3200. //#pragma warning(pop)
  3201. //===========================================================================
  3203. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::GetBlocks()
  3204. {
  3205. return m_ptrFirstBlock.GetInterface(TRUE);
  3206. }
  3208. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::FindNearestTextBlock(XTP_EDIT_LINECOL posText)
  3209. {
  3210. CSingleLock singleLock(GetDataLoker(), TRUE);
  3212. //---------------------------------------------------------------------------
  3213. CXTPSyntaxEditLexTextBlockPtr ptrTBstart = GetBlocks();
  3214. CXTPSyntaxEditLexTextBlock* pTBnearest = ptrTBstart;
  3216. for (CXTPSyntaxEditLexTextBlock* pTB = ptrTBstart; pTB; pTB = pTB->m_ptrNext)
  3217. {
  3218. if (posText < pTB->m_PosStartLC)
  3219. {
  3220. break;
  3221. }
  3222. pTBnearest = pTB;
  3223. }
  3224. //--------------------------
  3225. while (pTBnearest && pTBnearest->m_ptrPrev &&
  3226.   pTBnearest->m_PosStartLC == pTBnearest->m_ptrPrev->m_PosStartLC)
  3227. {
  3228. pTBnearest = pTBnearest->m_ptrPrev;
  3229. }
  3231. //--------------------------
  3232. if (pTBnearest)
  3233. {
  3234. pTBnearest->InternalAddRef();
  3235. }
  3236. return pTBnearest;
  3237. }
  3239. BOOL CXTPSyntaxEditLexTextSchema::UpdateTBNearest(CXTPSyntaxEditLexTextBlock* pNarestTB1,
  3240. int nLineDiff, int nColDiff,
  3241. XTP_EDIT_LINECOL posFrom, XTP_EDIT_LINECOL posTo,
  3242.  int eEditAction )
  3243. {
  3244. int nResult = xtpEditUTBNothing;
  3246. CXTPSyntaxEditLexTextBlock* pTB;
  3247. for (pTB = pNarestTB1; pTB; pTB = pTB->m_ptrParent)
  3248. {
  3249. ASSERT(pTB != pTB->m_ptrParent);
  3251. //-------------------------------------------------------------
  3252. BOOL bIsBlockStartIntersected = eEditAction == xtpEditActDelete &&
  3253. pTB->m_PosStartLC >= posFrom && pTB->m_PosStartLC < posTo
  3254. ||
  3255. eEditAction == xtpEditActInsert &&
  3256. pTB->m_PosStartLC < posFrom &&
  3257. posFrom.GetXLC() < pTB->GetStartTagEndXLC();
  3259. if (bIsBlockStartIntersected)
  3260. {
  3261. nResult |= xtpEditUTBReparse;
  3262. if (pTB == pNarestTB1)
  3263. {
  3264. nResult |= xtpEditUTBNearestUpdated;
  3265. }
  3266. // set empty
  3267. pTB->m_PosEndLC.nLine = pTB->m_PosStartLC.nLine;
  3268. pTB->m_PosEndLC.nCol = pTB->m_PosStartLC.nCol-1;
  3269. continue;
  3270. }
  3272. //-------------------------------------------------------------
  3273. BOOL bIsEditingFullyInside = eEditAction == xtpEditActInsert &&
  3274. pTB->GetStartTagEndXLC() <= posFrom.GetXLC() &&
  3275. posFrom.GetXLC() <= pTB->GetEndTagBeginXLC()
  3276. ||
  3277. eEditAction == xtpEditActDelete &&
  3278. pTB->GetStartTagEndXLC() <= posFrom.GetXLC() &&
  3279. posTo.GetXLC() <= pTB->GetEndTagBeginXLC();
  3281. if (bIsEditingFullyInside)
  3282. {
  3283. if (pTB == pNarestTB1)
  3284. {
  3285. nResult |= xtpEditUTBNearestUpdated;
  3286. }
  3287. BOOL bEmpty = FALSE;
  3289. pTB->m_PosEndLC.nLine += nLineDiff;
  3291. if (pTB->m_PosEndLC.nLine < pTB->m_PosStartLC.nLine)
  3292. {
  3293. // set empty
  3294. bEmpty = TRUE;
  3295. pTB->m_PosEndLC.nLine = pTB->m_PosStartLC.nLine;
  3296. pTB->m_PosEndLC.nCol = pTB->m_PosStartLC.nCol-1;
  3297. }
  3298. int nELine = eEditAction == xtpEditActInsert ? posTo.nLine : posFrom.nLine;
  3299. if (!bEmpty && pTB->m_PosEndLC.nLine == nELine)
  3300. {
  3301. pTB->m_PosEndLC.nCol += nColDiff;
  3302. if (pTB->m_PosEndLC.nCol < 0)
  3303. {
  3304. pTB->m_PosEndLC.nCol = 0;
  3305. }
  3306. }
  3307. continue;
  3308. }
  3310. //-------------------------------------------------------------
  3311. BOOL bIsBlockEndIntersected = eEditAction == xtpEditActDelete &&
  3312. (!(posTo.GetXLC() <= pTB->GetEndTagBeginXLC() ||
  3313. posFrom.GetXLC() > pTB->GetEndTagEndXLC() )
  3314. )
  3315. ||
  3316. eEditAction == xtpEditActInsert &&
  3317. posFrom.GetXLC() > pTB->GetEndTagBeginXLC() &&
  3318. posFrom.GetXLC() <= pTB->GetEndTagEndXLC();
  3320. if (bIsBlockEndIntersected)
  3321. {
  3322. nResult |= xtpEditUTBReparse;
  3323. if (pTB == pNarestTB1)
  3324. {
  3325. nResult |= xtpEditUTBNearestUpdated;
  3326. }
  3327. // set empty
  3328. pTB->m_PosEndLC.nLine = 0;
  3329. pTB->m_PosEndLC.nCol =  0;
  3330. continue;
  3331. }
  3332. }
  3334. //--------------------
  3335. return nResult;
  3336. }
  3338. int CXTPSyntaxEditLexTextSchema::UpdateTextBlocks(XTP_EDIT_LINECOL posFrom, XTP_EDIT_LINECOL posTo,
  3339.  int eEditAction )
  3341. {
  3342. CSingleLock singleLock(GetDataLoker());
  3344. //BOOL bLocked = TryLockCS(&singleLock, GetDataLoker(), 5000, 50);
  3345. BOOL bLocked = singleLock.Lock(5000);
  3347. if (!bLocked)
  3348. {
  3349. ASSERT(FALSE);
  3350. TRACE(_T("ERROR! Cannot enter critical section. [Dead lock, hang up???] CXTPSyntaxEditLexTextSchema::UpdateTextBlocks() n"));
  3351. return xtpEditUTBError;
  3352. }
  3354. CXTPSyntaxEditLexTextBlockPtr ptrNarestTB1 = FindNearestTextBlock(posFrom);
  3355. if (!ptrNarestTB1)
  3356. {
  3357. return xtpEditUTBNothing;
  3358. }
  3360. int nLineDiff = posTo.nLine - posFrom.nLine;
  3361. int nColDiff = posTo.nCol - posFrom.nCol;
  3363. ASSERT(nLineDiff >= 0);
  3365. if (eEditAction == xtpEditActDelete)
  3366. {
  3367. nLineDiff *= -1;
  3368. nColDiff *= -1;
  3369. }
  3371. //- (1)- update FullyInside nearest and parents blocks
  3372. int nURes = UpdateTBNearest(ptrNarestTB1, nLineDiff,
  3373. nColDiff, posFrom, posTo, eEditAction);
  3375. //- (2)- update block after nearest
  3376. CXTPSyntaxEditLexTextBlock* pTB = (nURes & xtpEditUTBNearestUpdated) ? ptrNarestTB1->m_ptrNext :
  3377. ptrNarestTB1;
  3379. for (; pTB; pTB = pTB->m_ptrNext)
  3380. {
  3381. //-------------------------------------------------------------
  3382. BOOL bIsBlockStartIntersected = eEditAction == xtpEditActDelete &&
  3383. (!(posTo <= pTB->m_PosStartLC ||
  3384. posFrom.GetXLC() >= pTB->GetStartTagEndXLC())
  3385. )
  3386. ||
  3387. eEditAction == xtpEditActInsert &&
  3388. pTB->m_PosStartLC < posFrom &&
  3389. posFrom.GetXLC() < pTB->GetStartTagEndXLC();
  3391. if (bIsBlockStartIntersected)
  3392. {
  3393. nURes |= xtpEditUTBReparse;
  3395. // set empty
  3396. pTB->m_PosEndLC.nLine = pTB->m_PosStartLC.nLine;
  3397. pTB->m_PosEndLC.nCol = pTB->m_PosStartLC.nCol-1;
  3398. continue;
  3399. }
  3401. //-------------------------------------------------------------
  3402. BOOL bIsEditingFullyInside = eEditAction == xtpEditActInsert &&
  3403. pTB->GetStartTagEndXLC() <= posFrom.GetXLC() &&
  3404. posFrom.GetXLC() <= pTB->GetEndTagBeginXLC()
  3405. ||
  3406. eEditAction == xtpEditActDelete &&
  3407. pTB->GetStartTagEndXLC() <= posFrom.GetXLC() &&
  3408. posTo.GetXLC() <= pTB->GetEndTagBeginXLC(); // ??? +- 1;
  3411. if (bIsEditingFullyInside)
  3412. {
  3413. BOOL bEmpty = FALSE;
  3415. pTB->m_PosEndLC.nLine += nLineDiff;
  3417. if (pTB->m_PosEndLC.nLine < pTB->m_PosStartLC.nLine)
  3418. {
  3419. // set empty
  3420. bEmpty = TRUE;
  3421. pTB->m_PosEndLC.nLine = pTB->m_PosStartLC.nLine;
  3422. pTB->m_PosEndLC.nCol = pTB->m_PosStartLC.nCol-1;
  3423. }
  3424. int nELine = eEditAction == xtpEditActInsert ? posTo.nLine : posFrom.nLine;
  3425. if (!bEmpty && pTB->m_PosEndLC.nLine == nELine)
  3426. {
  3427. pTB->m_PosEndLC.nCol += nColDiff;
  3428. if (pTB->m_PosEndLC.nCol < 0)
  3429. {
  3430. pTB->m_PosEndLC.nCol = 0;
  3431. }
  3432. }
  3433. continue;
  3434. }
  3436. //-------------------------------------------------------------
  3437. BOOL bIsBlockEndIntersected = eEditAction == xtpEditActDelete &&
  3438. (!(posTo.GetXLC() <= pTB->GetEndTagBeginXLC() ||
  3439. posFrom.GetXLC() > pTB->GetEndTagEndXLC() )
  3440. )
  3441. ||
  3442. eEditAction == xtpEditActInsert &&
  3443. posFrom.GetXLC() > pTB->GetEndTagBeginXLC() &&
  3444. posFrom.GetXLC() <= pTB->GetEndTagEndXLC();
  3446. if (bIsBlockEndIntersected)
  3447. {
  3448. nURes |= xtpEditUTBReparse;
  3450. // set empty
  3451. pTB->m_PosEndLC.nLine = 0;
  3452. pTB->m_PosEndLC.nCol = 0;
  3453. continue;
  3454. }
  3456. //-------------------------------------------------------------------
  3457. BOOL bIsBlockOutside = eEditAction == xtpEditActInsert &&
  3458. pTB->m_PosStartLC >= posFrom ||
  3459. eEditAction == xtpEditActDelete && pTB->m_PosStartLC >= posTo;
  3460. //-----------------------------
  3461. int nELine = eEditAction == xtpEditActInsert ? posTo.nLine : posFrom.nLine;
  3463. if (bIsBlockOutside && nLineDiff == 0 &&
  3464. pTB->m_PosStartLC.nLine != nELine &&
  3465. pTB->m_PosEndLC.nLine != nELine)
  3466. {
  3467. break;
  3468. }
  3469. //-------------------------------------------------------------------
  3471. if (bIsBlockOutside )
  3472. {
  3473. pTB->m_PosStartLC.nLine += nLineDiff;
  3474. pTB->m_PosEndLC.nLine += nLineDiff;
  3476. if (pTB->m_PosStartLC.nLine == nELine)
  3477. {
  3478. pTB->m_PosStartLC.nCol += nColDiff;
  3479. }
  3480. if (pTB->m_PosEndLC.nLine == nELine)
  3481. {
  3482. pTB->m_PosEndLC.nCol += nColDiff;
  3483. }
  3484. }
  3485. //-------------------------------------------------------------------
  3486. }
  3488. return nURes;
  3489. }
  3491. BOOL CXTPSyntaxEditLexTextSchema::LoadClassSchema(CXTPSyntaxEditLexClassInfoArray* arClassInfo)
  3492. {
  3493. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  3494. CSingleLock singleLock(GetDataLoker(), TRUE);
  3496. RemoveAll();
  3497. m_pClassSchema->RemoveAll();
  3499. int nCCount = (int)arClassInfo->GetSize();
  3500. for (int i = 0; i < nCCount; i++)
  3501. {
  3502. const XTP_EDIT_LEXCLASSINFO& infoClass = arClassInfo->GetAt(i);
  3504. CXTPSyntaxEditLexClassPtr ptrLexClass = m_pClassSchema->GetNewClass(FALSE);
  3505. if (!ptrLexClass)
  3506. {
  3507. return FALSE;
  3508. }
  3509. ptrLexClass->m_strClassName = infoClass.csClassName;
  3511. int nPCount = (int)infoClass.arPropertyDesc.GetSize();
  3512. for (int k = 0; k < nPCount; k++)
  3513. {
  3514. const XTP_EDIT_LEXPROPINFO& infoProp = infoClass.arPropertyDesc[k];
  3515. if (!ptrLexClass->SetProp(&infoProp))
  3516. {
  3517. ASSERT(FALSE);
  3518. }
  3519. }
  3521. m_pClassSchema->AddPreBuildClass(ptrLexClass);
  3523. #ifdef DBG_TRACE_LOAD_CLASS_SCH
  3524. {
  3525. BOOL bEmpty = ptrLexClass->IsEmpty() && ptrLexClass->m_Parent.eOpt != xtpEditOptParent_file;
  3526. LPCTSTR cszPref = bEmpty ? _T("* !EMPTY! (it is not used)* ") : _T("* ");
  3527. ptrLexClass->Dump(cszPref);
  3528. }
  3529. #endif
  3530. }
  3532. return TRUE;
  3533. //BOOL bRes = m_pClassSchema->Build();
  3534. //return bRes;
  3535. }
  3538. void CXTPSyntaxEditLexTextSchema::BuildIfNeed()
  3539. {
  3540. CSingleLock singleLockCls(GetClassSchLoker(), TRUE);
  3541. CSingleLock singleLock(GetDataLoker(), TRUE);
  3543. CXTPSyntaxEditLexClassPtrArray* ptrArCfile = m_pClassSchema->GetClasses(FALSE);
  3544. if (!ptrArCfile || ptrArCfile->GetSize() == 0)
  3545. {
  3546. m_pClassSchema->Build();
  3547. }
  3548. }
  3550. BOOL CXTPSyntaxEditLexTextSchema::IsFileExtSupported(const CString& strExt)
  3551. {
  3552. CXTPSyntaxEditLexClassPtr ptrTopCls = GetTopClassForFileExt(strExt);
  3553. return ptrTopCls != NULL;
  3554. }
  3556. CXTPSyntaxEditLexClass* CXTPSyntaxEditLexTextSchema::GetTopClassForFileExt(const CString& strExt)
  3557. {
  3558. CString strPropName = _T("IsExt=") + strExt;
  3560. CXTPSyntaxEditLexClassPtrArray arTopClasses;
  3561. CXTPSyntaxEditLexClassPtrArray* ptrArCfile = m_pClassSchema->GetClasses(TRUE);
  3562. int nCount = ptrArCfile ? (int)ptrArCfile->GetSize() : 0;
  3563. int i;
  3565. if (nCount == 0)
  3566. {
  3567. BOOL bUnused;
  3568. ptrArCfile = m_pClassSchema->GetChildrenFor(NULL, bUnused);
  3569. nCount = ptrArCfile ? (int)ptrArCfile->GetSize() : 0;
  3571. for (i = 0; i < nCount; i++)
  3572. {
  3573. CXTPSyntaxEditLexClassPtr ptrCfile = ptrArCfile->GetAt(i);
  3574. CXTPSyntaxEditLexClassPtr ptrCFnew = m_pClassSchema->GetNewClass(TRUE);
  3575. if (ptrCFnew)
  3576. {
  3577. ptrCFnew->CopyFrom(ptrCfile);
  3578. arTopClasses.AddPtr(ptrCFnew, TRUE);
  3579. }
  3580. }
  3582. SAFE_DELETE(ptrArCfile);
  3583. ptrArCfile = &arTopClasses;
  3584. }
  3586. nCount = ptrArCfile ? (int)ptrArCfile->GetSize() : 0;
  3587. for (i = 0; i < nCount; i++)
  3588. {
  3589. CXTPSyntaxEditLexClassPtr ptrCfile = ptrArCfile->GetAt(i);
  3591. CXTPSyntaxEditLexVariantPtr ptrRes = ptrCfile->PropV(strPropName);
  3593. if (!ptrRes || ptrRes->m_nObjType != xtpEditLVT_valInt)
  3594. {
  3595. ASSERT(FALSE);
  3596. continue;
  3597. }
  3598. if (ptrRes->m_nValue)
  3599. {
  3600. return ptrCfile.Detach();
  3601. }
  3602. }
  3603. return NULL;
  3604. }
  3607. CXTPSyntaxEditLexTextSchema* CXTPSyntaxEditLexParser::GetTextSchema()
  3608. {
  3609. return m_ptrTextSchema;
  3610. }
  3612. void CXTPSyntaxEditLexParser::SetTextSchema(CXTPSyntaxEditLexTextSchema* pTextSchema)
  3613. {
  3614. CSingleLock singLockMain(&m_csParserData);
  3616. CloseParseThread();
  3618. if (m_ptrTextSchema)
  3619. {
  3620. m_ptrTextSchema->RemoveAll();
  3621. }
  3623. m_SinkMT.UnadviseAll();
  3625. CMDTARGET_RELEASE(m_ptrTextSchema);
  3626. RemoveAllOptions();
  3628. if (pTextSchema)
  3629. {
  3630. pTextSchema->BuildIfNeed();
  3631. m_ptrTextSchema = pTextSchema->Clone();
  3633. CXTPNotifyConnection* ptrConn = m_ptrTextSchema ? m_ptrTextSchema->GetConnection() : NULL;
  3634. if (ptrConn)
  3635. {
  3636. m_SinkMT.Advise(ptrConn, xtpEditOnParserStarted,   &XTPSyntaxEditLexAnalyser::CXTPSyntaxEditLexParser::OnParseEvent_NotificationHandler);
  3637. m_SinkMT.Advise(ptrConn, xtpEditOnTextBlockParsed, &XTPSyntaxEditLexAnalyser::CXTPSyntaxEditLexParser::OnParseEvent_NotificationHandler);
  3638. m_SinkMT.Advise(ptrConn, xtpEditOnParserEnded,     &XTPSyntaxEditLexAnalyser::CXTPSyntaxEditLexParser::OnParseEvent_NotificationHandler);
  3639. }
  3640. }
  3642. #ifdef _DEBUG
  3643. AfxDump(XTPGetLexAutomatMemMan());
  3644. #endif
  3645. }
  3647. BOOL CXTPSyntaxEditLexParser::GetTokensForAutoCompleate(CXTPSyntaxEditLexTokensDefArray& rArTokens,
  3648.   BOOL bAppend)
  3649. {
  3650. CSingleLock singLockMain(&m_csParserData);
  3652. if (!bAppend)
  3653. {
  3654. rArTokens.RemoveAll();
  3655. }
  3657. CXTPSyntaxEditLexTextSchema* ptrTxtSch = GetTextSchema();
  3658. CXTPSyntaxEditLexClassSchema* ptrClsSch = ptrTxtSch ? ptrTxtSch->GetClassSchema() : NULL;
  3659. CXTPSyntaxEditLexClassPtrArray* ptrArCls = ptrClsSch ? ptrClsSch->GetPreBuildClasses() : NULL;
  3661. if (!ptrArCls)
  3662. {
  3663. return FALSE;
  3664. }
  3666. //--------------------------------------------------
  3667. int nCCount = (int)ptrArCls->GetSize();
  3668. for (int i = 0; i < nCCount; i++)
  3669. {
  3670. CXTPSyntaxEditLexTokensDef tmpTkDef;
  3672. CXTPSyntaxEditLexClassPtr ptrCls = ptrArCls->GetAt(i);
  3673. CXTPSyntaxEditLexVariantPtr ptrTags = ptrCls->PropV(_T("token:tag"));
  3675. if (!ptrTags)
  3676. {
  3677. continue;
  3678. }
  3679. GetStrsFromLVArray(ptrTags, tmpTkDef.m_arTokens);
  3681. //--------------------
  3682. CXTPSyntaxEditLexVariantPtr ptrSartSeps = ptrCls->PropV(_T("token:start:separators"));
  3683. CXTPSyntaxEditLexVariantPtr ptrEndSeps = ptrCls->PropV(_T("token:end:separators"));
  3684. if (ptrSartSeps)
  3685. {
  3686. GetStrsFromLVArray(ptrSartSeps, tmpTkDef.m_arStartSeps);
  3687. }
  3689. if (ptrEndSeps)
  3690. {
  3691. GetStrsFromLVArray(ptrEndSeps, tmpTkDef.m_arEndSeps);
  3692. }
  3694. //=================
  3695. rArTokens.Add(tmpTkDef);
  3696. }
  3698. return TRUE;
  3699. }
  3701. void CXTPSyntaxEditLexParser::GetStrsFromLVArray(CXTPSyntaxEditLexVariant* pLVArray,
  3702.   CStringArray& rArStrs) const
  3703. {
  3704. if (!pLVArray || pLVArray->m_nObjType != xtpEditLVT_LVArrayPtr ||
  3705. !pLVArray->m_ptrLVArrayPtr)
  3706. {
  3707. ASSERT(FALSE);
  3708. return;
  3709. }
  3711. int nCount = (int)pLVArray->m_ptrLVArrayPtr->GetSize();
  3712. for (int i = 0; i < nCount; i++)
  3713. {
  3714. CXTPSyntaxEditLexVariantPtr ptrLVVal = pLVArray->m_ptrLVArrayPtr->GetAt(i);
  3715. ASSERT(ptrLVVal);
  3717. if (ptrLVVal && ptrLVVal->m_nObjType == xtpEditLVT_valStr)
  3718. {
  3719. for (int k = 0; k < ptrLVVal->m_arStrVals.GetSize(); k++)
  3720. {
  3721. CString strVal = ptrLVVal->m_arStrVals[k];
  3722. ASSERT(strVal.GetLength());
  3724. if (strVal.GetLength())
  3725. {
  3726. rArStrs.Add(strVal);
  3727. }
  3728. }
  3729. }
  3730. }
  3731. }
  3734. ////////////////////////////////////////////////////////////////////////////
  3735. CXTPSyntaxEditLexParser::CXTPSyntaxEditParseThreadParams* CXTPSyntaxEditLexParser::GetParseInThreadParams()
  3736. {
  3737. return &m_PThreadParams;
  3738. }
  3740. void CXTPSyntaxEditLexParser::StartParseInThread(CXTPSyntaxEditBufferManager* pBuffer,
  3741. const XTP_EDIT_LINECOL* pLCStart, const XTP_EDIT_LINECOL* pLCEnd,
  3742. int eEdinAction, BOOL bRunWithoutWait)
  3743. {
  3744. UNREFERENCED_PARAMETER(eEdinAction);
  3745. DBG_TRACE_TIME(1, _T("### ### ### StartParseInThread time = "));
  3747. CSingleLock singLockMain(&m_csParserData);
  3749. if (!m_ptrTextSchema)
  3750. {
  3751. return;
  3752. }
  3754. CSingleLock singLockPrm(&m_PThreadParams.lockThreadParams);
  3756. //if (IsCSLocked(m_PThreadParams.lockThreadParams)) {
  3757. if (IsMutexLocked(&m_PThreadParams.lockThreadParams))
  3758. {
  3759. DBG_TRACE_PARSE_START_STOP(_T("- Parser set BREAK Event. n"));
  3761. VERIFY( m_ptrTextSchema->GetBreakParsingEvent()->SetEvent() );
  3762. }
  3763. if (!singLockPrm.Lock())
  3764. {
  3765. ASSERT(FALSE);
  3766. return;
  3767. }
  3769. m_PThreadParams.ptrBuffer = pBuffer;
  3771. CXTPSyntaxEditTextRegion invZone;
  3773. if (pLCStart && !pLCEnd && pLCStart->GetXLC() == XTP_EDIT_XLC(1, 0) )
  3774. {
  3775. invZone.Set(pLCStart, pLCEnd);
  3776. m_PThreadParams.arInvalidZones.RemoveAll();
  3777. m_PThreadParams.AddParseZone(invZone);
  3778. }
  3779. else if (pLCStart || pLCEnd)
  3780. {
  3781. invZone.Set(pLCStart, pLCEnd);
  3782. m_PThreadParams.AddParseZone(invZone);
  3783. }
  3785. if (!m_pParseThread)
  3786. {// create thread
  3787. m_pParseThread = AfxBeginThread(ThreadParseProc, this, m_nParseThreadPriority);
  3788. if (!m_pParseThread)
  3789. {
  3790. ASSERT(FALSE);
  3791. return;
  3792. }
  3793. }
  3795. if (!SetParseThreadPriority(m_nParseThreadPriority))
  3796. {
  3797. // try to start a new thread
  3798. StartParseInThread(pBuffer, pLCStart, pLCEnd, eEdinAction, bRunWithoutWait);
  3799. }
  3801. CString sDBGpos = DBG_TraceIZone(pLCStart, pLCEnd);
  3802. DBG_TRACE_PARSE_START_STOP(_T("- Parser set START Event. Add invalid Zone [ %s ] n"), (LPCTSTR)sDBGpos);
  3804. if (bRunWithoutWait)
  3805. {
  3806. VERIFY( m_PThreadParams.evRunWithoutWait.SetEvent() );
  3807. }
  3808. VERIFY( m_PThreadParams.evParseRun.SetEvent() );
  3809. }
  3811. void CXTPSyntaxEditLexParser::StopParseInThread()
  3812. {
  3813. DBG_TRACE_TIME(1, _T("### ### ### STOP Parse In Thread time = "));
  3815. CSingleLock singLockMain(&m_csParserData);
  3817. if (!m_ptrTextSchema)
  3818. {
  3819. return;
  3820. }
  3822. CSingleLock singLockPrm(&m_PThreadParams.lockThreadParams);
  3823. CEvent* pBreakEvent = m_ptrTextSchema->GetBreakParsingEvent();
  3824. ASSERT(pBreakEvent);
  3825. if (!pBreakEvent)
  3826. return;
  3828. if (IsMutexLocked(&m_PThreadParams.lockThreadParams))
  3829. {
  3830. VERIFY( pBreakEvent->SetEvent() );
  3832. DBG_TRACE_PARSE_START_STOP(_T("- STOP Parser set BREAK Event. n"));
  3833. }
  3835. if (!singLockPrm.Lock())
  3836. {
  3837. ASSERT(FALSE);
  3838. return;
  3839. }
  3840. if (IsEventSet(*pBreakEvent))
  3841. {
  3842. VERIFY( pBreakEvent->ResetEvent() );
  3844. DBG_TRACE_PARSE_START_STOP(_T("- STOP Parser REset BREAK Event. n"));
  3845. }
  3847. DBG_TRACE_PARSE_START_STOP(_T("- STOP Parser finished. n"));
  3848. }
  3850. int CXTPSyntaxEditLexParser::GetParseThreadPriority()
  3851. {
  3852. try
  3853. {
  3854. if (m_pParseThread)
  3855. {
  3856. int nPriority = m_pParseThread->GetThreadPriority();
  3857. return nPriority;
  3858. }
  3859. }
  3860. catch (...)
  3861. {
  3862. m_pParseThread = NULL;
  3863. TRACE(_T("ERROR! Parse Thread is not exist. n"));
  3864. };
  3866. return m_nParseThreadPriority;
  3867. }
  3869. BOOL CXTPSyntaxEditLexParser::SetParseThreadPriority(int nPriority)
  3870. {
  3871. m_nParseThreadPriority = nPriority;
  3872. try
  3873. {
  3874. if (m_pParseThread)
  3875. {
  3876. if (m_nParseThreadPriority != m_pParseThread->GetThreadPriority())
  3877. {
  3878. m_pParseThread->SetThreadPriority(m_nParseThreadPriority);
  3879. }
  3880. }
  3881. }
  3882. catch (...)
  3883. {
  3884. TRACE(_T("ERROR! Parse Thread is not exist. n"));
  3886. m_pParseThread = NULL;
  3887. return FALSE;
  3888. }
  3889. return TRUE;
  3890. }
  3892. void CXTPSyntaxEditLexParser::OnBeforeEditChanged()
  3893. {
  3894. //CSingleLock singLockMain(&m_csParserData);
  3896. StopParseInThread();
  3897. }
  3899. void CXTPSyntaxEditLexParser::OnEditChanged(const XTP_EDIT_LINECOL& posFrom,
  3900.   const XTP_EDIT_LINECOL& posTo, int eEditAction,
  3901.   CXTPSyntaxEditBufferManager* pBuffer)
  3902. {
  3903. DBG_TRACE_TIME(1, _T("### ### ### OnEditChanged time = "));
  3905. CSingleLock singLockMain(&m_csParserData);
  3907. if (!m_ptrTextSchema)
  3908. {
  3909. return;
  3910. }
  3912. if (!pBuffer)
  3913. {
  3914. ASSERT(FALSE);
  3915. return;
  3916. }
  3919. m_ptrTextSchema->UpdateTextBlocks(posFrom, posTo, eEditAction);
  3921. BOOL bThreadParse = GetSchemaOptions(pBuffer->GetFileExt())->m_bEditReparceInSeparateThread;
  3922. if (bThreadParse)
  3923. {
  3924. StartParseInThread(pBuffer, &posFrom, &posTo, eEditAction, FALSE);
  3925. }
  3926. else
  3927. {
  3928. CXTPSyntaxEditTextIterator txtIter(pBuffer);
  3929. m_ptrTextSchema->RunParseUpdate(TRUE, &txtIter, &posFrom, &posTo);
  3930. }
  3931. }
  3933. void CXTPSyntaxEditLexParser::OnParseEvent_NotificationHandler(XTP_NOTIFY_CODE Event,
  3934.  WPARAM wParam, LPARAM lParam)
  3935. {
  3936. if (Event == xtpEditOnTextBlockParsed)
  3937. {
  3938. CXTPSyntaxEditLexTextBlockPtr ptrTBended;
  3940. CXTPSyntaxEditLexTextSchema* ptrTextSch = GetTextSchema();
  3941. ptrTBended = ptrTextSch ? ptrTextSch->GetLastParsedBlock(wParam) : NULL;
  3943. if (ptrTBended)
  3944. {
  3945. m_pConnect->SendEvent(Event, (WPARAM)(CXTPSyntaxEditLexTextBlock*)ptrTBended, 0);
  3946. }
  3947. }
  3948. else
  3949. {
  3950. m_pConnect->SendEvent(Event, wParam, lParam);
  3951. }
  3952. }
  3953. UINT CXTPSyntaxEditLexParser::ThreadParseProc(LPVOID pParentParser)
  3954. {
  3955. DBG_TRACE_PARSE_START_STOP(_T("*** Parser Thread is started. %08xn"), ::GetCurrentThreadId());
  3957. if (!pParentParser)
  3958. {
  3959. ASSERT(FALSE);
  3960. return 111;
  3961. }
  3963. //  try
  3964. {
  3965. CXTPSyntaxEditLexParserPtr ptrParser((CXTPSyntaxEditLexParser*)pParentParser, TRUE);
  3966. CXTPSyntaxEditLexParser::CXTPSyntaxEditParseThreadParams* pPRMs = NULL;
  3967. pPRMs = ptrParser->GetParseInThreadParams();
  3968. if (!pPRMs)
  3969. {
  3970. ASSERT(FALSE);
  3971. return 222;
  3972. }
  3973. CSingleLock lockPRMs(&pPRMs->lockThreadParams, TRUE);
  3975. HANDLE arWaiters[] = {pPRMs->evParseRun, pPRMs->evExitThread};
  3976. HANDLE hRunWithoutWait = pPRMs->evRunWithoutWait;
  3978. DWORD dwSelfCloseTimeout_ms = ptrParser->GetSchemaOptions(
  3979. pPRMs->ptrBuffer->GetFileExt())->m_dwParserThreadIdleLifeTime_ms;
  3981. DWORD dwWaitFilter_ms = ptrParser->GetSchemaOptions(
  3982. pPRMs->ptrBuffer->GetFileExt())->m_dwEditReparceTimeout_ms;
  3984. lockPRMs.Unlock();
  3986. DWORD dwWaitRes = 0;
  3987. do
  3988. {
  3989. dwWaitRes = WaitForMultipleObjects(2, arWaiters, FALSE, dwSelfCloseTimeout_ms);
  3991. if (dwWaitRes == WAIT_TIMEOUT)
  3992. {
  3993. CSingleLock lockPRMs1(&pPRMs->lockThreadParams, TRUE);
  3995. if (pPRMs->arInvalidZones.GetSize() == 0)
  3996. {
  3997. ptrParser->SelfCloseParseThread();
  3998. return 1;
  3999. }
  4000. else
  4001. {
  4002. continue;
  4003. }
  4004. }
  4006. //=== Wait Filter === (for keyboard input)
  4007. if (dwWaitRes == WAIT_OBJECT_0 && !IsEventSet(hRunWithoutWait))
  4008. {
  4009. do {
  4010. dwWaitRes = WaitForMultipleObjects(2, arWaiters, FALSE, dwWaitFilter_ms);
  4011. }
  4012. while (dwWaitRes == WAIT_OBJECT_0 && !IsEventSet(hRunWithoutWait));
  4014. if (dwWaitRes == WAIT_TIMEOUT)
  4015. {
  4016. dwWaitRes = WAIT_OBJECT_0;
  4017. }
  4018. }
  4019. //=== Wait Filter === (for keyboard input)
  4021. if (dwWaitRes == WAIT_OBJECT_0)
  4022. {
  4023. //***
  4024. CSingleLock lockPRMs2(&pPRMs->lockThreadParams, TRUE);
  4025. //***
  4027. // Update Options
  4028. dwSelfCloseTimeout_ms = ptrParser->GetSchemaOptions(
  4029. pPRMs->ptrBuffer->GetFileExt())->m_dwParserThreadIdleLifeTime_ms;
  4031. dwWaitFilter_ms = ptrParser->GetSchemaOptions(
  4032. pPRMs->ptrBuffer->GetFileExt())->m_dwEditReparceTimeout_ms;
  4033. // END Update Options
  4035. CXTPSyntaxEditTextIterator txtIter(pPRMs->ptrBuffer);
  4037. CXTPSyntaxEditLexTextSchema* ptrTextSch = ptrParser->GetTextSchema();
  4038. if (!ptrTextSch)
  4039. {
  4040. continue;
  4041. }
  4042. CEvent* pBreakEvent = ptrTextSch->GetBreakParsingEvent();
  4043. ASSERT(pBreakEvent);
  4045. int nZonesCount = 0;
  4046. BOOL bParseRestedBlock = FALSE;
  4047. BOOL bBreaked = FALSE;
  4048. do
  4049. {
  4050. if (IsEventSet(*pBreakEvent))
  4051. {
  4052. VERIFY( pBreakEvent->ResetEvent() );
  4053. DBG_TRACE_PARSE_START_STOP(_T("* Parser Start BREAKED. n"));
  4054. break;
  4055. }
  4057. XTP_EDIT_LINECOL* pLCStart = NULL;
  4058. XTP_EDIT_LINECOL* pLCEnd = NULL;
  4059. CXTPSyntaxEditTextRegion iZone;
  4061. nZonesCount = (int)pPRMs->arInvalidZones.GetSize();
  4062. //bParseRestedBlock = FALSE; //nZonesCount > 0;
  4064. if (nZonesCount)
  4065. {
  4066. iZone = pPRMs->arInvalidZones[nZonesCount-1];
  4068. if (iZone.m_posStart.IsValidData())
  4069. {
  4070. pLCStart = &iZone.m_posStart;
  4071. }
  4072. if (iZone.m_posEnd.IsValidData())
  4073. {
  4074. pLCEnd = &iZone.m_posEnd;
  4075. }
  4076. }
  4078. CString sDBGpos = DBG_TraceIZone(pLCStart, pLCEnd);
  4079. DBG_TRACE_PARSE_START_STOP(_T("* Parser Started. Invalid Zone [%s] n"), sDBGpos);
  4081. // run parser
  4082. /*DEBUG*/ DWORD dwTime0 = GetTickCount();   //DEBUG
  4084. int nParseRes = ptrTextSch->RunParseUpdate(TRUE, &txtIter,
  4085. pLCStart, pLCEnd, TRUE);
  4086. if (nParseRes & xtpEditLPR_Error)
  4087. {
  4088. //ASSERT(FALSE);
  4089. //::MessageBeep((UINT)-1);
  4090. TRACE(_T("Lex Parser ERROR! Try Full reparse. n"));
  4092. ptrTextSch->RemoveAll();
  4094. XTP_EDIT_LINECOL posLC1 = {1,0};
  4095. txtIter.SeekBegin();
  4097. nParseRes = ptrTextSch->RunParseUpdate(TRUE, &txtIter,
  4098. &posLC1, NULL);
  4100. pPRMs->arInvalidZones.RemoveAll();
  4101. nZonesCount = 0;
  4103. if (nParseRes & xtpEditLPR_RunFinished)
  4104. {
  4105. TRACE(_T("Full reparse - (OK) <F I N I S H E D>  n"));
  4106. }
  4107. else if (nParseRes & xtpEditLPR_RunBreaked)
  4108. {
  4109. TRACE(_T("Full reparse - BREAKED  n"));
  4111. iZone.Set(NULL, NULL);
  4112. pPRMs->arInvalidZones.Add(iZone);
  4113. }
  4114. else if (nParseRes & xtpEditLPR_Error)
  4115. {
  4116. TRACE(_T("Full reparse - ERROR  n"));
  4117. }
  4118. nZonesCount = (int)pPRMs->arInvalidZones.GetSize();
  4119. }
  4121. /*DEBUG*/ DWORD dwTime1 = GetTickCount();//DEBUG
  4123. bBreaked = (nParseRes & xtpEditLPR_RunFinished) == 0 ||
  4124. (nParseRes & (xtpEditLPR_RunBreaked|xtpEditLPR_Error)) > 0 ||
  4125. IsEventSet(*pBreakEvent);
  4127. VERIFY( pBreakEvent->ResetEvent() );
  4129. CXTPSyntaxEditTextRegion zoneValid = ptrTextSch->GetUpdatedTextRegion();
  4131. if ((nParseRes&xtpEditLPR_RunFinished) && nZonesCount)
  4132. {
  4133. pPRMs->arInvalidZones.RemoveAt(nZonesCount-1);
  4134. nZonesCount--;  //pPRMs->UpdateZones(zoneValid);
  4135. }
  4137. //DEBUG
  4138. {
  4139. CString sDBGzone = DBG_TraceIZone(&zoneValid.m_posStart, &zoneValid.m_posEnd);
  4140. //TRACE(_T("- Parser set START Event. Add invalid Zone [ %s ] n"), sDBGpos);
  4141. DBG_TRACE_PARSE_START_STOP(_T("* Parser Ended. (result=%x) %s%s%s (%.3f sec) VALID Zone[ %s ] n"),
  4142. nParseRes,
  4143. (nParseRes&xtpEditLPR_RunBreaked) ? _T(" BREAKED ") : _T(""),
  4144. (nParseRes&xtpEditLPR_Error) ? _T(" ERROR ") : _T(""),
  4145. (nParseRes&xtpEditLPR_RunFinished) ? _T(" <F I N I S H E D> ") : _T(""),
  4146. labs(dwTime1-dwTime0)/1000.0, (LPCTSTR)sDBGzone);
  4147. }
  4148. }
  4149. while ((bParseRestedBlock || nZonesCount) && !bBreaked);
  4150. }
  4151. }
  4152. while (dwWaitRes != WAIT_OBJECT_0+1);
  4153. }
  4154. //  catch(...) {
  4155. //      TRACE(_T("* EXCEPTION!!! CXTPSyntaxEditLexParser::ThreadParseProc(2)n"));
  4156. //      return 333;
  4157. //  }
  4159. DBG_TRACE_PARSE_START_STOP(_T("*** Parser Thread is Ended. (%x)n"), ::GetCurrentThreadId());
  4160. return 0;
  4161. }
  4163. #ifdef _DEBUG
  4164. void CXTPSyntaxEditLexTextBlock::Dump( CDumpContext& dc ) const
  4165. {
  4167. CObject::Dump( dc );
  4169. // Now do the stuff for our specific class.
  4170. dc << "t <<TB>>";
  4171. dc << " (ref=" << m_dwRef << ") n";
  4172. dc << "t start(" << m_PosStartLC.nLine << ", " << m_PosStartLC.nCol << ") ";
  4173. dc << "t end(" << m_PosEndLC.nLine << ", " << m_PosEndLC.nCol << ") n";
  4175. #if _MSC_VER >= 1300
  4176. dc << "t Parent="; dc.DumpAsHex((INT_PTR)(CXTPSyntaxEditLexTextBlock*)m_ptrParent);
  4177. dc << ", Prev=";    dc.DumpAsHex((INT_PTR)(CXTPSyntaxEditLexTextBlock*)m_ptrPrev);
  4178. dc << ", Next=";    dc.DumpAsHex((INT_PTR)(CXTPSyntaxEditLexTextBlock*)m_ptrNext);
  4179. dc << ", LastChild=";   dc.DumpAsHex((INT_PTR)(CXTPSyntaxEditLexTextBlock*)m_ptrLastChild);
  4180. #endif
  4182. }
  4183. #endif
  4185. BOOL CXTPSyntaxEditLexTextSchema::RunParseOnScreen(CTextIter* pTxtIter,
  4186. int nRowStart, int nRowEnd,
  4187. CXTPSyntaxEditLexTextBlockPtr& rPtrScreenSchFirstTB
  4188. )
  4189. {
  4190. if (!pTxtIter || nRowStart <= 0 || nRowEnd <= 0)
  4191. {
  4192. ASSERT(FALSE);
  4193. return FALSE;
  4194. }
  4196. CSingleLock singleLock(GetDataLoker());
  4198. if (!singleLock.Lock(30))
  4199. {
  4200. TRACE(_T("Cannot enter critical section. CXTPSyntaxEditLexTextSchema::RunParseOnScreen() n"));
  4201. return FALSE;
  4202. }
  4203. //---------------------------------------------------------------------------
  4204. //** (1) ** -------------------------
  4205. CXTPSyntaxEditLexTextBlockPtr ptrTBParentToRun;
  4206. BOOL bInit = InitScreenSch(pTxtIter, nRowStart, nRowEnd, rPtrScreenSchFirstTB,
  4207. ptrTBParentToRun);
  4209. if (!bInit)
  4210. {
  4211. //TRACE(_T("- parser::InitScreenSch return FALSE res.n"));
  4212. return FALSE;
  4213. }
  4215. XTP_EDIT_LINECOL startLC = {nRowStart, 0};
  4216. if (!pTxtIter->SeekPos(startLC))
  4217. {
  4218. return FALSE;
  4219. }
  4221. int nParseRes = 0;
  4223. CXTPSyntaxEditLexOnScreenParseCnt runCnt;
  4224. runCnt.m_nRowStart  = nRowStart;
  4225. runCnt.m_nRowEnd    = nRowEnd;
  4226. runCnt.m_ptrTBLast  = ptrTBParentToRun;
  4228. //** (2) ** -------------------------
  4229. CXTPSyntaxEditLexClassPtrArray* ptrArClasses = m_pClassSchema->GetClasses(FALSE);
  4230. int nCCount = ptrArClasses ? (int)ptrArClasses->GetSize() : 0;
  4231. BOOL bRunEOF = TRUE;
  4232. XTP_EDIT_LINECOL lcTextPos = {0,0};
  4234. while (!pTxtIter->IsEOF() && nCCount && bRunEOF)
  4235. {
  4236. bRunEOF = !pTxtIter->IsEOF();
  4238. nParseRes = Run_OnScreenTBStack(pTxtIter, ptrTBParentToRun, &runCnt);
  4240. if (nParseRes & (xtpEditLPR_Error|xtpEditLPR_RunBreaked)) // |xtpEditLPR_RunFinished))
  4241. {
  4242. TRACE(_T("- parser::RunParseOnScreen return by erroe or BREAK. n"));
  4243. return !(nParseRes&xtpEditLPR_Error);
  4244. }
  4246. //** -------------------------------------------------------------
  4247. if (!pTxtIter->IsEOF() && !(nParseRes & xtpEditLPR_Iterated))
  4248. {
  4249. SeekNextEx(pTxtIter, ptrTBParentToRun->m_ptrLexClass, &runCnt);
  4250. }
  4252. //---------------------------------------------------------------------------
  4253. lcTextPos = pTxtIter->GetPosLC();
  4254. if (lcTextPos.nLine > runCnt.m_nRowEnd)
  4255. {
  4256. break;
  4257. }
  4259. //---------------------------------------------------------------------------
  4260. if (ptrTBParentToRun->m_ptrParent)
  4261. {
  4262. ptrTBParentToRun = ptrTBParentToRun->m_ptrParent;
  4263. }
  4264. }
  4265. return TRUE;
  4266. }
  4268. CXTPSyntaxEditLexTextBlockPtr CXTPSyntaxEditLexTextSchema::InitScreenSch_RunTopClass(CTextIter* pTxtIter)
  4269. {
  4270. CXTPSyntaxEditLexTextBlockPtr ptrTBtop;
  4272. CXTPSyntaxEditLexClassPtrArray* ptrClsAr = m_pClassSchema->GetClasses(FALSE);
  4273. int nCount = ptrClsAr ? (int)ptrClsAr->GetSize() : 0;
  4274. for (int i = 0; i < nCount; i++)
  4275. {
  4276. CXTPSyntaxEditLexClassPtr ptrC = ptrClsAr->GetAt(i);
  4277. if (!ptrC)
  4278. {
  4279. ASSERT(FALSE);
  4280. continue;
  4281. }
  4283. ASSERT(ptrTBtop == NULL);
  4284. int nParseRes = ptrC->RunParse(pTxtIter, this, ptrTBtop);
  4286. if ((nParseRes & xtpEditLPR_StartFound) && ptrTBtop)
  4287. {
  4288. return ptrTBtop;
  4289. }
  4290. }
  4292. return NULL;
  4293. }
  4295. BOOL CXTPSyntaxEditLexTextSchema::InitScreenSch(CTextIter* pTxtIter, int nRowStart, int nRowEnd,
  4296.  CXTPSyntaxEditLexTextBlockPtr& rPtrScreenSchFirstTB,
  4297. CXTPSyntaxEditLexTextBlockPtr& rPtrTBParentToRun)
  4298. {
  4299. CXTPSyntaxEditLexTextBlockPtr ptrTBstart = GetBlocks();
  4301. // process first screen parse in the main thread
  4302. if (nRowStart == 1 && !ptrTBstart)
  4303. {
  4304. rPtrTBParentToRun = rPtrScreenSchFirstTB = InitScreenSch_RunTopClass(pTxtIter);
  4305. return (rPtrTBParentToRun != NULL);
  4306. }
  4308. CXTPSyntaxEditLexTextBlock* pLastSchBlock = GetLastSchBlock(FALSE);
  4309. if (m_ptrNewChainTB2 && pLastSchBlock &&
  4310. (pLastSchBlock->m_PosEndLC.IsValidData() && nRowStart > pLastSchBlock->m_PosEndLC.nLine ||
  4311. !pLastSchBlock->m_PosEndLC.IsValidData() && nRowStart > pLastSchBlock->m_PosStartLC.nLine)
  4312.   )
  4313. {
  4314. return FALSE;
  4315. }
  4317. //=======================================================================
  4318. CXTPSyntaxEditLexTextBlock* pTBLast = NULL;
  4320. XTP_EDIT_LINECOL lcStart = {nRowStart, 0};
  4321. // (1) ---
  4322. CXTPSyntaxEditLexTextBlock* pTB;
  4323. for (pTB = ptrTBstart; pTB; pTB = pTB->m_ptrNext)
  4324. {
  4325. if (pTB->m_PosStartLC < lcStart &&
  4326. pTB->GetPosEndLC() >= lcStart ||
  4327. pTB == ptrTBstart )
  4328. {
  4329. pTBLast = pTB;
  4330. }
  4331. if (pTB->m_PosStartLC.nLine > nRowEnd)
  4332. {
  4333. break;
  4334. }
  4335. }
  4337. // (2) ---
  4338. CXTPSyntaxEditLexTextBlockPtr ptrTBCopyNext;
  4339. for (pTB = pTBLast; pTB; pTB = pTB->m_ptrParent)
  4340. {
  4341. CXTPSyntaxEditLexTextBlockPtr ptrTBCopy = CopyShortTBtoFull(pTB);
  4342. if (!ptrTBCopy)
  4343. {
  4344. return FALSE;
  4345. }
  4347. if (pTB == pTBLast)
  4348. {
  4349. rPtrTBParentToRun = ptrTBCopy;
  4351. if (pTB->m_PosStartLC.nLine <= nRowStart &&
  4352. pTB->m_PosEndLC.nLine >= nRowStart ||
  4353. pTB == ptrTBstart)
  4354. {
  4355. pTBLast = pTB;
  4356. }
  4357. }
  4358. else
  4359. {
  4360. ptrTBCopy->m_ptrNext = ptrTBCopyNext;
  4361. ptrTBCopyNext->m_ptrPrev = ptrTBCopy;
  4363. ptrTBCopyNext->m_ptrParent = ptrTBCopy;
  4364. }
  4366. rPtrScreenSchFirstTB = ptrTBCopy;
  4368. ptrTBCopyNext = ptrTBCopy;
  4369. }
  4371. return (rPtrTBParentToRun != NULL);
  4372. }
  4374. CXTPSyntaxEditLexTextBlock* CXTPSyntaxEditLexTextSchema::CopyShortTBtoFull(CXTPSyntaxEditLexTextBlock* pTB)
  4375. {
  4376. CXTPSyntaxEditLexTextBlockPtr ptrCopyTB = GetNewBlock();
  4378. if (!ptrCopyTB || !pTB || !pTB->m_ptrLexClass)
  4379. {
  4380. ASSERT(pTB && pTB->m_ptrLexClass);
  4381. return NULL;
  4382. }
  4383. ptrCopyTB->m_PosStartLC = pTB->m_PosStartLC;
  4384. ptrCopyTB->m_PosEndLC = pTB->m_PosEndLC;
  4386. int nClassID = pTB->m_ptrLexClass->GetAttribute_int(XTPLEX_ATTRCLASSID, FALSE, -1);
  4387. ASSERT(nClassID > 0);
  4389. CXTPSyntaxEditLexClassPtrArray* ptrTopClassesAr = m_pClassSchema->GetClasses(FALSE);
  4390. ptrCopyTB->m_ptrLexClass = FindLexClassByID(ptrTopClassesAr, nClassID);
  4392. if (!ptrCopyTB->m_ptrLexClass)
  4393. {
  4394. ASSERT(FALSE);
  4395. return NULL;
  4396. }
  4398. return ptrCopyTB.Detach();
  4399. }
  4401. CXTPSyntaxEditLexClass* CXTPSyntaxEditLexTextSchema::FindLexClassByID(CXTPSyntaxEditLexClassPtrArray* pClassesAr, int nClassID)
  4402. {
  4403. if (!pClassesAr)
  4404. {
  4405. return NULL;
  4406. }
  4407. int nCount = (int)pClassesAr->GetSize();
  4408. for (int i = 0; i < nCount; i++)
  4409. {
  4410. CXTPSyntaxEditLexClass* pC = pClassesAr->GetAt(i, FALSE);
  4412. int nC_ID = pC->GetAttribute_int(XTPLEX_ATTRCLASSID, FALSE);
  4414. if (nC_ID == nClassID)
  4415. {
  4416. pC->InternalAddRef();
  4417. return pC;
  4418. }
  4420. //-------------------------------------------------------
  4421. CXTPSyntaxEditLexClass* pCF2 = FindLexClassByID(pC->GetChildren(), nClassID);
  4422. if (pCF2)
  4423. {
  4424. return pCF2;
  4425. }
  4426. pCF2 = FindLexClassByID(pC->GetChildrenDyn(), nClassID);
  4427. if (pCF2)
  4428. {
  4429. return pCF2;
  4430. }
  4431. }
  4432. return NULL;
  4433. }
  4435. int CXTPSyntaxEditLexTextSchema::Run_OnScreenTBStack(CTextIter* pTxtIter,
  4436. CXTPSyntaxEditLexTextBlock* pTBParentToRun,
  4437. CXTPSyntaxEditLexOnScreenParseCnt* pRunCnt)
  4438. {
  4439. if (!pTBParentToRun || !pTBParentToRun->m_ptrLexClass || !pRunCnt)
  4440. {
  4441. ASSERT(FALSE);
  4442. return xtpEditLPR_Error;
  4443. }
  4445. CXTPSyntaxEditLexTextBlockPtr ptrTBParentToRun(pTBParentToRun, TRUE);
  4446. CXTPSyntaxEditLexClassPtr ptrRunClass = pTBParentToRun->m_ptrLexClass;
  4447. int nPres = 0;
  4448. BOOL bIterated = FALSE;
  4450. BOOL bEnded = FALSE;
  4451. BOOL bRunEOF = TRUE;
  4452. XTP_EDIT_LINECOL lcTextPos = {0,0};
  4454. //** 1 **// Run existing block with children until block end
  4455. while (!bEnded && (bRunEOF || !pTxtIter->IsEOF()) )
  4456. {
  4457. bRunEOF = !pTxtIter->IsEOF();
  4459. BOOL bSkipIterate = FALSE;
  4461. nPres = ptrRunClass->RunParse(pTxtIter, this, ptrTBParentToRun, pRunCnt);
  4463. if (nPres & (xtpEditLPR_Error|xtpEditLPR_RunBreaked)) //|xtpEditLPR_RunFinished))
  4464. {
  4465. return nPres;
  4466. }
  4468. //---------------------------------------------------------------------------
  4469. if (nPres & xtpEditLPR_Iterated)
  4470. {
  4471. bSkipIterate = TRUE;
  4472. bIterated = TRUE;
  4473. }
  4475. //---------------------------------------------------------------------------
  4476. bEnded = (nPres & xtpEditLPR_EndFound) != 0;
  4478. if (bEnded)
  4479. {
  4480. CSingleLock singleLock(GetDataLoker(), TRUE);
  4482. ptrTBParentToRun->EndChildren(); //this);
  4484. DBG_TRACE_PARSE_RUN_BLOCKS(_T("(%08x) ENDED startPos=(%d,%d) endPos=(%d,%d), [%s] {%d}-noEndedStack n"),
  4485. (CXTPSyntaxEditLexTextBlock*)ptrTBParentToRun,
  4486. ptrTBParentToRun->m_PosStartLC.nLine, ptrTBParentToRun->m_PosStartLC.nCol, ptrTBParentToRun->m_PosEndLC.nLine,
  4487. ptrTBParentToRun->m_PosEndLC.nCol, ptrTBParentToRun->m_ptrLexClass->m_strClassName, m_nNoEndedClassesCount);
  4488. }
  4490. //---------------------------------------------------------------------------
  4491. if (!bEnded && !bSkipIterate)
  4492. {
  4493. SeekNextEx(pTxtIter, ptrRunClass, pRunCnt);
  4494. }
  4496. //---------------------------------------------------------------------------
  4497. lcTextPos = pTxtIter->GetPosLC();
  4498. if (lcTextPos.nLine > pRunCnt->m_nRowEnd)
  4499. {
  4500. break;
  4501. }
  4502. }
  4504. // ** end run existing ** //
  4505. if (!bEnded)
  4506. {
  4507. ptrTBParentToRun->m_PosEndLC = pTxtIter->GetPosLC();
  4509. ptrTBParentToRun->EndChildren(); //this);
  4510. return xtpEditLPR_RunFinished;
  4511. }
  4513. //===========================================================================
  4514. return (bIterated ? xtpEditLPR_Iterated : 0) | (pTxtIter->IsEOF() ? xtpEditLPR_RunFinished : 0);
  4515. }
  4517. CXTPSyntaxEditLexParserSchemaOptions::CXTPSyntaxEditLexParserSchemaOptions()
  4518. {
  4519. m_bFirstParseInSeparateThread           = TRUE;
  4520. m_bEditReparceInSeparateThread          = TRUE;
  4521. m_bConfigChangedReparceInSeparateThread = TRUE;
  4522. m_dwMaxBackParseOffset                  = XTP_EDIT_LEXPARSER_MAXBACKOFFSETDEFAULT;
  4523. m_dwEditReparceTimeout_ms               = XTP_EDIT_LEXPARSER_REPARSETIMEOUTMS;
  4524. m_dwOnScreenSchCacheLifeTime_sec        = XTP_EDIT_LEXPARSER_ONSCREENSCHCACHELIFETIMESEC;
  4525. m_dwParserThreadIdleLifeTime_ms         = XTP_EDIT_LEXPARSER_THREADIDLELIFETIMESEC * 1000;
  4526. }
  4528. CXTPSyntaxEditLexParserSchemaOptions::CXTPSyntaxEditLexParserSchemaOptions(const CXTPSyntaxEditLexParserSchemaOptions& rSrc)
  4529. {
  4530. m_bFirstParseInSeparateThread           = rSrc.m_bFirstParseInSeparateThread;
  4531. m_bEditReparceInSeparateThread          = rSrc.m_bEditReparceInSeparateThread;
  4532. m_bConfigChangedReparceInSeparateThread = rSrc.m_bConfigChangedReparceInSeparateThread;
  4533. m_dwMaxBackParseOffset                  = rSrc.m_dwMaxBackParseOffset;
  4534. m_dwEditReparceTimeout_ms               = rSrc.m_dwEditReparceTimeout_ms;
  4535. m_dwOnScreenSchCacheLifeTime_sec        = rSrc.m_dwOnScreenSchCacheLifeTime_sec;
  4536. m_dwParserThreadIdleLifeTime_ms         = rSrc.m_dwParserThreadIdleLifeTime_ms;
  4537. }
  4539. const CXTPSyntaxEditLexParserSchemaOptions& CXTPSyntaxEditLexParserSchemaOptions::operator=(const CXTPSyntaxEditLexParserSchemaOptions& rSrc)
  4540. {
  4541. m_bFirstParseInSeparateThread           = rSrc.m_bFirstParseInSeparateThread;
  4542. m_bEditReparceInSeparateThread          = rSrc.m_bEditReparceInSeparateThread;
  4543. m_bConfigChangedReparceInSeparateThread = rSrc.m_bConfigChangedReparceInSeparateThread;
  4544. m_dwMaxBackParseOffset                  = rSrc.m_dwMaxBackParseOffset;
  4545. m_dwEditReparceTimeout_ms               = rSrc.m_dwEditReparceTimeout_ms;
  4546. m_dwOnScreenSchCacheLifeTime_sec        = rSrc.m_dwOnScreenSchCacheLifeTime_sec;
  4547. m_dwParserThreadIdleLifeTime_ms         = rSrc.m_dwParserThreadIdleLifeTime_ms;
  4549. return *this;
  4550. }
  4552. BOOL CXTPSyntaxEditLexParser::ReadSchemaOptions(const CString& strExt,
  4553.   CXTPSyntaxEditLexTextSchema* pTextSchema,
  4554.   CXTPSyntaxEditLexParserSchemaOptions* pOpt)
  4555. {
  4556. if (pOpt)
  4557. {
  4558. *pOpt = *m_pSchOptions_default;
  4559. }
  4561. if (!pTextSchema || !pOpt)
  4562. {
  4563. ASSERT(FALSE);
  4564. return FALSE;
  4565. }
  4567. CXTPSyntaxEditLexClassPtr ptrTopCls = pTextSchema->GetTopClassForFileExt(strExt);
  4568. if (!ptrTopCls)
  4569. {
  4570. return FALSE;
  4571. }
  4573. pOpt->m_bFirstParseInSeparateThread = ptrTopCls->GetAttribute_BOOL(
  4574. XTPLEX_ATTRG_FIRSTPARSEINSEPARATETHREAD, FALSE, TRUE);
  4576. pOpt->m_bEditReparceInSeparateThread = ptrTopCls->GetAttribute_BOOL(
  4577. XTPLEX_ATTRG_EDITREPARCEINSEPARATETHREAD, FALSE, TRUE);
  4579. pOpt->m_bConfigChangedReparceInSeparateThread = ptrTopCls->GetAttribute_BOOL(
  4580. XTPLEX_ATTRG_CONFIGCHANGEDREPARCEINSEPARATETHREAD, FALSE, TRUE);
  4582. pOpt->m_dwMaxBackParseOffset = (DWORD)ptrTopCls->GetAttribute_int(
  4583. XTPLEX_ATTRG_MAXBACKPARSEOFFSET, FALSE,
  4584. XTP_EDIT_LEXPARSER_MAXBACKOFFSETDEFAULT);
  4586. pOpt->m_dwEditReparceTimeout_ms = (DWORD)ptrTopCls->GetAttribute_int(
  4587. XTPLEX_ATTRG_EDITREPARCETIMEOUT_MS, FALSE,
  4588. XTP_EDIT_LEXPARSER_REPARSETIMEOUTMS);
  4590. pOpt->m_dwOnScreenSchCacheLifeTime_sec = (DWORD)ptrTopCls->GetAttribute_int(
  4591. XTPLEX_ATTRG_ONSCREENSCHCACHELIFETIME_SEC, FALSE,
  4592. XTP_EDIT_LEXPARSER_ONSCREENSCHCACHELIFETIMESEC);
  4594. pOpt->m_dwParserThreadIdleLifeTime_ms = (DWORD)ptrTopCls->GetAttribute_int(
  4595. XTPLEX_ATTRG_PARSERTHREADIDLELIFETIME_SEC, FALSE,
  4596. XTP_EDIT_LEXPARSER_THREADIDLELIFETIMESEC);
  4598. if (pOpt->m_dwParserThreadIdleLifeTime_ms != INFINITE)
  4599. {
  4600. pOpt->m_dwParserThreadIdleLifeTime_ms *= 1000;
  4601. }
  4602. if (pOpt->m_dwParserThreadIdleLifeTime_ms == 0)
  4603. {
  4604. pOpt->m_dwParserThreadIdleLifeTime_ms = INFINITE;
  4605. }
  4607. return TRUE;
  4608. }
  4610. const CXTPSyntaxEditLexParserSchemaOptions* CXTPSyntaxEditLexParser::GetSchemaOptions(const CString& strExt)
  4611. {
  4612. CSingleLock singLockMain(&m_csParserData);
  4614. if (!m_ptrTextSchema)
  4615. {
  4616. RemoveAllOptions();
  4617. }
  4619. CXTPSyntaxEditLexParserSchemaOptions* pOptions = NULL;
  4621. if (m_mapSchOptions.Lookup(strExt, pOptions))
  4622. {
  4623. ASSERT(pOptions);
  4624. return pOptions;
  4625. }
  4626. else if (m_ptrTextSchema)
  4627. {
  4628. pOptions = new CXTPSyntaxEditLexParserSchemaOptions();
  4630. if (ReadSchemaOptions(strExt, m_ptrTextSchema, pOptions))
  4631. {
  4632. m_mapSchOptions.SetAt(strExt, pOptions);
  4633. return pOptions;
  4634. }
  4635. else
  4636. {
  4637. CMDTARGET_RELEASE(pOptions);
  4638. }
  4639. }
  4641. return m_pSchOptions_default;
  4642. }