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

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

对话框与窗口

开发平台：

Visual C++

XTPSyntaxEditLexClassSubObjT.h：源码内容
  1. // XTPSyntaxEditLexClassSubObjT.h
  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. //{{AFX_CODEJOCK_PRIVATE
  22. #if !defined(__XTPSYNTAXEDITLEXCLASSSUBOBJT_H__)
  23. #define __XTPSYNTAXEDITLEXCLASSSUBOBJT_H__
  24. //}}AFX_CODEJOCK_PRIVATE
  26. #if _MSC_VER > 1000
  27. #pragma once
  28. #endif // _MSC_VER > 1000
  30. //#pragma warning(disable: 4097 4786)
  32. //#pragma warning(push)
  34. // #define DBG_AUTOMAT
  36. namespace XTPSyntaxEditLexAnalyser
  37. {
  38. //{{AFX_CODEJOCK_PRIVATE
  39. //===========================================================================
  40. class CXTPSyntaxEditLexNULL
  41. {
  42. public:
  43. LPCTSTR GetName() const {
  44. return NULL;
  45. };
  47. BOOL IsEmpty() const {
  48. return TRUE;
  49. }
  51. BOOL IfMy(LPCTSTR pcszElementName) {
  52. UNREFERENCED_PARAMETER(pcszElementName);
  53. return FALSE;
  54. }
  56. BOOL AddIfMy(LPCTSTR pcszElementName, const CXTPSyntaxEditLexVariantPtr& ptr)
  57. {
  58. UNREFERENCED_PARAMETER(pcszElementName);
  59. UNREFERENCED_PARAMETER(ptr);
  60. return FALSE;
  61. }
  63. BOOL AppendIfMy(LPCTSTR pcszElementName,
  64.  const CXTPSyntaxEditLexVariantPtrArray& ptrAr)
  65. {
  66. UNREFERENCED_PARAMETER(pcszElementName);
  67. UNREFERENCED_PARAMETER(ptrAr);
  68. return FALSE;
  69. }
  71. CXTPSyntaxEditLexVariantPtrArray* GetIfMy(LPCTSTR pcszElementName)
  72. {
  73. UNREFERENCED_PARAMETER(pcszElementName);
  74. return NULL;
  75. }
  77. void CopyFrom(CXTPSyntaxEditLexNULL& rSrc) {
  78. UNREFERENCED_PARAMETER(rSrc);
  79. };
  81. void RemoveAll() {};
  82. #ifdef _DEBUG
  83. void DumpOffset(CDumpContext& dc, LPCTSTR pcszOffset) {
  84. dc << pcszOffset;
  85. };
  86. #endif
  87. };
  89. //---------------------------------------------------------------------------
  90. template<class _TC0 = CXTPSyntaxEditLexNULL, class _TC1 = CXTPSyntaxEditLexNULL,
  91. class _TC2 = CXTPSyntaxEditLexNULL, class _TC3 = CXTPSyntaxEditLexNULL,
  92. class _TC4 = CXTPSyntaxEditLexNULL, class _TC5 = CXTPSyntaxEditLexNULL,
  93. class _TC6 = CXTPSyntaxEditLexNULL, class _TC7 = CXTPSyntaxEditLexNULL,
  94. class _TC8 = CXTPSyntaxEditLexNULL, class _TC9 = CXTPSyntaxEditLexNULL >
  96. class CXTPSyntaxEditLexObj_SpecCollT
  97. {
  98. public:
  99. typedef CXTPSyntaxEditLexObj_SpecCollT<_TC0, _TC1, _TC2, _TC3, _TC4,
  100.  _TC5, _TC6, _TC7, _TC8, _TC9> Tthis;
  102. typedef _TC0 _Type0; typedef _TC1 _Type1; typedef _TC2 _Type2;
  103. typedef _TC3 _Type3; typedef _TC4 _Type4; typedef _TC5 _Type5;
  104. typedef _TC6 _Type6; typedef _TC7 _Type7; typedef _TC8 _Type8;
  105. typedef _TC9 _Type9;
  107. CXTPSyntaxEditLexObj_SpecCollT()
  108. {
  109. m_bEmpty = TRUE;
  111. SetSubMembers();
  112. };
  114. virtual ~CXTPSyntaxEditLexObj_SpecCollT(){};
  116. protected:
  117. BOOL m_bEmpty;
  119. _TC0* m_p0; _TC1* m_p1; _TC2* m_p2; _TC3* m_p3; _TC4* m_p4;
  120. _TC5* m_p5; _TC6* m_p6; _TC7* m_p7; _TC8* m_p8; _TC9* m_p9;
  122. virtual void SetSubMember0(){m_p0 = NULL;};
  123. virtual void SetSubMember1(){m_p1 = NULL;};
  124. virtual void SetSubMember2(){m_p2 = NULL;};
  125. virtual void SetSubMember3(){m_p3 = NULL;};
  126. virtual void SetSubMember4(){m_p4 = NULL;};
  127. virtual void SetSubMember5(){m_p5 = NULL;};
  128. virtual void SetSubMember6(){m_p6 = NULL;};
  129. virtual void SetSubMember7(){m_p7 = NULL;};
  130. virtual void SetSubMember8(){m_p8 = NULL;};
  131. virtual void SetSubMember9(){m_p9 = NULL;};
  133. virtual void SetSubMembers()
  134. {
  135. SetSubMember0();
  136. SetSubMember1();
  137. SetSubMember2();
  138. SetSubMember3();
  139. SetSubMember4();
  140. SetSubMember5();
  141. SetSubMember6();
  142. SetSubMember7();
  143. SetSubMember8();
  144. SetSubMember9();
  145. };
  146. public:
  147. BOOL IsEmpty() const {
  148. return m_bEmpty;
  149. }
  151. BOOL IfMy(LPCTSTR pcszElementName)
  152. {
  153. if(     m_p0 && m_p0->IfMy(pcszElementName)) {}
  154. else if(m_p1 && m_p1->IfMy(pcszElementName))
  155. {}
  156. else if(m_p2 && m_p2->IfMy(pcszElementName))
  157. {}
  158. else if(m_p3 && m_p3->IfMy(pcszElementName))
  159. {}
  160. else if(m_p4 && m_p4->IfMy(pcszElementName))
  161. {}
  162. else if(m_p5 && m_p5->IfMy(pcszElementName))
  163. {}
  164. else if(m_p6 && m_p6->IfMy(pcszElementName))
  165. {}
  166. else if(m_p7 && m_p7->IfMy(pcszElementName))
  167. {}
  168. else if(m_p8 && m_p8->IfMy(pcszElementName))
  169. {}
  170. else if(m_p9 && m_p9->IfMy(pcszElementName))
  171. {}
  172. else
  173. {
  174. return FALSE;
  175. }
  176. return TRUE;
  177. }
  179. BOOL AddIfMy(LPCTSTR pcszElementName, const CXTPSyntaxEditLexVariantPtr& ptr)
  180. {
  181. if(     m_p0 && m_p0->AddIfMy(pcszElementName, ptr)) {}
  182. else if(m_p1 && m_p1->AddIfMy(pcszElementName, ptr))
  183. {}
  184. else if(m_p2 && m_p2->AddIfMy(pcszElementName, ptr))
  185. {}
  186. else if(m_p3 && m_p3->AddIfMy(pcszElementName, ptr))
  187. {}
  188. else if(m_p4 && m_p4->AddIfMy(pcszElementName, ptr))
  189. {}
  190. else if(m_p5 && m_p5->AddIfMy(pcszElementName, ptr))
  191. {}
  192. else if(m_p6 && m_p6->AddIfMy(pcszElementName, ptr))
  193. {}
  194. else if(m_p7 && m_p7->AddIfMy(pcszElementName, ptr))
  195. {}
  196. else if(m_p8 && m_p8->AddIfMy(pcszElementName, ptr))
  197. {}
  198. else if(m_p9 && m_p9->AddIfMy(pcszElementName, ptr))
  199. {}
  200. else
  201. {
  202. return FALSE;
  203. }
  204. m_bEmpty = FALSE;
  205. return TRUE;
  206. }
  208. BOOL AppendIfMy(LPCTSTR pcszElementName,
  209. const CXTPSyntaxEditLexVariantPtrArray& ptrAr)
  210. {
  211. if(     m_p0 && m_p0->AppendIfMy(pcszElementName, ptrAr)) {}
  212. else if(m_p1 && m_p1->AppendIfMy(pcszElementName, ptrAr))
  213. {}
  214. else if(m_p2 && m_p2->AppendIfMy(pcszElementName, ptrAr))
  215. {}
  216. else if(m_p3 && m_p3->AppendIfMy(pcszElementName, ptrAr))
  217. {}
  218. else if(m_p4 && m_p4->AppendIfMy(pcszElementName, ptrAr))
  219. {}
  220. else if(m_p5 && m_p5->AppendIfMy(pcszElementName, ptrAr))
  221. {}
  222. else if(m_p6 && m_p6->AppendIfMy(pcszElementName, ptrAr))
  223. {}
  224. else if(m_p7 && m_p7->AppendIfMy(pcszElementName, ptrAr))
  225. {}
  226. else if(m_p8 && m_p8->AppendIfMy(pcszElementName, ptrAr))
  227. {}
  228. else if(m_p9 && m_p9->AppendIfMy(pcszElementName, ptrAr))
  229. {}
  230. else
  231. {
  232. return FALSE;
  233. }
  234. m_bEmpty = FALSE;
  235. return TRUE;
  236. }
  238. CXTPSyntaxEditLexVariantPtrArray* GetIfMy(LPCTSTR pcszElementName)
  239. {
  240. CXTPSyntaxEditLexVariantPtrArray* pData = NULL;
  242. if (m_p0 ) { pData = m_p0->GetIfMy( pcszElementName); if (pData) return pData; }
  243. if (m_p1 ) { pData = m_p1->GetIfMy( pcszElementName); if (pData) return pData; }
  244. if (m_p2 ) { pData = m_p2->GetIfMy( pcszElementName); if (pData) return pData; }
  245. if (m_p3 ) { pData = m_p3->GetIfMy( pcszElementName); if (pData) return pData; }
  246. if (m_p4 ) { pData = m_p4->GetIfMy( pcszElementName); if (pData) return pData; }
  247. if (m_p5 ) { pData = m_p5->GetIfMy( pcszElementName); if (pData) return pData; }
  248. if (m_p6 ) { pData = m_p6->GetIfMy( pcszElementName); if (pData) return pData; }
  249. if (m_p7 ) { pData = m_p7->GetIfMy( pcszElementName); if (pData) return pData; }
  250. if (m_p8 ) { pData = m_p8->GetIfMy( pcszElementName); if (pData) return pData; }
  251. if (m_p9 ) { pData = m_p9->GetIfMy( pcszElementName); if (pData) return pData; }
  253. return NULL;
  254. }
  256. void CopyFrom(const Tthis& rSrc)
  257. {
  258. RemoveAll();
  260. //m_p0 ? m_p0->CopyFrom(*rSrc.m_p0):1;
  262. // just call without accessing to the data (and no virtual)
  263. // NULL->CopyFrom(NULL) - is OK
  264. m_p0->CopyFrom(*rSrc.m_p0);
  265. m_p1->CopyFrom(*rSrc.m_p1);
  266. m_p2->CopyFrom(*rSrc.m_p2);
  267. m_p3->CopyFrom(*rSrc.m_p3);
  268. m_p4->CopyFrom(*rSrc.m_p4);
  269. m_p5->CopyFrom(*rSrc.m_p5);
  270. m_p6->CopyFrom(*rSrc.m_p6);
  271. m_p7->CopyFrom(*rSrc.m_p7);
  272. m_p8->CopyFrom(*rSrc.m_p8);
  273. m_p9->CopyFrom(*rSrc.m_p9);
  275. m_bEmpty = m_p0->IsEmpty() && m_p1->IsEmpty() && m_p2->IsEmpty() &&
  276. m_p3->IsEmpty() && m_p4->IsEmpty() && m_p5->IsEmpty() &&
  277. m_p6->IsEmpty() && m_p7->IsEmpty() && m_p8->IsEmpty() &&
  278. m_p9->IsEmpty();
  279. }
  281. void RemoveAll()
  282. {
  283. m_p0->RemoveAll(); m_p1->RemoveAll(); m_p2->RemoveAll();
  284. m_p3->RemoveAll(); m_p4->RemoveAll(); m_p5->RemoveAll();
  285. m_p6->RemoveAll(); m_p7->RemoveAll(); m_p8->RemoveAll();
  286. m_p9->RemoveAll();
  287. m_bEmpty = TRUE;
  288. }
  290. #ifdef _DEBUG
  291. void DumpOffset(CDumpContext& dc, LPCTSTR pcszOffset)
  292. {
  293. m_p0->DumpOffset(dc, pcszOffset); m_p1->DumpOffset(dc, pcszOffset);
  294. m_p2->DumpOffset(dc, pcszOffset); m_p3->DumpOffset(dc, pcszOffset);
  295. m_p4->DumpOffset(dc, pcszOffset); m_p5->DumpOffset(dc, pcszOffset);
  296. m_p6->DumpOffset(dc, pcszOffset); m_p7->DumpOffset(dc, pcszOffset);
  297. m_p8->DumpOffset(dc, pcszOffset); m_p9->DumpOffset(dc, pcszOffset);
  298. }
  299. #endif
  300. };
  302. //===========================================================================
  303. template<LPCTSTR (* _FuncName)(void) >
  304. class CXTPSyntaxEditLexVariantPtrArrayExT : public CXTPSyntaxEditLexVariantPtrArray
  305. {
  306. public:
  307. CXTPSyntaxEditLexVariantPtrArrayExT() {};
  308. virtual ~CXTPSyntaxEditLexVariantPtrArrayExT(){};
  310. LPCTSTR GetName() const {
  311. return _FuncName();
  312. }
  314. BOOL IsEmpty() const {
  315. return GetSize() == 0;
  316. }
  318. BOOL IfMy(LPCTSTR pcszElementName)
  319. {
  320. int nCmpRes = _tcsicmp(GetName(), pcszElementName);
  321. return (nCmpRes == 0);
  322. }
  324. BOOL AddIfMy(LPCTSTR pcszElementName, const CXTPSyntaxEditLexVariantPtr& ptr)
  325. {
  326. if(IfMy(pcszElementName)) {
  327. Add(ptr);
  328. return TRUE;
  329. }
  330. return FALSE;
  331. }
  333. BOOL AppendIfMy(LPCTSTR pcszElementName, const CXTPSyntaxEditLexVariantPtrArray& ptrAr)
  334. {
  335. if(IfMy(pcszElementName)) {
  336. Append(ptrAr);
  337. return TRUE;
  338. }
  339. return FALSE;
  340. }
  342. CXTPSyntaxEditLexVariantPtrArray* GetIfMy(LPCTSTR pcszElementName)
  343. {
  344. if(IfMy(pcszElementName)) {
  345. return this;
  346. }
  347. return NULL;
  348. }
  350. void CopyFrom(const CXTPSyntaxEditLexVariantPtrArray& rSrc) {
  351. RemoveAll();
  352. Append(rSrc);
  353. }
  354. #ifdef _DEBUG
  355. void DumpOffset(CDumpContext& dc, LPCTSTR pcszOffset)
  356. {
  357. if(IsEmpty()) {
  358. return;
  359. }
  360. #if _MSC_VER > 1100
  361. int nCount = (int)GetSize();
  363. dc << pcszOffset;
  364. dc << GetName() << _T("[") << nCount << _T("]");
  366. for(int i = 0; i < nCount; i++)
  367. {
  368. if(i) {
  369. dc << _T(", ");
  370. }
  372. CXTPSyntaxEditLexVariantPtr ptrV = GetAt(i);
  373. if(ptrV) {
  374. ptrV->Dump(dc);
  375. }
  376. else
  377. {
  378. dc << _T("?<NULL>");
  379. }
  380. }
  381. dc << _T(" n");
  382. #else
  383. UNREFERENCED_PARAMETER(dc);
  384. UNREFERENCED_PARAMETER(pcszOffset);
  385. #endif
  386. }
  387. #endif
  388. };
  389. //===========================================================================
  390. //}}AFX_CODEJOCK_PRIVATE
  392. class CXTPSyntaxEditLexAutomatWordsMap;
  393. class _XTP_EXT_CLASS LA_CHAR_NODE
  394. {
  395. friend class CXTPSyntaxEditLexAutomatWordsMap;
  396. friend class CXTPSyntaxEditLexAutomatMemMan;
  397. public:
  398. //----------------------------------------------------------------
  399. enum NodeFlags {
  400. nfSubWordEnd = 0x0001,
  401. };
  402. //----------------------------------------------------------------
  403. WORD                    wChar;
  404. WORD                    wFlags;
  405. CXTPSyntaxEditLexAutomatWordsMap* pNextMap;
  406. protected:
  407. LA_CHAR_NODE*           pNextNode;
  409. void Clear();
  411. public:
  412. LA_CHAR_NODE();
  413. virtual ~LA_CHAR_NODE();
  415. const LA_CHAR_NODE& operator = (const LA_CHAR_NODE& rSrc);
  417. //void Clear();
  418. };
  419. typedef LA_CHAR_NODE* PLA_CHAR_NODE;
  422. class _XTP_EXT_CLASS CXTPSyntaxEditLexAutomatWordsMap : public CXTPCmdTarget
  423. {
  424. friend class CXTPSyntaxEditLexAutomatMemMan;
  425. public:
  426. CXTPSyntaxEditLexAutomatWordsMap(UINT uHashTableSize = 17);
  427. virtual ~CXTPSyntaxEditLexAutomatWordsMap();
  429. void RemoveAll();
  431. void AddWord(CString strWord, UINT uHashTableSize);
  433. BOOL FindWord(BOOL bMinWord, LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  434.   BOOL bConvertToLowerCase, BOOL bIgnoreCaseDyn) const;
  436. void InitMap(UINT uHashTableSize);
  437. UINT GetHashTableSize();
  439. static UINT AFX_CDECL DivideHTSize(UINT uHashTableSize, UINT uMin = 1);
  440. protected:
  441. static UINT AFX_CDECL PrimeAdjustU_50(UINT uNumber);
  443. BOOL _FindWord(LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  444. WORD wEndFlags, BOOL bConvertToLowerCase,
  445. BOOL bTryToChangeCaseDyn, BOOL bChangeCase = FALSE) const;
  448. WORD _GetChar(LPCTSTR pcszStr, int& rnCharLen) const;
  449. WORD _ChangeCase(WORD wChar) const;
  450. WORD _MakeLower(WORD wChar) const;
  452. void Clear() {
  453. RemoveAll();
  454. };
  456. virtual void OnFinalRelease();
  458. CXTPSyntaxEditLexAutomatWordsMap* pNextFreeObj;
  460. PLA_CHAR_NODE*          m_pHashTable;
  461. UINT                    m_uHashTableSize;
  463. const LA_CHAR_NODE* Lookup(WORD wChar) const;
  465. const LA_CHAR_NODE* SetAt(const LA_CHAR_NODE& newNode);
  466. private:
  468. };
  469. XTP_DEFINE_SMART_PTR_INTERNAL(CXTPSyntaxEditLexAutomatWordsMap)
  471. class _XTP_EXT_CLASS CXTPSyntaxEditLexTagsAutomat
  472. {
  473. public:
  474. CXTPSyntaxEditLexTagsAutomat();
  475. virtual ~CXTPSyntaxEditLexTagsAutomat();
  477. void AddTagsList(CXTPSyntaxEditLexVariantPtrArray* pArTags, BOOL bConvertToLowerCase);
  479. BOOL IsEmpty();
  480. void RemoveAll();
  482. void CopyFrom(const CXTPSyntaxEditLexTagsAutomat& rSrc);
  484. BOOL FindMinWord(LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  485.  BOOL bConvertToLowerCase, BOOL bIgnoreCaseDyn);
  487. BOOL FindMaxWord(LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  488.  BOOL bConvertToLowerCase, BOOL bIgnoreCaseDyn);
  490. protected:
  491. void _AddWords(CXTPSyntaxEditLexAutomatWordsMapPtr& rPtrMap, CStringArray& arTags, BOOL bConvertToLowerCase);
  492. UINT _CalcHashTableSize(int nCount);
  494. BOOL _FindWord(BOOL bMinWord, LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  495. BOOL bConvertToLowerCase, BOOL bIgnoreCaseDyn);
  497. public:
  498. CXTPSyntaxEditLexAutomatWordsMapPtr m_ptrWordsMap;
  499. CXTPSyntaxEditLexAutomatWordsMapPtr m_ptrWordsMap_not;
  500. private:
  501. };
  503. class _XTP_EXT_CLASS CXTPSyntaxEditLexAutomatMemMan : public CXTPCmdTarget
  504. {
  505. public:
  506. CXTPSyntaxEditLexAutomatMemMan();
  507. virtual ~CXTPSyntaxEditLexAutomatMemMan();
  509. CXTPSyntaxEditLexAutomatWordsMap* NewMap(UINT uHashTableSize);
  510. LA_CHAR_NODE*           NewNode();
  511. PLA_CHAR_NODE*          NewHashTable(UINT uSize);
  513. void FreeObject(CXTPSyntaxEditLexAutomatWordsMap* pObj);
  514. void FreeObject(LA_CHAR_NODE* pObj);
  515. void FreeObject(PLA_CHAR_NODE* pObj);
  517. DWORD Lock();
  518. DWORD Unlok();
  520. #ifdef _DEBUG
  521. void Dump(CDumpContext& dc) const;
  522. #endif
  523. UINT m_uAllocatedMaps;
  524. UINT m_uUsedMaps;
  526. UINT m_uAllocatedNodes;
  527. UINT m_uUsedNodes;
  529. UINT m_uAllocatedTables;
  530. UINT m_uUsedTables;
  531. UINT m_uAllocatedTablesBytes;
  532. UINT m_uUsedTablesBytes;
  533. // END DEBUG -----------------------------------
  535. protected:
  536. LONG    m_lLockCount;
  538. void    FreeAll();
  540. struct LA_HASH_TABLE
  541. {
  542. friend class CXTPSyntaxEditLexAutomatMemMan;
  544. UINT            uSize;
  545. //protected:
  546. LA_HASH_TABLE*  pNextFreeObj;
  548. void Clear() {
  549. PLA_CHAR_NODE* pData = GetData();
  550. ::ZeroMemory(pData, uSize*sizeof(PLA_CHAR_NODE*));
  551. }
  553. PLA_CHAR_NODE* GetData() {
  554. return (PLA_CHAR_NODE*) ( ((byte*)this) + GetHeaderSizeB() );
  555. }
  557. static UINT GetHeaderSizeB() {
  558. UINT uHeader = sizeof(LA_HASH_TABLE);
  559. return uHeader;
  560. }
  562. static UINT GetHeaderSize() {
  563. UINT uHeader = GetHeaderSizeB();
  564. UINT uHeader2 = uHeader / sizeof(PLA_CHAR_NODE);
  565. uHeader2 += (uHeader % sizeof(PLA_CHAR_NODE)) ? 1 : 0;
  566. return uHeader2;
  567. }
  569. static LA_HASH_TABLE* GetHeader(PLA_CHAR_NODE* pData) {
  570. return (LA_HASH_TABLE*) ( ((byte*)pData) - GetHeaderSizeB() );
  571. }
  572. };
  574. CXTPSyntaxEditLexAutomatWordsMap* m_pFreeMaps;
  575. LA_CHAR_NODE*   m_pFreeNodes;
  577. LA_HASH_TABLE*  m_pFreeTables;
  579. CList<CXTPSyntaxEditLexAutomatWordsMap*, CXTPSyntaxEditLexAutomatWordsMap*> m_allocatedMaps;
  580. CList<LA_CHAR_NODE*, LA_CHAR_NODE*>         m_allocatedNodes;
  581. CList<PLA_CHAR_NODE*, PLA_CHAR_NODE*>       m_allocatedTables;
  582. };
  584. ////////////////////////////////////////////////////////////////////////////
  585. template<LPCTSTR (* _FuncName)(void) >
  586. class CXTPSyntaxEditLexVariantPtrArrayExAutomatT : public CXTPSyntaxEditLexVariantPtrArrayExT<_FuncName>
  587. {
  588. public:
  589. typedef CXTPSyntaxEditLexVariantPtrArrayExT<_FuncName> TBase;
  590. typedef CXTPSyntaxEditLexVariantPtrArrayExAutomatT<_FuncName> Tthis;
  592. CXTPSyntaxEditLexVariantPtrArrayExAutomatT() {
  593. #ifdef _DEBUG
  594. m_bAutomatWasBuilt = FALSE;
  595. #endif
  596. };
  597. virtual ~CXTPSyntaxEditLexVariantPtrArrayExAutomatT(){};
  599. void BuildAutomat(BOOL bConvertToLowerCase = FALSE)
  600. {
  601. m_automat.RemoveAll();
  602. m_automat.AddTagsList(this, bConvertToLowerCase);
  603. #ifdef _DEBUG
  604. m_bAutomatWasBuilt = TRUE;
  605. #endif
  606. }
  608. void CopyFrom(const Tthis& rSrc) {
  609. TBase::CopyFrom(rSrc);
  610. m_automat.CopyFrom(rSrc.m_automat);
  612. #ifdef _DEBUG
  613. m_bAutomatWasBuilt = rSrc.m_bAutomatWasBuilt;
  614. #endif
  615. }
  617. BOOL FindMinWord(LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  618. BOOL bConvertToLowerCase = FALSE, BOOL bIgnoreCaseDyn = FALSE)
  619. {
  620. ASSERT(m_bAutomatWasBuilt);
  621. return m_automat.FindMinWord(pcszBuffer, rstrWord, nBufSize,
  622. bConvertToLowerCase, bIgnoreCaseDyn);
  623. }
  625. BOOL FindMaxWord(LPCTSTR pcszBuffer, CString& rstrWord, int nBufSize,
  626. BOOL bConvertToLowerCase = FALSE, BOOL bIgnoreCaseDyn = FALSE)
  627. {
  628. ASSERT(m_bAutomatWasBuilt);
  629. return m_automat.FindMaxWord(pcszBuffer, rstrWord, nBufSize,
  630. bConvertToLowerCase, bIgnoreCaseDyn);
  631. }
  633. protected:
  634. CXTPSyntaxEditLexTagsAutomat    m_automat;
  635. #ifdef _DEBUG
  636. BOOL m_bAutomatWasBuilt;
  637. #endif
  638. };
  639. }
  642. ////////////////////////////////////////////////////////////////////////////
  643. //#pragma warning(pop)
  645. #endif // !defined(__XTPSYNTAXEDITLEXCLASSSUBOBJT_H__)