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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditLexCfgFileReader.cpp：源码内容
  1. // XTPSyntaxEditLexCfgFileReader.cpp: implementation of the CXTPSyntaxEditLexCfgFileReader class.
  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/XTPColorManager.h"
  25. #include "Common/XTPNotifyConnection.h"
  26. #include "Common/XTPSmartPtrInternalT.h"
  27. #include "Common/XTPResourceManager.h"
  28. #include "Common/XTPVC80Helpers.h"
  29. #include "Common/XTPVC50Helpers.h"
  31. // syntax editor includes
  32. #include "XTPSyntaxEditDefines.h"
  33. #include "XTPSyntaxEditStruct.h"
  34. #include "XTPSyntaxEditLexPtrs.h"
  35. #include "XTPSyntaxEditLexClassSubObjT.h"
  36. #include "XTPSyntaxEditTextIterator.h"
  37. #include "XTPSyntaxEditSectionManager.h"
  38. #include "XTPSyntaxEditLexCfgFileReader.h"
  39. #include "XTPSyntaxEditLexClassSubObjDef.h"
  40. #include "XTPSyntaxEditLexClass.h"
  41. #include "XTPSyntaxEditLexParser.h"
  42. #include "XTPSyntaxEditLexColorFileReader.h"
  43. #include "XTPSyntaxEditCtrl.h"
  45. #ifdef _DEBUG
  46. #define new DEBUG_NEW
  47. #undef THIS_FILE
  48. static char THIS_FILE[] = __FILE__;
  49. #endif
  51. #ifndef DBG_READ_TRACE
  52. #define DBG_READ_TRACE
  53. #endif
  55. namespace XTPSyntaxEditLexAnalyser
  56. {
  57. //===========================================================================
  58. // XTP_EDIT_LEXPROPINFO
  59. //===========================================================================
  60. XTP_EDIT_LEXPROPINFO::XTP_EDIT_LEXPROPINFO()
  61. {
  62. nLine           = 0;
  63. nOffset         = 0;
  64. nPropertyLen    = 0;
  65. }
  67. XTP_EDIT_LEXPROPINFO::XTP_EDIT_LEXPROPINFO(const XTP_EDIT_LEXPROPINFO& rSrc)
  68. {
  69. arPropName.RemoveAll();
  70. int i;
  71. for (i = 0; i < rSrc.arPropName.GetSize(); ++i) {
  72. arPropName.Add(rSrc.arPropName[i]);
  73. }
  75. arPropValue.RemoveAll();
  76. for (i = 0; i < rSrc.arPropValue.GetSize(); ++i) {
  77. arPropValue.Add(rSrc.arPropValue[i]);
  78. }
  80. nLine           = rSrc.nLine;
  81. nOffset         = rSrc.nOffset;
  82. nPropertyLen    = rSrc.nPropertyLen;
  83. }
  85. const XTP_EDIT_LEXPROPINFO& XTP_EDIT_LEXPROPINFO::operator = (const XTP_EDIT_LEXPROPINFO& rSrc)
  86. {
  87. arPropName.RemoveAll();
  88. int i;
  89. for (i = 0; i < rSrc.arPropName.GetSize(); ++i) {
  90. arPropName.Add(rSrc.arPropName[i]);
  91. }
  93. arPropValue.RemoveAll();
  94. for (i = 0; i < rSrc.arPropValue.GetSize(); ++i) {
  95. arPropValue.Add(rSrc.arPropValue[i]);
  96. }
  98. nLine           = rSrc.nLine;
  99. nOffset         = rSrc.nOffset;
  100. nPropertyLen    = rSrc.nPropertyLen;
  102. return *this;
  103. }
  105. //===========================================================================
  106. // CXTPSyntaxEditLexPropInfoArray
  107. //===========================================================================
  108. CXTPSyntaxEditLexPropInfoArray::CXTPSyntaxEditLexPropInfoArray()
  109. {
  111. }
  113. CXTPSyntaxEditLexPropInfoArray::CXTPSyntaxEditLexPropInfoArray(const CXTPSyntaxEditLexPropInfoArray& rSrc)
  114. {
  115. RemoveAll();
  117. for (int i = 0; i < rSrc.GetSize(); ++i)
  118. {
  119. XTP_EDIT_LEXPROPINFO info(rSrc[i]);
  120. Add(info);
  121. }
  122. }
  124. const CXTPSyntaxEditLexPropInfoArray& CXTPSyntaxEditLexPropInfoArray::operator = (const CXTPSyntaxEditLexPropInfoArray& rSrc)
  125. {
  126. RemoveAll();
  128. for (int i = 0; i < rSrc.GetSize(); ++i)
  129. {
  130. XTP_EDIT_LEXPROPINFO info(rSrc[i]);
  131. Add(info);
  132. }
  134. return *this;
  135. }
  137. //===========================================================================
  138. // XTP_EDIT_LEXCLASSINFO
  139. //===========================================================================
  140. XTP_EDIT_LEXCLASSINFO::XTP_EDIT_LEXCLASSINFO()
  141. {
  142. nEndLine    = 0;
  143. nStartLine  = 0;
  144. }
  146. XTP_EDIT_LEXCLASSINFO::XTP_EDIT_LEXCLASSINFO(const XTP_EDIT_LEXCLASSINFO& rSrc)
  147. {
  148. arPropertyDesc.RemoveAll();
  149. for (int i = 0; i < rSrc.arPropertyDesc.GetSize(); ++i)
  150. {
  151. XTP_EDIT_LEXPROPINFO info(rSrc.arPropertyDesc[i]);
  152. arPropertyDesc.Add(info);
  153. }
  155. nEndLine    = rSrc.nEndLine;
  156. nStartLine  = rSrc.nStartLine;
  157. csClassName = rSrc.csClassName;
  158. }
  160. const XTP_EDIT_LEXCLASSINFO& XTP_EDIT_LEXCLASSINFO::operator = (const XTP_EDIT_LEXCLASSINFO& rSrc)
  161. {
  162. arPropertyDesc.RemoveAll();
  163. for (int i = 0; i < rSrc.arPropertyDesc.GetSize(); ++i)
  164. {
  165. XTP_EDIT_LEXPROPINFO info(rSrc.arPropertyDesc[i]);
  166. arPropertyDesc.Add(info);
  167. }
  169. nEndLine    = rSrc.nEndLine;
  170. nStartLine  = rSrc.nStartLine;
  171. csClassName = rSrc.csClassName;
  173. return *this;
  174. }
  176. //===========================================================================
  177. // CXTPSyntaxEditLexClassInfoArray
  178. //===========================================================================
  179. CXTPSyntaxEditLexClassInfoArray::CXTPSyntaxEditLexClassInfoArray()
  180. {
  181. m_bModified = FALSE;
  182. }
  184. CXTPSyntaxEditLexClassInfoArray::CXTPSyntaxEditLexClassInfoArray(const CXTPSyntaxEditLexClassInfoArray& rSrc)
  185. {
  186. RemoveAll();
  187. m_bModified = rSrc.m_bModified;
  189. for (int i = 0; i < rSrc.GetSize(); ++i)
  190. {
  191. XTP_EDIT_LEXCLASSINFO info(rSrc[i]);
  192. Add(info);
  193. }
  194. }
  196. const CXTPSyntaxEditLexClassInfoArray& CXTPSyntaxEditLexClassInfoArray::operator = (const CXTPSyntaxEditLexClassInfoArray& rSrc)
  197. {
  198. RemoveAll();
  199. m_bModified = rSrc.m_bModified;
  201. for (int i = 0; i < rSrc.GetSize(); ++i)
  202. {
  203. XTP_EDIT_LEXCLASSINFO info(rSrc[i]);
  204. Add(info);
  205. }
  207. return *this;
  208. }
  210. extern CString MakeStr(const CStringArray& rArProps, LPCTSTR strSplitter);
  211. }
  213. //////////////////////////////////////////////////////////////////////
  214. // Construction/Destruction
  215. //////////////////////////////////////////////////////////////////////
  217. using namespace XTPSyntaxEditLexAnalyser;
  219. const CString cstrDelims(_T(" t,"));
  220. const CString cstrEOL(_T("rn"));
  221. const CString cstrHex(_T("0123456789ABCDEFGabcdefg"));
  223. AFX_STATIC BOOL AFX_CDECL AfxCompareTime(const FILETIME& ft1, const FILETIME& ft2, DWORD dwTimeDiff = 500)
  224. {
  225. ULARGE_INTEGER uFT1, uFT2;
  227. uFT1.LowPart = ft1.dwLowDateTime;
  228. uFT1.HighPart = ft1.dwHighDateTime;
  230. uFT2.LowPart = ft2.dwLowDateTime;
  231. uFT2.HighPart = ft2.dwHighDateTime;
  233. ULONGLONG ullDiff = uFT1.QuadPart > uFT2.QuadPart ? uFT1.QuadPart - uFT2.QuadPart : uFT2.QuadPart - uFT1.QuadPart;
  235. //ullDiff = the number of 100-nanosecond intervals since January 1, 1601.
  236. if (ullDiff <= (dwTimeDiff*1000*1000/100))
  237. {
  238. return TRUE;
  239. }
  240. return FALSE;
  241. }
  243. AFX_STATIC BOOL AFX_CDECL AfxOpenFile(CFile& file, LPCTSTR lpszFileName, UINT nOpenFlags)
  244. {
  245. if (nOpenFlags == CFile::modeRead)
  246. {
  247. if (!FILEEXISTS_S(lpszFileName))
  248. {
  249. return FALSE;
  250. }
  251. }
  253. CFileException e;
  254. if (!file.Open(lpszFileName, nOpenFlags, &e))
  255. {
  256. AfxThrowFileException(e.m_cause,e.m_lOsError, e.m_strFileName);
  257. }
  259. return TRUE;
  260. }
  262. AFX_STATIC CString AFX_CDECL AfxMakeStrES(const CStringArray& rArProps, LPCTSTR strSplitter)
  263. {
  264. CString strResult;
  265. int nCount = (int)rArProps.GetSize();
  266. for (int i = 0; i < nCount; i++)
  267. {
  268. CString csProp = XTPSyntaxEditLexConfig()->ESToStr(rArProps[i], TRUE);
  269. if (i)
  270. {
  271. strResult += strSplitter;
  272. }
  273. CString strI = csProp;
  274. strResult += strI;
  275. }
  276. return strResult;
  277. }
  279. ////////////////////////////////////////////////////////////////////////////
  281. CXTPSyntaxEditLexCfgFileReader& AFX_CDECL CXTPSyntaxEditLexCfgFileReader::Instance()
  282. {
  283. static CXTPSyntaxEditLexCfgFileReader instance;
  284. return instance;
  285. }
  287. CXTPSyntaxEditLexCfgFileReader::CXTPSyntaxEditLexCfgFileReader()
  288. {
  289. m_csDataBuffer = XTP_EDIT_LEXCLASS_EMPTYSTR;
  290. m_nCurrLine = 0;
  291. m_nCurrLine_pos = 0;
  292. m_nCurrPos = 0;
  293. m_nEOFPos = 0;
  294. m_strToken = XTP_EDIT_LEXCLASS_EMPTYSTR;
  295. m_nTokenType = xtpEditTokType_Unknown;
  296. m_bReadNames = TRUE;
  297. m_bES = FALSE;
  298. }
  300. CXTPSyntaxEditLexCfgFileReader::~CXTPSyntaxEditLexCfgFileReader()
  301. {
  302. CleanInfoMap(m_mapLexClassInfo);
  303. }
  305. void CXTPSyntaxEditLexCfgFileReader::CleanInfoMap(CMapStringToPtr& mapInfo)
  306. {
  307. for (POSITION pos = mapInfo.GetStartPosition(); pos;)
  308. {
  309. CString csFileName;
  310. CXTPSyntaxEditLexClassInfoArray* pInfoArray = NULL;
  311. mapInfo.GetNextAssoc(pos, csFileName, (void*&)pInfoArray);
  312. SAFE_DELETE(pInfoArray);
  313. }
  314. mapInfo.RemoveAll();
  315. }
  317. void CXTPSyntaxEditLexCfgFileReader::CopyInfoMap(CMapStringToPtr& mapInfo)
  318. {
  319. CleanInfoMap(mapInfo);
  321. for (POSITION pos = m_mapLexClassInfo.GetStartPosition(); pos;)
  322. {
  323. // get the source data.
  324. CString csFileName;
  325. CXTPSyntaxEditLexClassInfoArray* pSource = NULL;
  326. m_mapLexClassInfo.GetNextAssoc(pos, csFileName, (void*&)pSource);
  328. // instantiate a new data pointer.
  329. CXTPSyntaxEditLexClassInfoArray* pDest =
  330. new CXTPSyntaxEditLexClassInfoArray(*pSource);
  332. // set the data.
  333. mapInfo[csFileName] = pDest;
  334. }
  335. }
  337. void CXTPSyntaxEditLexCfgFileReader::ReadSource2(const CString& csFileName, CStringArray& arBuffer)
  338. {
  339. try
  340. {
  341. arBuffer.RemoveAll();
  343. CStdioFile file;
  344. if (AfxOpenFile(file, csFileName, CFile::modeRead))
  345. {
  346. arBuffer.Add(_T(""));
  348. CString csBuffer;
  349. while (file.ReadString(csBuffer))
  350. {
  351. int nLen = csBuffer.GetLength();
  352. if (nLen && csBuffer[nLen-1] == _T('r'))
  353. {
  354. DELETE_S(csBuffer, nLen-1);
  355. }
  356. arBuffer.Add(csBuffer);
  357. }
  358. }
  359. }
  360. catch(CFileException* expFile)
  361. {
  362. #ifdef _DEBUG
  363. ProcessFileException(expFile);
  364. #endif
  365. expFile->Delete();
  366. }
  367. }
  369. void CXTPSyntaxEditLexCfgFileReader::ReadSource(const CString& csFileName, BOOL bSaveInfo)
  370. {
  371. try
  372. {
  373. CFile file;
  374. if (AfxOpenFile(file, csFileName, CFile::modeRead))
  375. {
  376. int iLen = (int)file.GetLength();
  377. char* pszBuffer = new char[iLen+2];
  378. int iBytes = (int)file.Read(pszBuffer, iLen);
  380. ASSERT(iLen == iBytes);
  382. pszBuffer[iLen] = '';
  383. m_csDataBuffer = pszBuffer;
  385. SAFE_DELETE_AR(pszBuffer);
  386. file.Close();
  388. Parse(m_arLexClassInfo);
  390. if (bSaveInfo)
  391. {
  392. CString csKey = csFileName;
  393. csKey.MakeLower();
  395. CXTPSyntaxEditLexClassInfoArray* pInfo = NULL;
  396. if (!m_mapLexClassInfo.Lookup(csKey, (void*&)pInfo))
  397. {
  398. m_mapLexClassInfo[csKey] = new CXTPSyntaxEditLexClassInfoArray(m_arLexClassInfo);
  399. }
  400. else
  401. {
  402. *pInfo = m_arLexClassInfo;
  403. }
  404. }
  405. }
  406. }
  407. catch(CFileException* expFile)
  408. {
  409. #ifdef _DEBUG
  410. ProcessFileException(expFile);
  411. #endif
  412. expFile->Delete();
  413. }
  414. }
  416. void CXTPSyntaxEditLexCfgFileReader::ReadSource(UINT nResourceID)
  417. {
  418. VERIFY(XTPResourceManager()->LoadHTML(&m_csDataBuffer, nResourceID));
  419. }
  421. void CXTPSyntaxEditLexCfgFileReader::Parse(CXTPSyntaxEditLexClassInfoArray& arLexClassDesc)
  422. {
  423. arLexClassDesc.RemoveAll();
  425. m_nEOFPos = m_csDataBuffer.GetLength() - 1;
  426. m_nPrevPos = 0;
  427. if (m_nEOFPos < 0)
  428. {
  429. return;
  430. }
  431. m_nCurrLine = 1;
  432. m_nCurrLine_pos = 0;
  433. m_nCurrPos = 0;
  434. m_strToken = XTP_EDIT_LEXCLASS_EMPTYSTR;
  436. int nTokenType = 0;
  437. while (m_nEOFPos > m_nCurrPos && m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_STARTTOKEN) != 0)
  438. {
  439. nTokenType = GetLexToken();
  440. }
  442. if (m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_STARTTOKEN) == 0)
  443. {
  444. while (m_nEOFPos > m_nCurrPos)
  445. {
  446. XTP_EDIT_LEXCLASSINFO infoClass;
  447. ParseLexClass(infoClass);
  448. if (!infoClass.csClassName.IsEmpty())
  449. {
  450. arLexClassDesc.Add(infoClass);
  451. }
  452. }
  453. }
  454. }
  456. void CXTPSyntaxEditLexCfgFileReader::ParseLexClass(XTP_EDIT_LEXCLASSINFO& infoClass)
  457. {
  458. if (m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_STARTTOKEN) == 0)
  459. {
  460. infoClass.nStartLine = m_nCurrLine;
  461. infoClass.nEndLine = 0;
  462. }
  464. int nTokenType = GetLexToken();
  466. int nPrevToken = 0;
  467. while (m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_STARTTOKEN) != 0 && m_nEOFPos > m_nCurrPos )
  468. {
  469. XTP_EDIT_LEXPROPINFO infoProp;
  471. if (m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_ENDTOKEN) == 0)
  472. {
  473. infoClass.nEndLine = m_nCurrLine;
  474. }
  476. infoProp.nLine = 0;
  477. infoProp.nPropertyLen = 0;
  478. infoProp.nOffset = 0;
  479. int nValBeginPos = 0;
  481. while (m_strToken != _T('=') && m_nEOFPos > m_nCurrPos && m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_STARTTOKEN) != 0)
  482. {
  484. if (nTokenType != xtpEditTokType_EOL && m_nEOFPos > m_nCurrPos)
  485. {
  486. if (m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_PROPNAME) == 0)
  487. {
  488. infoClass.csClassName = m_strToken;
  489. //TRACE(_T("nName = %s"), m_strToken);
  490. }
  491. else
  492. {
  493. infoProp.arPropName.Add(m_strToken);
  494. DBG_READ_TRACE(_T("%s$"),m_strToken);
  495. }
  496. infoProp.nLine = m_nCurrLine;
  497. }
  498. nTokenType = GetLexToken();
  499. }
  501. if (m_strToken.CompareNoCase(XTP_EDIT_LEXCLASS_STARTTOKEN) != 0 &&
  502. nTokenType != xtpEditTokType_EOL)
  503. { // get value's chain
  505. nTokenType = GetLexToken();
  507. infoProp.nOffset = m_nCurrPos - m_nPrevPos - m_strToken.GetLength();
  508. nValBeginPos = m_nCurrPos - m_strToken.GetLength();
  509. if (nPrevToken == xtpEditTokType_Quoted)
  510. {
  511. infoProp.nOffset += 1;
  512. }
  513. if (nTokenType == xtpEditTokType_Quoted )
  514. {
  515. infoProp.nOffset -= 1;
  516. nValBeginPos -= 1;
  517. }
  519. while (nTokenType != xtpEditTokType_EOL && m_nEOFPos > m_nCurrPos)
  520. {
  521. if (nTokenType != xtpEditTokType_EOL)
  522. {
  523. if (infoClass.csClassName.CompareNoCase(XTP_EDIT_LEXCLASS_PROPNAME) == 0)
  524. {
  525. infoClass.csClassName = m_strToken;
  526. DBG_READ_TRACE(_T("nClass name = %s "),m_strToken);
  527. }
  528. else
  529. {
  530. m_nPrevPos = m_nCurrPos;
  531. CString str = StrToES(m_strToken, TRUE);
  532. infoProp.arPropValue.Add(str);
  534. str = ESToStr(str, TRUE);
  535. DBG_READ_TRACE(_T("|%sn"),str);
  536. }
  538. }
  540. nPrevToken = nTokenType;
  541. nTokenType = GetLexToken();
  542. }
  544. if (infoProp.arPropValue.GetSize() > 0)
  545. {
  546. infoProp.nPropertyLen +=  m_nPrevPos - nValBeginPos;
  547. if (nPrevToken == xtpEditTokType_Quoted)
  548. {
  549. infoProp.nPropertyLen -= 1;
  550. }
  552. infoClass.arPropertyDesc.Add(infoProp);
  553. }
  555. nTokenType = GetLexToken();
  556. }
  557. }
  559. DBG_READ_TRACE(_T("n ---------------- %s -----------------n"), infoClass.csClassName);
  561. if (infoClass.nEndLine == 0)
  562. {
  563. int nCount = (int)infoClass.arPropertyDesc.GetSize();
  564. if (nCount)
  565. {
  566. infoClass.nEndLine = infoClass.arPropertyDesc[nCount-1].nLine;
  567. }
  568. else
  569. {
  570. infoClass.nEndLine = infoClass.nStartLine;
  571. }
  572. }
  573. }
  576. int CXTPSyntaxEditLexCfgFileReader::GetLexToken()
  577. {
  578. int nIgnoredTokensMask = xtpEditTokType_Unknown;
  579. nIgnoredTokensMask |= xtpEditTokType_Delim;
  580. nIgnoredTokensMask |= xtpEditTokType_Comment;
  582. m_strToken = XTP_EDIT_LEXCLASS_EMPTYSTR;
  583. int nTokenType = GetToken();
  584. if (m_strToken == _T(":"))
  585. nTokenType = xtpEditTokType_Unknown;
  587. while ((nTokenType == xtpEditTokType_Unknown ||
  588.    nTokenType == xtpEditTokType_Delim||
  589.    nTokenType == xtpEditTokType_Comment
  590.    ) && m_nEOFPos > m_nCurrPos
  591.    )
  592. {
  593. m_strToken = XTP_EDIT_LEXCLASS_EMPTYSTR;
  594. nTokenType = GetToken();
  595. }
  596. if (m_strToken == _T("lexClass"))
  597. {
  598. GetToken();
  599. }
  601. return nTokenType;
  603. }
  605. int CXTPSyntaxEditLexCfgFileReader::GetToken()
  606. {
  607. TCHAR tchCurrSymbol = _T('');
  608. int nFoundedToken = 0;
  609. if (m_nCurrPos >= m_nEOFPos)
  610. {
  611. return xtpEditTokType_Unknown;
  612. }
  614. //------------------------------------------------------------------------
  615. TCHAR tchCurr_0 = m_csDataBuffer.GetAt(m_nCurrPos);
  617. if (tchCurr_0 == _T('x0A') && m_nCurrPos > m_nCurrLine_pos)
  618. {
  619. m_nCurrLine++;
  620. m_nCurrLine_pos = m_nCurrPos;
  621. }
  622. //------------------------------------------------------------------------
  624. tchCurrSymbol = m_csDataBuffer.GetAt(m_nCurrPos++);
  626. switch (m_nTokenType)
  627. {
  628. case xtpEditTokType_Unknown :
  629. nFoundedToken = ProcessUnknowToken(tchCurrSymbol);
  630. if (m_nTokenType == xtpEditTokType_Unknown)
  631. {
  632. GetToken();
  633. }
  634. break;
  635. case xtpEditTokType_Delim :
  636. nFoundedToken = ProcessDelimToken(tchCurrSymbol);
  637. break;
  638. case xtpEditTokType_Name :
  639. nFoundedToken = ProcessNameToken(tchCurrSymbol);
  640. if (m_nTokenType == xtpEditTokType_Name)
  641. {
  642. m_strToken += tchCurrSymbol;
  643. GetToken();
  644. }
  645. break;
  646. case xtpEditTokType_Value :
  647. nFoundedToken = ProcessValueToken(tchCurrSymbol);
  648. if (m_nTokenType == xtpEditTokType_Value)
  649. {
  650. m_strToken += tchCurrSymbol;
  651. GetToken();
  652. }
  653. break;
  654. case xtpEditTokType_Quoted :
  655. nFoundedToken = ProcessQuotedToken(tchCurrSymbol);
  656. if (m_nTokenType == xtpEditTokType_Quoted)
  657. {
  658. m_strToken += tchCurrSymbol;
  659. GetToken();
  660. }
  661. break;
  662. case xtpEditTokType_Comment :
  663. nFoundedToken = ProcessCommentToken(tchCurrSymbol);
  664. if (m_nTokenType == xtpEditTokType_Comment)
  665. {
  666. m_strToken += tchCurrSymbol;
  667. GetToken();
  668. }
  669. break;
  670. case xtpEditTokType_EOL :
  671. nFoundedToken = ProcessEOLToken(tchCurrSymbol);
  672. if (m_nTokenType == xtpEditTokType_EOL)
  673. {
  674. m_strToken += tchCurrSymbol;
  675. GetToken();
  676. }
  677. break;
  678. case xtpEditTokType_Control :
  679. nFoundedToken = ProcessControlToken(tchCurrSymbol);
  680. if (m_nTokenType == xtpEditTokType_Control)
  681. {
  682. m_strToken += tchCurrSymbol;
  683. GetToken();
  684. }
  685. break;
  686. default :
  687. nFoundedToken = ProcessUnknowToken(tchCurrSymbol);
  688. if (m_nTokenType == xtpEditTokType_Unknown)
  689. {
  690. GetToken();
  691. }
  692. }
  694. return nFoundedToken;
  695. }
  697. int CXTPSyntaxEditLexCfgFileReader::ProcessUnknowToken(TCHAR tchCurrSymbol)
  698. {
  699. int nFoundedToken = m_nTokenType;
  700. if (_istalpha(tchCurrSymbol))
  701. {
  702. m_nTokenType = xtpEditTokType_Name;
  703. }
  704. else if (tchCurrSymbol == _T('''))
  705. {
  706. m_nTokenType = xtpEditTokType_Quoted;
  707. }
  708. else if (tchCurrSymbol == _T('/'))
  709. {
  710. m_nTokenType = xtpEditTokType_Comment;
  711. }
  712. else if (cstrDelims.Find(tchCurrSymbol) > -1)
  713. {
  714. m_nTokenType = xtpEditTokType_Delim;
  715. }
  716. else if (cstrEOL.Find(tchCurrSymbol) > -1)
  717. {
  718. m_nTokenType = xtpEditTokType_EOL;
  719. }
  720. else if (tchCurrSymbol == _T('='))
  721. {
  722. m_nTokenType = xtpEditTokType_Control;
  723. }
  724. else if (tchCurrSymbol == _T(':'))
  725. {
  726. m_nTokenType = xtpEditTokType_Control;
  727. }
  728. else
  729. {
  730. m_nTokenType = xtpEditTokType_Value;
  731. }
  733. if (nFoundedToken != m_nTokenType)
  734. {
  735. m_nCurrPos--;
  736. }
  738. return nFoundedToken;
  739. }
  741. int CXTPSyntaxEditLexCfgFileReader::ProcessDelimToken(TCHAR tchCurrSymbol)
  742. {
  743. return ProcessUnknowToken(tchCurrSymbol);
  744. }
  746. int CXTPSyntaxEditLexCfgFileReader::ProcessNameToken(TCHAR tchCurrSymbol)
  747. {
  748. int nFoundedToken = m_nTokenType;
  749. if (tchCurrSymbol == _T('''))
  750. {
  751. m_nTokenType = xtpEditTokType_Quoted;
  752. }
  753. else if (tchCurrSymbol == _T('/'))
  754. {
  755. m_nTokenType = xtpEditTokType_Comment;
  756. }
  757. else if (cstrDelims.Find(tchCurrSymbol) > -1)
  758. {
  759. m_nTokenType = xtpEditTokType_Delim;
  760. }
  761. else if (cstrEOL.Find(tchCurrSymbol) > -1)
  762. {
  763. m_nTokenType = xtpEditTokType_EOL;
  764. }
  765. else if (tchCurrSymbol == _T('='))
  766. {
  767. m_nTokenType = xtpEditTokType_Control;
  768. }
  769. else if (tchCurrSymbol == _T(':'))
  770. {
  771. m_nTokenType = xtpEditTokType_Control;
  772. }
  774. if (nFoundedToken != m_nTokenType)
  775. {
  776. m_nCurrPos--;
  777. }
  779. return nFoundedToken;
  780. }
  782. int CXTPSyntaxEditLexCfgFileReader::ProcessValueToken(TCHAR tchCurrSymbol)
  783. {
  784. int nFoundedToken = m_nTokenType;
  785. if (cstrDelims.Find(tchCurrSymbol) > -1)
  786. {
  787. m_nTokenType = xtpEditTokType_Delim;
  788. }
  789. else if (cstrEOL.Find(tchCurrSymbol) > -1)
  790. {
  791. m_nTokenType = xtpEditTokType_EOL;
  792. }
  793. else if (tchCurrSymbol == _T('/'))
  794. {
  795. m_nTokenType = xtpEditTokType_Comment;
  796. }
  798. if (nFoundedToken != m_nTokenType)
  799. {
  800. m_nCurrPos--;
  801. }
  803. return nFoundedToken;
  805. }
  807. int CXTPSyntaxEditLexCfgFileReader::ProcessQuotedToken(TCHAR tchCurrSymbol)
  808. {
  810. int nFoundedToken = m_nTokenType;
  812. int nLen = m_strToken.GetLength();
  814. if (cstrEOL.Find(tchCurrSymbol) > -1)
  815. m_nTokenType = xtpEditTokType_EOL;
  816. else if (m_nCurrPos == m_nEOFPos)
  817. m_nTokenType = xtpEditTokType_Unknown;
  818. else if (nLen == 0)
  819. return nFoundedToken;
  820. else if (m_strToken.GetAt(max(0, m_strToken.GetLength() - 1)) == _T('\'))
  821. {
  822. return nFoundedToken;
  823. }
  824. else if (tchCurrSymbol == _T('''))
  825. {
  826. if (m_strToken == _T('''))
  827. {
  828. nFoundedToken = GetToken();
  829. }
  830. else
  831. {
  832. m_nTokenType = xtpEditTokType_Unknown;
  833. m_strToken += tchCurrSymbol;
  834. m_nCurrPos++;
  835. }
  836. }
  838. return nFoundedToken;
  839. }
  841. int CXTPSyntaxEditLexCfgFileReader::ProcessCommentToken(TCHAR tchCurrSymbol)
  842. {
  843. int nFoundedToken = m_nTokenType;
  844. if (cstrEOL.Find(tchCurrSymbol) > -1)
  845. {
  846. m_nTokenType = xtpEditTokType_EOL;
  847. m_nCurrPos--;
  848. }
  849. return nFoundedToken;
  850. }
  852. int CXTPSyntaxEditLexCfgFileReader::ProcessEOLToken(TCHAR tchCurrSymbol)
  853. {
  854. return ProcessUnknowToken(tchCurrSymbol);
  855. }
  857. int CXTPSyntaxEditLexCfgFileReader::ProcessControlToken(TCHAR tchCurrSymbol)
  858. {
  859. return ProcessUnknowToken(tchCurrSymbol);
  860. }
  862. CXTPSyntaxEditLexClassInfoArray& CXTPSyntaxEditLexCfgFileReader::GetLexClassInfoArray()
  863. {
  864. return m_arLexClassInfo;
  865. }
  867. BOOL CXTPSyntaxEditLexCfgFileReader::WriteCfgFile(const CString& csFileName, CXTPSyntaxEditLexClassInfoArray& arLexClassDesc)
  868. {
  869. if (!arLexClassDesc.m_bModified)
  870. return FALSE;
  872. CStringArray arBuffer;
  873. CMapPtrToBool mapSavedClass;
  875. ReadSource(csFileName, FALSE);
  876. ReadSource2(csFileName, arBuffer);
  878. try
  879. {
  880. CString csTmpFileName = csFileName + _T(".tmp");
  882. ::SetFileAttributes(csTmpFileName, FILE_ATTRIBUTE_NORMAL);
  883. ::DeleteFile(csTmpFileName);
  885. CFile file;
  886. if (!AfxOpenFile(file, csTmpFileName, CFile::modeWrite | CFile::shareExclusive | CFile::modeCreate))
  887. return FALSE;
  889. int nLastWrittenLine = 0;
  891. // (1) Update Existing and deleted Classes
  892. int nCount = (int)m_arLexClassInfo.GetSize();
  893. int i;
  894. for (i = 0; i < nCount; i++)
  895. {
  896. XTP_EDIT_LEXCLASSINFO& oldClassInfo = m_arLexClassInfo[i];
  898. XTP_EDIT_LEXCLASSINFO* pNewClassInfo = FindClassDesc(arLexClassDesc, oldClassInfo.csClassName);
  899. // class was deleted;
  900. if (!pNewClassInfo)
  901. {
  902. WriteStrings(file, arBuffer, nLastWrittenLine+1, oldClassInfo.nStartLine-1);
  903. nLastWrittenLine = oldClassInfo.nEndLine;
  904. continue;
  905. }
  906. mapSavedClass[pNewClassInfo] = TRUE;
  908. CMapPtrToBool mapSavedProps;
  909. CString csOffset(_T("t"));
  911. // (1.a) Update Existing and deleted properties
  912. int nPropsCount = (int)oldClassInfo.arPropertyDesc.GetSize();
  913. int k;
  914. for (k = 0; k < nPropsCount; k++)
  915. {
  916. XTP_EDIT_LEXPROPINFO& oldInfoProp = oldClassInfo.arPropertyDesc[k];
  918. WriteStrings(file, arBuffer, nLastWrittenLine+1, oldInfoProp.nLine-1);
  919. nLastWrittenLine = oldInfoProp.nLine;
  921. XTP_EDIT_LEXPROPINFO* pNewInfoProp = FindPropDesc(pNewClassInfo, &oldInfoProp, mapSavedProps);
  922. if (pNewInfoProp)
  923. {
  924. WriteProp(file, csOffset, oldInfoProp, *pNewInfoProp, arBuffer);
  925. mapSavedProps[pNewInfoProp] = TRUE;
  926. }
  927. }
  929. // (1.b) Insert new properties
  930. nPropsCount = (int)pNewClassInfo->arPropertyDesc.GetSize();
  931. for (k = 0; k < nPropsCount; k++)
  932. {
  933. XTP_EDIT_LEXPROPINFO& newInfoProp = pNewClassInfo->arPropertyDesc[k];
  935. bool bSaved = false;
  936. if (!mapSavedProps.Lookup((void*)&newInfoProp, bSaved) || !bSaved)
  937. {
  938. WriteProp(file, csOffset, newInfoProp);
  939. }
  940. }
  941. }
  943. //------------------------------------------------------------------------
  944. WriteStrings(file, arBuffer, nLastWrittenLine+1, m_nCurrLine);
  945. nLastWrittenLine = m_nCurrLine;
  947. //===========================================================================
  948. // (2) Insert new Classes
  949. nCount = (int)arLexClassDesc.GetSize();
  950. for (i = 0; i < nCount; i++)
  951. {
  952. XTP_EDIT_LEXCLASSINFO& newClassInfo = arLexClassDesc[i];
  954. bool bSaved = false;
  955. if (!mapSavedClass.Lookup((void*)&newClassInfo, bSaved) || !bSaved)
  956. {
  957. WriteString(file, _T(""));
  958. WriteString(file, XTP_EDIT_LEXCLASS_STARTTOKEN);
  960. // Insert properties
  961. int nPropsCount = (int)newClassInfo.arPropertyDesc.GetSize();
  962. for (int k = 0; k < nPropsCount; k++)
  963. {
  964. const XTP_EDIT_LEXPROPINFO& newInfoProp = newClassInfo.arPropertyDesc[k];
  966. CString csOffset(_T("t"));
  967. WriteProp(file, csOffset, newInfoProp);
  968. }
  970. WriteString(file, XTP_EDIT_LEXCLASS_ENDTOKEN);
  971. }
  972. }
  974. //===========================================================================
  975. file.Close();
  977. CString strFileName_prev = csFileName + _T(".old");
  978. ::SetFileAttributes(strFileName_prev, FILE_ATTRIBUTE_NORMAL);
  979. ::DeleteFile(strFileName_prev);
  981. #ifdef _DEBUG
  982. //CFile::Rename(csFileName, strFileName_prev);
  983. #endif
  985. ::SetFileAttributes(csFileName, FILE_ATTRIBUTE_NORMAL);
  986. ::DeleteFile(csFileName);
  987. CFile::Rename(csTmpFileName, csFileName);
  989. m_arLexClassInfo.RemoveAll();
  990. return TRUE;
  991. }
  993. catch(CFileException* expFile)
  994. {
  995. #ifdef _DEBUG
  996. expFile->ReportError();
  997. //ProcessFileException(expFile);
  998. #endif
  999. expFile->Delete();
  1000. }
  1002. m_arLexClassInfo.RemoveAll();
  1003. arLexClassDesc.m_bModified = FALSE;
  1005. return FALSE;
  1006. }
  1008. XTP_EDIT_LEXCLASSINFO* CXTPSyntaxEditLexCfgFileReader::FindClassDesc(CXTPSyntaxEditLexClassInfoArray& arInfoClass, const CString& csClassName)
  1009. {
  1010. if (csClassName.IsEmpty())
  1011. {
  1012. ASSERT(FALSE);
  1013. return NULL;
  1014. }
  1016. for (int i = 0; i < arInfoClass.GetSize(); i++)
  1017. {
  1018. if (arInfoClass[i].csClassName.CompareNoCase(csClassName) == 0)
  1019. {
  1020. return &arInfoClass[i];
  1021. }
  1022. }
  1024. return NULL;
  1025. }
  1027. XTP_EDIT_LEXPROPINFO* CXTPSyntaxEditLexCfgFileReader::FindPropDesc(XTP_EDIT_LEXCLASSINFO* pInfoClass, XTP_EDIT_LEXPROPINFO* pInfoProp, CMapPtrToBool& mapUsed)
  1028. {
  1029. if (!pInfoClass || !pInfoProp)
  1030. {
  1031. ASSERT(FALSE);
  1032. return NULL;
  1033. }
  1035. int nPNameSize = (int)pInfoProp->arPropName.GetSize();
  1036. CString strPropName_src = MakeStr(pInfoProp->arPropName, _T(":"));
  1038. int nCount = (int)pInfoClass->arPropertyDesc.GetSize();
  1039. for (int i = 0; i < nCount; i++)
  1040. {
  1041. XTP_EDIT_LEXPROPINFO* pNewInfoProp = &(*pInfoClass).arPropertyDesc[i];
  1042. ASSERT(pNewInfoProp);
  1044. if (pNewInfoProp && pNewInfoProp->arPropName.GetSize() == nPNameSize)
  1045. {
  1046. CString strPName = MakeStr(pNewInfoProp->arPropName, _T(":"));
  1048. if (strPropName_src.CompareNoCase(strPName) == 0)
  1049. {
  1050. bool bUsed = false;
  1051. if (mapUsed.Lookup(pNewInfoProp, bUsed) && bUsed)
  1052. {
  1053. continue;
  1054. }
  1056. return pNewInfoProp;
  1057. }
  1058. }
  1059. }
  1061. return NULL;
  1062. }
  1065. void CXTPSyntaxEditLexCfgFileReader::WriteString(CFile& file, LPCTSTR pcszString)
  1066. {
  1067. int nStrLen = (int)_tcslen(pcszString);
  1069. #ifdef _UNICODE
  1070. CByteArray arBufferMBCS;
  1071. arBufferMBCS.SetSize(nStrLen*2+4);
  1073. char* pTextMBCS = (char*)arBufferMBCS.GetData();
  1075. int nNewLen = WideCharToMultiByte(CP_ACP, 0,
  1076. pcszString, -1, pTextMBCS, nStrLen*2+1, NULL, NULL);
  1078. nStrLen = nNewLen ? nNewLen-1 : 0;
  1079. #else
  1080. char* pTextMBCS = (char*)pcszString;
  1081. #endif
  1083. file.Write(pTextMBCS, nStrLen);
  1084. file.Write("rn", 2);
  1085. }
  1087. void CXTPSyntaxEditLexCfgFileReader::WriteStrings(CFile& file, CStringArray& arBuffer, int nFrom, int nTo)
  1088. {
  1089. int nCount = (int)arBuffer.GetSize();
  1090. if (nFrom >= nCount || nFrom > nTo)
  1091. {
  1092. return;
  1093. }
  1094. if (nTo >= nCount)
  1095. {
  1096. nTo = nCount-1;
  1097. }
  1099. for (int nLine = nFrom; nLine <= nTo; nLine++)
  1100. {
  1101. CString csBuffer = arBuffer[nLine];
  1102. WriteString(file, csBuffer);
  1103. }
  1104. }
  1106. void CXTPSyntaxEditLexCfgFileReader::WriteProp(CFile& file, CString& csOffset, const XTP_EDIT_LEXPROPINFO& newInfoProp)
  1107. {
  1108. CString csPropName = MakeStr(newInfoProp.arPropName, _T(":"));
  1109. CString csPropValue = AfxMakeStrES(newInfoProp.arPropValue, _T(", "));
  1110. CString csPropString = csOffset + csPropName + _T(" = ") + csPropValue;
  1111. WriteString(file, csPropString);
  1112. }
  1114. void CXTPSyntaxEditLexCfgFileReader::WriteProp(CFile& file, CString& csOffset, const XTP_EDIT_LEXPROPINFO& oldInfoProp, const XTP_EDIT_LEXPROPINFO& newInfoProp, const CStringArray& arBuffer)
  1115. {
  1116. if (oldInfoProp.nLine < arBuffer.GetSize())
  1117. {
  1118. CString csBuffer = arBuffer[oldInfoProp.nLine];
  1120. int iIndex = csBuffer.Find(_T("="));
  1121. ASSERT(iIndex > 0);
  1122. if (iIndex > 0)
  1123. {
  1124. csOffset = csBuffer.SpanIncluding(_T(" t"));
  1126. CString csSep = csBuffer.Mid(iIndex+1);
  1127. csSep = csSep.SpanIncluding(_T(" t"));
  1128. iIndex += csSep.GetLength();
  1130. CString csNewBuffer = csBuffer;
  1131. DELETE_S(csNewBuffer, iIndex+1, oldInfoProp.nPropertyLen);
  1133. CString csPropValue = AfxMakeStrES(newInfoProp.arPropValue, _T(", "));
  1134. INSERT_S(csNewBuffer, iIndex+1, csPropValue);
  1135. WriteString(file, csNewBuffer);
  1136. return;
  1137. }
  1139. }
  1140. else
  1141. {
  1142. ASSERT(FALSE);
  1143. }
  1145. WriteProp(file, csOffset, newInfoProp);
  1146. }
  1148. #ifdef _DEBUG
  1149. void CXTPSyntaxEditLexCfgFileReader::ProcessFileException(CFileException* pExc)
  1150. {
  1151. CString strErrorMsg(_T(" "));
  1152. switch (pExc->m_cause)
  1153. {
  1154. #if (_MSC_VER > 1310) // VS2005
  1155. case CFileException::genericException :
  1156. #else
  1157. case CFileException::generic :
  1158. #endif
  1159. strErrorMsg = _T("An unspecified error occurred.");
  1160. break;
  1161. case CFileException::fileNotFound :
  1162. strErrorMsg = _T("The file could not be located.");
  1163. break;
  1164. case CFileException::badPath :
  1165. strErrorMsg = _T("All or part of the path is invalid.");
  1166. break;
  1167. case CFileException::tooManyOpenFiles :
  1168. strErrorMsg = _T("The permitted number of open files was exceeded.");
  1169. break;
  1170. case CFileException::accessDenied :
  1171. strErrorMsg = _T("The file could not be accessed.");
  1172. break;
  1173. case CFileException::invalidFile :
  1174. strErrorMsg = _T("There was an attempt to use an invalid file handle.");
  1175. break;
  1176. case CFileException::removeCurrentDir :
  1177. strErrorMsg = _T("The current working directory cannot be removed.");
  1178. break;
  1179. case CFileException::directoryFull :
  1180. strErrorMsg = _T("There are no more directory entries.");
  1181. break;
  1182. case CFileException::badSeek :
  1183. strErrorMsg = _T("There was an error trying to set the file pointer.");
  1184. break;
  1185. case CFileException::hardIO :
  1186. strErrorMsg = _T("There was a hardware error.");
  1187. break;
  1188. case CFileException::sharingViolation :
  1189. strErrorMsg = _T("SHARE.EXE was not loaded, or a shared region was locked.");
  1190. break;
  1191. case CFileException::lockViolation :
  1192. strErrorMsg = _T("There was an attempt to lock a region that was already locked.");
  1193. break;
  1194. case CFileException::diskFull :
  1195. strErrorMsg = _T("The disk is full.");
  1196. break;
  1197. case CFileException::endOfFile :
  1198. strErrorMsg = _T("The end of file was reached.");
  1199. break;
  1200. default :
  1201. strErrorMsg = _T("Unknown error.");
  1202. }
  1204. TRACE(_T("ERROR: %s File Name: %s n"), (LPCTSTR)strErrorMsg, (LPCTSTR)pExc->m_strFileName);
  1205. }
  1206. #endif
  1209. CString CXTPSyntaxEditLexCfgFileReader::StrToES(CString strSrc, BOOL bQuoted)
  1210. {
  1211. CString strRez(strSrc);
  1212. strRez.TrimLeft(); strRez.TrimRight();
  1214. int nLen = strRez.GetLength();
  1215. if (nLen < 1)
  1216. {
  1217. return strRez;
  1218. }
  1220. if (bQuoted && strRez.GetAt(0) == _T(''') && strRez.GetAt(nLen - 1) == _T('''))
  1221. {
  1222. strRez.SetAt(0,      _T('x1'));
  1223. strRez.SetAt(nLen-1, _T('x1'));
  1224. }
  1226. REPLACE_S(strRez, _T("\\"), _T("x2"));
  1228. REPLACE_S(strRez, _T("\a"), _T("a"));
  1229. REPLACE_S(strRez, _T("\b"), _T("b"));
  1230. REPLACE_S(strRez, _T("\f"), _T("f"));
  1231. REPLACE_S(strRez, _T("\n"), _T("n"));
  1232. REPLACE_S(strRez, _T("\r"), _T("r"));
  1233. REPLACE_S(strRez, _T("\t"), _T("t"));
  1234. REPLACE_S(strRez, _T("\v"), _T("v"));
  1235. REPLACE_S(strRez, _T("\'"), _T("'"));
  1237. REPLACE_S(strRez, _T("x2"), _T("\"));
  1238. REPLACE_S(strRez, _T("x1"), _T("'"));
  1239. return strRez;
  1240. }
  1242. CString CXTPSyntaxEditLexCfgFileReader::ESToStr(CString strSrc, BOOL bQuoted)
  1243. {
  1244. CString strRez(strSrc);
  1246. strRez.TrimLeft(); strRez.TrimRight();
  1248. int nLen = strRez.GetLength();
  1249. if (nLen < 1)
  1250. {
  1251. return strRez;
  1252. }
  1254. if (bQuoted && strRez.GetAt(0) == _T(''') && strRez.GetAt(nLen - 1) == _T('''))
  1255. {
  1256. strRez.SetAt(0,      _T('x1'));
  1257. strRez.SetAt(nLen-1, _T('x1'));
  1258. }
  1260. REPLACE_S(strRez, _T("\"), _T("x2"));
  1262. REPLACE_S(strRez, _T("a"), _T("\a"));
  1263. REPLACE_S(strRez, _T("b"), _T("\b"));
  1264. REPLACE_S(strRez, _T("f"), _T("\f"));
  1265. REPLACE_S(strRez, _T("n"), _T("\n"));
  1266. REPLACE_S(strRez, _T("r"), _T("\r"));
  1267. REPLACE_S(strRez, _T("t"), _T("\t"));
  1268. REPLACE_S(strRez, _T("v"), _T("\v"));
  1269. REPLACE_S(strRez, _T("'"), _T("\'"));
  1270. REPLACE_S(strRez, _T("x2"), _T("\\"));
  1272. REPLACE_S(strRez, _T("x1"), _T("'"));
  1275. return strRez;
  1276. }
  1278. /////////////////////////////////////////////////////////////////////////////
  1279. // CXTPSyntaxEditFileChangesMonitor
  1280. //
  1281. CXTPSyntaxEditFileChangesMonitor::CXTPSyntaxEditFileChangesMonitor()
  1282. {
  1283. m_pThread = NULL;
  1284. m_evExitThread = NULL;
  1285. m_pConfigMgr = NULL;
  1286. }
  1288. CXTPSyntaxEditFileChangesMonitor::~CXTPSyntaxEditFileChangesMonitor()
  1289. {
  1290. StopMonitoring();
  1291. }
  1293. void CXTPSyntaxEditFileChangesMonitor::SetDefaultFolder(const CString& strPath)
  1294. {
  1295. m_strPath = strPath;
  1296. }
  1298. void CXTPSyntaxEditFileChangesMonitor::RemoveAll()
  1299. {
  1300. m_arFiles.RemoveAll();
  1301. }
  1303. BOOL CXTPSyntaxEditFileChangesMonitor::AddMonitorFile(CString& strFilename,
  1304.  DWORD dwOwnerFlags)
  1305. {
  1306. // try open file
  1307. BY_HANDLE_FILE_INFORMATION sysFileInfo;
  1309. BOOL bRes = GetFileInfo(strFilename, &sysFileInfo);
  1310. if (!bRes)
  1311. {
  1312. // try again in the default folder
  1313. CString strFullFilename = m_strPath + strFilename;
  1314. bRes = GetFileInfo(strFullFilename, &sysFileInfo);
  1315. if (bRes)
  1316. {
  1317. strFilename = strFullFilename;
  1318. }
  1319. }
  1321. // get complete file name
  1322. if (bRes)
  1323. {
  1324. // get the directory for the file
  1325. TCHAR szPath[_MAX_PATH];
  1326. LPTSTR lpszName;
  1327. if (::GetFullPathName(strFilename, _MAX_PATH, szPath, &lpszName))
  1328. {
  1329. strFilename = szPath;
  1330. }
  1331. }
  1333. // Prepare file info structure
  1334. CFMFileInfo fmFileInfo;
  1336. fmFileInfo.m_strFileName = strFilename;
  1338. fmFileInfo.m_bExists = bRes;
  1339. fmFileInfo.m_dwOwnerFlags = dwOwnerFlags;
  1341. if (bRes)
  1342. {
  1343. fmFileInfo.m_sysFileInfo = sysFileInfo;
  1344. }
  1346. // add file to the monitoring array
  1347. m_arFiles.Add(fmFileInfo);
  1349. return bRes;
  1350. }
  1352. void CXTPSyntaxEditFileChangesMonitor::StartMonitoring()
  1353. {
  1354. if (m_pThread)
  1355. {
  1356. ASSERT(FALSE);
  1357. return;
  1358. }
  1360. ASSERT(m_evExitThread == NULL);
  1361. m_evExitThread = CreateEvent(NULL,TRUE,FALSE,NULL);
  1362. ASSERT(m_evExitThread);
  1364. m_pThread = AfxBeginThread(ThreadMonitorProc, (LPVOID)this,
  1365. THREAD_PRIORITY_LOWEST);
  1366. //, 0, CREATE_SUSPENDED, NULL);
  1368. if (!m_pThread)
  1369. {
  1370. ASSERT(FALSE);
  1371. return;
  1372. }
  1373. }
  1375. void CXTPSyntaxEditFileChangesMonitor::StopMonitoring()
  1376. {
  1377. if (m_pThread)
  1378. {
  1379. HANDLE hThread = m_pThread->m_hThread;
  1380. ::SetEvent(m_evExitThread);
  1382. DWORD dwThreadRes = ::WaitForSingleObject(hThread, 20*1000);
  1384. if (dwThreadRes == WAIT_TIMEOUT)
  1385. {
  1386. ::TerminateThread(hThread, 0);
  1387. //ASSERT(FALSE);
  1388. TRACE(_T("ERROR! FileChangesMonitor thread was not ended by normal way. It was terminated. n"));
  1389. }
  1390. ::CloseHandle(m_evExitThread);
  1392. m_evExitThread = NULL;
  1393. m_pThread = NULL;
  1394. }
  1395. RemoveAll();
  1396. }
  1398. UINT CXTPSyntaxEditFileChangesMonitor::ThreadMonitorProc(LPVOID p)
  1399. {
  1400. try
  1401. {
  1402. CXTPSyntaxEditFileChangesMonitor* pFolderMonitor = (CXTPSyntaxEditFileChangesMonitor*)p;
  1403. if (!pFolderMonitor)
  1404. return 1;
  1406. for (;;)
  1407. {
  1408. // Wait for notification.
  1409. DWORD dwWaitStatus = WaitForSingleObject(pFolderMonitor->m_evExitThread, 3000);
  1411. if (WAIT_OBJECT_0 == dwWaitStatus)
  1412. {
  1413. ::Sleep(100);
  1414. break;
  1415. }
  1417. if (WAIT_TIMEOUT == dwWaitStatus)
  1418. {
  1419. pFolderMonitor->RefreshFiles();
  1420. }
  1421. }
  1422. }
  1423. catch(...) {
  1424. TRACE(_T("EXCEPTION in CXTPSyntaxEditFileChangesMonitor::ThreadMonitorProcn"));
  1425. }
  1427. return 0;
  1428. }
  1430. void CXTPSyntaxEditFileChangesMonitor::RefreshFiles()
  1431. {
  1432. // Iterate all stored filenames
  1433. int nCount = (int)m_arFiles.GetSize();
  1434. for (int i = 0; i < nCount; i++)
  1435. {
  1436. //CString strFilename;
  1437. CFMFileInfo& rFMFileInfo = m_arFiles.ElementAt(i);
  1439. // get new info for this file
  1440. BY_HANDLE_FILE_INFORMATION sysFileInfo;
  1442. if (GetFileInfo(rFMFileInfo.m_strFileName, &sysFileInfo) )
  1443. {
  1444. // check whether file status is changed
  1445. if (!AfxCompareTime(sysFileInfo.ftLastWriteTime,
  1446. rFMFileInfo.m_sysFileInfo.ftLastWriteTime) ||
  1447. sysFileInfo.nFileSizeLow != rFMFileInfo.m_sysFileInfo.nFileSizeLow ||
  1448. sysFileInfo.nFileSizeHigh != rFMFileInfo.m_sysFileInfo.nFileSizeHigh
  1449. || !rFMFileInfo.m_bExists)
  1450. {
  1451. int nCfgFlags = rFMFileInfo.m_bExists ? 0 : xtpEditCfgFileAdd;
  1453. rFMFileInfo.m_sysFileInfo = sysFileInfo;
  1454. rFMFileInfo.m_bExists = TRUE;
  1456. // reload this file
  1457. m_pConfigMgr->ReloadFile(rFMFileInfo.m_strFileName,
  1458. rFMFileInfo.m_dwOwnerFlags, nCfgFlags);
  1459. }
  1460. }
  1461. else
  1462. {
  1463. if (rFMFileInfo.m_bExists)
  1464. {
  1465. rFMFileInfo.m_bExists = FALSE;
  1467. // remove this file from the collection
  1468. m_pConfigMgr->ReloadFile(rFMFileInfo.m_strFileName,
  1469.  rFMFileInfo.m_dwOwnerFlags, xtpEditCfgFileRemove);
  1470. }
  1472. // try again in the default folder
  1473. CString strFullFilename = m_strPath + rFMFileInfo.m_strFileName;
  1474. if (GetFileInfo(strFullFilename, &sysFileInfo))
  1475. {
  1476. rFMFileInfo.m_strFileName = strFullFilename;
  1477. i--;
  1478. }
  1479. }
  1480. }
  1481. }
  1483. BOOL CXTPSyntaxEditFileChangesMonitor::GetFileInfo(LPCTSTR pcszFilePath,
  1484.   BY_HANDLE_FILE_INFORMATION* pInfo)
  1485. {
  1486. const DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
  1488. HANDLE hFile = ::CreateFile(pcszFilePath, GENERIC_READ, dwShareMode, NULL,
  1489.  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  1491. if (hFile == INVALID_HANDLE_VALUE)
  1492. {
  1493. return FALSE;
  1494. }
  1496. if (!pInfo)
  1497. {
  1498. return TRUE;
  1499. }
  1501. ZeroMemory(pInfo, sizeof(*pInfo));
  1503. BOOL bRes = GetFileInformationByHandle(hFile, pInfo);
  1505. CloseHandle(hFile);
  1507. return bRes;
  1508. }
  1510. ////////////////////////////////////////////////////////////////////////////
  1511. //class CFMFileInfo
  1512. CXTPSyntaxEditFileChangesMonitor::CFMFileInfo::CFMFileInfo()
  1513. {
  1514. ZeroMemory(&m_sysFileInfo, sizeof(m_sysFileInfo));
  1515. m_bExists = FALSE;
  1516. m_dwOwnerFlags = 0;
  1517. }
  1519. const CXTPSyntaxEditFileChangesMonitor::CFMFileInfo&
  1520. CXTPSyntaxEditFileChangesMonitor::CFMFileInfo::operator=(
  1521. const CXTPSyntaxEditFileChangesMonitor::CFMFileInfo& rSrc)
  1522. {
  1523. m_strFileName   = rSrc.m_strFileName;
  1525. m_sysFileInfo   = rSrc.m_sysFileInfo;
  1526. m_bExists       = rSrc.m_bExists;
  1527. m_dwOwnerFlags  = rSrc.m_dwOwnerFlags;
  1529. return *this;
  1530. }