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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditTextIterator.cpp：源码内容
  1. // XTPSyntaxEditTextIterator.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. //
  20. //////////////////////////////////////////////////////////////////////
  22. #include "stdafx.h"
  24. // common includes
  25. #include "Common/XTPNotifyConnection.h"
  26. #include "Common/XTPSmartPtrInternalT.h"
  27. #include "Common/XTPVC80Helpers.h"
  29. // syntax editor includes
  30. #include "XTPSyntaxEditDefines.h"
  31. #include "XTPSyntaxEditStruct.h"
  32. #include "XTPSyntaxEditLexPtrs.h"
  33. #include "XTPSyntaxEditLexClassSubObjT.h"
  34. #include "XTPSyntaxEditTextIterator.h"
  35. #include "XTPSyntaxEditSectionManager.h"
  36. #include "XTPSyntaxEditLexCfgFileReader.h"
  37. #include "XTPSyntaxEditLexClassSubObjDef.h"
  38. #include "XTPSyntaxEditLexClass.h"
  39. #include "XTPSyntaxEditLexParser.h"
  40. #include "XTPSyntaxEditBufferManager.h"
  41. #include "XTPSyntaxEditTextIterator.h"
  43. #define XTP_EDIT_LEX_TEXT_BUF_SIZE 512
  44. #define XTP_EDIT_LEX_TEXT_BUF_START_GAP 10
  46. #ifdef _UNICODE
  47. #define CHAR_W 1
  48. #else
  49. #define CHAR_W 2
  50. #endif
  52. //---------------------------------------------------------------------------
  53. #define CHR_TO_B(nChr) ( (int)((nChr)*sizeof(TCHAR)) )
  55. ////////////////////////////////////////////////////////////////////////////
  56. AFX_INLINE int xtpEdit_StrLenInBytes(LPCTSTR pcszStr, int nChars)
  57. {
  58. #ifdef _UNICODE
  59. return (int)_tcsnbcnt(pcszStr, nChars) * sizeof(TCHAR);
  60. #else
  61. return (int)_tcsnbcnt(pcszStr, nChars);
  62. #endif
  63. }
  65. AFX_INLINE int xtpEdit_StrCharsToBytes(LPCTSTR pcszStr, int nChars)
  66. {
  67. #ifdef _UNICODE
  68. UNREFERENCED_PARAMETER(pcszStr);
  69. return nChars * sizeof(TCHAR);
  70. #else
  71. LPCTSTR p2;
  72. if (nChars == 1)
  73. {
  74. p2 = _tcsinc(pcszStr);
  75. }
  76. else
  77. {
  78. p2 = _tcsninc(pcszStr, nChars);
  79. }
  80. int nB = int(p2 - pcszStr);
  81. return nB;
  83. //return _tcsnbcnt(pcszStr, nChars);
  84. #endif
  85. }
  86. ////////////////////////////////////////////////////////////////////////////
  88. static const TCHAR szEOL[] = _T("x0Dx0A");
  90. ////////////////////////////////////////////////////////////////////////////
  91. //class CXTPSyntaxEditTextIterator
  92. namespace XTPSyntaxEditLexAnalyser
  93. {
  94. BOOL IsEventSet(HANDLE hEvent);
  95. }
  97. CXTPSyntaxEditTextIterator::CXTPSyntaxEditTextIterator(CXTPSyntaxEditBufferManager* pData)
  98. {
  99. m_pData = pData;
  100. if (!m_pData)
  101. return;
  103. m_pData->InternalAddRef();
  105. int nMaxBackOffset_sch = (int)m_pData->GetLexParser()->GetSchemaOptions(
  106. m_pData->GetFileExt())->m_dwMaxBackParseOffset;
  108. // WARNING! - value should be in reasonable range
  109. ASSERT(nMaxBackOffset_sch >= 10 && nMaxBackOffset_sch <= 10*1000);
  111. m_nBufOffsetB_normal = max(nMaxBackOffset_sch, 20);
  112. m_nBufOffsetB_max = XTP_EDIT_LEX_TEXT_BUF_SIZE;
  113. m_nBufOffsetB = 0;
  115. SeekBegin();
  116. }
  118. CXTPSyntaxEditTextIterator::~CXTPSyntaxEditTextIterator()
  119. {
  120. if (m_pData)
  121. {
  122. m_pData->InternalRelease();
  123. }
  124. }
  126. CString CXTPSyntaxEditTextIterator::GetEOL() // "rn", "nr", "r"
  127. {
  128. if (!m_pData)
  129. {
  130. ASSERT(FALSE);
  131. return szEOL;
  132. }
  133. CString strEOL = m_pData->GetCurCRLF();
  134. return strEOL;
  135. }
  137. void CXTPSyntaxEditTextIterator::SeekBegin()
  138. {
  139. m_LCpos.nLine = 1;
  140. m_LCpos.nCol = 0;
  142. m_mapLine2Len.RemoveAll();
  144. int nEndRow = m_pData->GetRowCount();
  145. int nHSize = max(nEndRow/10, 500);
  146. m_mapLine2Len.InitHashTable(nHSize, FALSE);
  148. m_nNextLine = 1;
  149. m_nBufSizeB = 0;
  151. m_nTmpOffsetC = 0;
  152. m_nTmpOffsetB = 0;
  154. m_nBufOffsetB = XTP_EDIT_LEX_TEXT_BUF_START_GAP;
  156. if (m_arBuffer.GetSize() < max(m_nBufOffsetB_normal, 500))
  157. {
  158. m_arBuffer.SetSize(max(m_nBufOffsetB_normal, 500));
  159. }
  160. memset(m_arBuffer.GetData(), 0, m_arBuffer.GetSize());
  162. TCHAR* pData = GetBuffer(m_nBufOffsetB);
  164. STRCPY_S(pData, _tcslen(szEOL) + 1, szEOL);
  165. m_nBufOffsetB += CHR_TO_B(2);
  167. //---
  168. int nLen = GetLineLen(m_nNextLine, TRUE);
  169. m_bEOF = nLen == 0;
  170. }
  172. BOOL CXTPSyntaxEditTextIterator::SeekPos(const XTP_EDIT_LINECOL& posLC, HANDLE hBreakEvent)
  173. {
  174. SeekBegin();
  176. if (m_bEOF)
  177. {
  178. return FALSE;
  179. }
  181. int nSumLenB = 0;
  182. int nLnStart = posLC.nLine;
  184. while (nSumLenB < m_nBufOffsetB_normal && nLnStart > 1)
  185. {
  186. nSumLenB += GetLineLenBytes(nLnStart, TRUE);
  187. nLnStart--;
  189. if (hBreakEvent && XTPSyntaxEditLexAnalyser::IsEventSet(hBreakEvent))
  190. {
  191. return FALSE;
  192. }
  193. }
  194. m_nNextLine = nLnStart;
  195. GetText();
  197. m_LCpos.nLine = nLnStart;
  198. m_LCpos.nCol = 0;
  200. while (m_LCpos < posLC && !m_bEOF)
  201. {
  202. int nSeek = 1;
  203. if (m_LCpos.nLine < posLC.nLine)
  204. {
  205. nSeek = 0;
  206. if (!m_mapLine2Len.Lookup(m_LCpos.nLine, nSeek) || !nSeek)
  207. {
  208. ASSERT(nSeek || !nSeek && m_LCpos.nLine >= m_pData->GetRowCount());
  209. nSeek = 1;
  210. }
  211. }
  212. else
  213. {
  214. ASSERT(m_LCpos.nLine == posLC.nLine);
  215. nSeek = posLC.nCol - m_LCpos.nCol;
  216. ASSERT(nSeek >=0);
  217. }
  219. if (nSeek <= 0)
  220. {
  221. ASSERT(FALSE);
  222. break;
  223. }
  225. SeekNext(nSeek);
  227. if (hBreakEvent && XTPSyntaxEditLexAnalyser::IsEventSet(hBreakEvent))
  228. {
  229. return FALSE;
  230. }
  231. }
  233. BOOL bRes = (m_LCpos == posLC);
  234. return bRes;
  235. }
  237. LPCTSTR CXTPSyntaxEditTextIterator::GetText(int nCharsBuf)  // don't remove line end chars
  238. {
  239. if (!m_pData)
  240. {
  241. ASSERT(FALSE);
  242. return NULL;
  243. }
  244. int nSizeB = (int)m_arBuffer.GetSize();
  246. const int cnReservB = (XTP_EDIT_LEX_TEXT_BUF_SIZE+100)*2;
  248. if (!m_nBufSizeB || (m_nBufSizeB < CHR_TO_B(nCharsBuf)) )
  249. {
  250. int nEndRow = m_pData->GetRowCount();
  252. while (m_nNextLine <= nEndRow && m_nBufSizeB < CHR_TO_B(nCharsBuf) )
  253. {
  254. CString strBuf;
  255. m_pData->GetLineText(m_nNextLine, strBuf, TRUE);
  257. int nLenC = (int)_tcsclen(strBuf);
  258. int nLenB = xtpEdit_StrLenInBytes(strBuf, nLenC);
  260. //---------------------------------------------------------------------------
  261. int nNeedSizeB = m_nBufOffsetB + m_nBufSizeB + nLenB +
  262.  max(256, nCharsBuf*2);
  264. if (nNeedSizeB > nSizeB)
  265. {
  266. m_arBuffer.SetSize(nNeedSizeB + cnReservB);
  267. nSizeB = (int)m_arBuffer.GetSize();
  268. }
  269. //---------------------------------------------------------------------------
  270. TCHAR* pBuf = GetBuffer(m_nBufOffsetB + m_nBufSizeB);
  272. ASSERT(*(pBuf-1) != _T(''));
  273. ASSERT(*pBuf == _T(''));
  274. *pBuf = _T('');
  276. STRCPY_S(pBuf, strBuf.GetLength() + 1, strBuf);
  278. ASSERT(nSizeB-m_nBufOffsetB-m_nBufSizeB > nLenB);
  280. m_nBufSizeB += nLenB;
  282. ASSERT(m_nBufSizeB < nSizeB);
  284. m_mapLine2Len[m_nNextLine] = nLenC;
  285. //TRACE(_T("TEXT-ITERATOR: line(%d) len = %d n"),m_nNextLine, nLenC);
  287. //--------------------------------
  288. if (m_nNextLine == nEndRow)
  289. {
  290. TCHAR* pBufEnd = GetBuffer(m_nBufOffsetB + m_nBufSizeB);
  291. STRCPY_S(pBufEnd, _tcslen(szEOL) + 1, szEOL);
  292. int nLenB2 = xtpEdit_StrLenInBytes(szEOL, 2);
  293. m_nBufSizeB += nLenB2;
  295. ASSERT(m_nBufSizeB < nSizeB);
  296. }
  298. m_nNextLine++;
  299. }
  300. }
  302. ASSERT(m_nBufSizeB < nSizeB);
  304. TCHAR* pText = GetBuffer(m_nBufOffsetB + m_nTmpOffsetB);
  306. return pText;
  307. }
  309. // Move cur pos and return pointer to the text begin;
  310. LPCTSTR CXTPSyntaxEditTextIterator::SeekNext(DWORD dwChars, int nCharsBuf)
  311. {
  312. int nBSize = (int)m_arBuffer.GetSize();
  313. ASSERT(m_nBufSizeB <= nBSize);
  315. if (m_nBufSizeB < CHR_TO_B(nCharsBuf + dwChars))
  316. {
  317. GetText(nCharsBuf + dwChars);
  318. }
  320. if (m_nBufSizeB < CHR_TO_B(dwChars) )
  321. {
  322. dwChars = m_nBufSizeB/sizeof(TCHAR);
  323. }
  325. if (m_nBufSizeB >= CHR_TO_B(dwChars) && m_nBufSizeB)
  326. {
  327. nBSize = (int)m_arBuffer.GetSize();
  328. ASSERT(nBSize > CHR_TO_B(dwChars) );
  330. TCHAR* pText = GetBuffer(m_nBufOffsetB);
  331. //int nStepB = xtpEdit_StrLenInBytes(pText, dwChars);
  332. int nStepB = xtpEdit_StrCharsToBytes(pText, dwChars);
  333. ASSERT(nStepB > 0);
  335. if (m_nBufOffsetB > m_nBufOffsetB_max)
  336. {
  337. int nStepRem = m_nBufOffsetB - m_nBufOffsetB_normal;
  338. ASSERT(nStepRem > 0);
  340. m_arBuffer.RemoveAt(0, nStepRem);
  341. m_nBufOffsetB -= nStepRem;
  342. }
  344. m_nBufOffsetB += nStepB;
  345. m_nBufSizeB -= nStepB;
  347. TCHAR* pBuf = GetBuffer(m_nBufOffsetB + m_nBufSizeB);
  348. ASSERT(*(pBuf-1) != _T(''));
  349. ASSERT(*pBuf == _T(''));
  351. m_bEOF = m_nBufSizeB <= 0;
  353. if (dwChars && !m_bEOF)
  354. {
  355. LCPosAdd(m_LCpos, dwChars);
  356. }
  358. SetTxtOffset(m_nTmpOffsetC);
  360. pText = GetBuffer(m_nBufOffsetB + m_nTmpOffsetB);
  362. return pText;
  363. }
  365. return NULL;
  366. }
  368. LPCTSTR CXTPSyntaxEditTextIterator::SeekPrev()
  369. {
  370. int nBSize = (int)m_arBuffer.GetSize();
  371. ASSERT(m_nBufSizeB <= nBSize);
  373. if (m_nBufOffsetB <= XTP_EDIT_LEX_TEXT_BUF_START_GAP)
  374. {
  375. XTP_EDIT_LINECOL lcPos = m_LCpos;
  376. //LCPosDec(lcPos);
  378. if (!SeekPos(lcPos))
  379. return NULL;
  380. }
  382. if (m_nBufOffsetB > 0 && m_nBufSizeB > 0 && m_LCpos > XTP_EDIT_LINECOL::Pos1)
  383. {
  384. TCHAR* pText0 = GetBuffer(0);
  385. TCHAR* pText1 = GetBuffer(m_nBufOffsetB);
  386. TCHAR* pText = pText1;
  388. pText = _tcsdec(pText0, pText);
  390. if (!pText)
  391. {
  392. m_nBufOffsetB = 0;
  393. m_bEOF = TRUE;
  394. return NULL;
  395. }
  397. int nStepB = int(pText1 - pText) * sizeof(TCHAR);
  399. m_nBufOffsetB -= nStepB;
  400. m_nBufSizeB += nStepB;
  402. LCPosDec(m_LCpos);
  404. //SetTxtOffset(m_nTmpOffsetC);
  405. //pText = GetBuffer(m_nBufOffsetB + m_nTmpOffsetB);
  407. return pText;
  408. }
  410. return NULL;
  411. }
  414. void CXTPSyntaxEditTextIterator::SetTxtOffset(int nOffsetChars)
  415. {
  416. m_nTmpOffsetC = nOffsetChars;
  417. m_nTmpOffsetB = 0;
  419. if (m_nTmpOffsetC)
  420. {
  421. TCHAR* pText = GetBuffer(m_nBufOffsetB);
  423. if (m_nTmpOffsetC < 0)
  424. {
  425. TCHAR* pText_min = GetBuffer(0);
  426. TCHAR* pText0 = pText;
  427. for (int i = 0; i < labs(nOffsetChars); i++)
  428. {
  429. if (pText0 <= pText_min)
  430. {
  431. break;
  432. }
  433. pText0 = _tcsdec(pText_min, pText0);
  434. }
  435. m_nTmpOffsetB = -1 * int( ((byte*)pText) - ((byte*)pText0) );
  436. }
  437. else
  438. {
  439. m_nTmpOffsetB = xtpEdit_StrLenInBytes(pText, m_nTmpOffsetC);
  440. }
  441. }
  442. }
  444. BOOL CXTPSyntaxEditTextIterator::IsEOF()
  445. {
  446. return m_bEOF;
  447. }
  449. XTP_EDIT_LINECOL CXTPSyntaxEditTextIterator::GetPosLC()
  450. {
  451. return m_LCpos;
  452. }
  454. XTP_EDIT_LINECOL CXTPSyntaxEditTextIterator::GetPosLC_last(BOOL bWithEOL)
  455. {
  456. int nEndRow = m_pData->GetRowCount();
  457. return XTP_EDIT_LINECOL::MakeLineCol(nEndRow, GetLineLen(nEndRow, bWithEOL));
  458. }
  460. void CXTPSyntaxEditTextIterator::LCPosAdd(XTP_EDIT_LINECOL& rLC, int nCharsAdd)
  461. {
  462. int nLineLen = 0;
  464. int nRestChars = nCharsAdd;
  465. while (nRestChars)
  466. {
  467. if (m_mapLine2Len.Lookup(rLC.nLine, nLineLen))
  468. {
  469. if (nLineLen == 0)
  470. {
  471. break;   // last empty line
  472. }
  473. ASSERT(nLineLen > 0);
  475. int nDiff = nLineLen - rLC.nCol;
  476. ASSERT(nDiff >= 0);
  478. if (nDiff <= nRestChars)
  479. {
  480. rLC.nLine++;
  481. rLC.nCol = 0;
  483. nRestChars -= nDiff;
  484. }
  485. else
  486. {
  487. rLC.nCol += nRestChars;
  488. nRestChars = 0;
  489. break;
  490. }
  491. }
  492. else
  493. {
  494. break; // no more lines
  495. }
  496. }
  497. }
  499. void CXTPSyntaxEditTextIterator::LCPosDec(XTP_EDIT_LINECOL& rLC)
  500. {
  501. rLC.nCol--;
  502. if (rLC.nCol < 0)
  503. {
  504. if (rLC.nLine <= 1)
  505. {
  506. ASSERT(FALSE);
  507. rLC.nCol = 0;
  508. }
  509. else
  510. {
  511. rLC.nLine--;
  512. int nLineLen = 0;
  513. if (m_mapLine2Len.Lookup(rLC.nLine, nLineLen))
  514. {
  515. ASSERT(nLineLen || rLC.nLine == m_pData->GetRowCount());
  516. nLineLen = max(1, nLineLen);
  518. rLC.nCol = nLineLen-1;
  519. }
  520. else
  521. {
  522. if (rLC.nLine >= 1)
  523. {
  524. nLineLen = m_pData->GetLineTextLengthC(rLC.nLine, TRUE);
  525. ASSERT(nLineLen || rLC.nLine == m_pData->GetRowCount());
  526. nLineLen = max(1, nLineLen);
  528. rLC.nCol = nLineLen-1;
  529. }
  530. else
  531. {
  532. ASSERT(FALSE);
  533. rLC.nLine++;
  534. rLC.nCol++;
  535. }
  536. }
  537. }
  538. }
  539. }
  541. int CXTPSyntaxEditTextIterator::GetLineLen(int nLine, BOOL bWithEOL)
  542. {
  543. if (!m_pData)
  544. {
  545. ASSERT(FALSE);
  546. return 0;
  547. }
  549. int nEndRow = m_pData->GetRowCount();
  550. if (nLine > 0 && nLine <= nEndRow)
  551. {
  552. CString strBuf;
  553. m_pData->GetLineText(nLine, strBuf, bWithEOL);
  555. int nLen = (int)_tcsclen(strBuf);
  556. return nLen;
  557. }
  558. return 0;
  559. }
  561. int CXTPSyntaxEditTextIterator::GetLineLenBytes(int nLine, BOOL bWithEOL)
  562. {
  563. if (!m_pData)
  564. {
  565. ASSERT(FALSE);
  566. return 0;
  567. }
  569. int nEndRow = m_pData->GetRowCount();
  570. if (nLine > 0 && nLine <= nEndRow)
  571. {
  572. CString strBuf;
  573. m_pData->GetLineText(nLine, strBuf, bWithEOL);
  575. int nLenB = xtpEdit_StrLenInBytes(strBuf, strBuf.GetLength());
  576. return nLenB;
  577. }
  578. return 0;
  579. }
  581. CString CXTPSyntaxEditTextIterator::GetFileExt()
  582. {
  583. if (!m_pData)
  584. {
  585. ASSERT(FALSE);
  586. return _T("");
  587. }
  589. CString strFN = m_pData->GetFileExt();
  590. return strFN;
  591. }