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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
SpString.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：33k
源码类别：

金融证券系统

开发平台：

Visual C++

SpString.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CSPString;
  9. */
  10. #include "StdAfx.h"
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[] = __FILE__;
  15. #endif
  17. #ifdef _DEBUG
  18. #define new DEBUG_NEW
  19. #endif
  21. #ifndef _SP_ENABLE_INLINES
  22. #define _SPSTRING_INLINE
  23. #include "../Include/SpString.inl"
  24. #undef _SPSTRING_INLINE
  25. #endif
  27. /////////////////////////////////////////////////////////////////////////////
  28. // static class data, special inlines
  30. // afxSPChNil is left for backward compatibility
  31. TCHAR afxSPChNil = '';
  33. // For an empty string, m_pchData will point here
  34. // (note: avoids special case of checking for NULL m_pchData)
  35. // empty string data (and locked)
  36. int _afxSPInitData[] = { -1, 0, 0, 0 };
  37. CSPStringData* _afxSPDataNil = (CSPStringData*)&_afxSPInitData;
  38. LPCTSTR _afxSPPchNil = (LPCTSTR)(((BYTE*)&_afxSPInitData)+sizeof(CSPStringData));
  39. // special function to make afxEmptyString work even during initialization
  40. const CSPString& __stdcall AfxGetEmptySPString()
  41. { return *(CSPString*)&_afxSPPchNil; }
  43. //////////////////////////////////////////////////////////////////////////////
  44. // Construction/Destruction
  46. #ifdef _AFXDLL
  47. CSPString::CSPString()
  48. {
  49. Init();
  50. }
  51. #endif
  53. CSPString::CSPString(const CSPString& stringSrc)
  54. {
  55. SP_ASSERT(stringSrc.GetData()->nRefs != 0);
  56. if (stringSrc.GetData()->nRefs >= 0)
  57. {
  58. SP_ASSERT(stringSrc.GetData() != _afxSPDataNil);
  59. m_pchData = stringSrc.m_pchData;
  60. InterlockedIncrement(&GetData()->nRefs);
  61. }
  62. else
  63. {
  64. Init();
  65. *this = stringSrc.m_pchData;
  66. }
  67. }
  69. void CSPString::AllocBuffer(int nLen)
  70. // always allocate one extra character for '' termination
  71. // assumes [optimistically] that data length will equal allocation length
  72. {
  73. SP_ASSERT(nLen >= 0);
  74. SP_ASSERT(nLen <= INT_MAX-1);    // max size (enough room for 1 extra)
  76. if (nLen == 0)
  77. Init();
  78. else
  79. {
  80. CSPStringData* pData;
  81. {
  82. pData = (CSPStringData*)
  83. new BYTE[sizeof(CSPStringData) + (nLen+1)*sizeof(TCHAR)];
  84. pData->nAllocLength = nLen;
  85. }
  86. pData->nRefs = 1;
  87. pData->data()[nLen] = '';
  88. pData->nDataLength = nLen;
  89. m_pchData = pData->data();
  90. }
  91. }
  93. void __fastcall CSPString::FreeData(CSPStringData* pData)
  94. {
  95. delete[] (BYTE*)pData;
  96. }
  98. void CSPString::Release()
  99. {
  100. if (GetData() != _afxSPDataNil)
  101. {
  102. SP_ASSERT(GetData()->nRefs != 0);
  103. if (InterlockedDecrement(&GetData()->nRefs) <= 0)
  104. FreeData(GetData());
  105. Init();
  106. }
  107. }
  109. void PASCAL CSPString::Release(CSPStringData* pData)
  110. {
  111. if (pData != _afxSPDataNil)
  112. {
  113. SP_ASSERT(pData->nRefs != 0);
  114. if (InterlockedDecrement(&pData->nRefs) <= 0)
  115. FreeData(pData);
  116. }
  117. }
  119. void CSPString::Empty()
  120. {
  121. if (GetData()->nDataLength == 0)
  122. return;
  123. if (GetData()->nRefs >= 0)
  124. Release();
  125. else
  126. *this = &afxSPChNil;
  127. SP_ASSERT(GetData()->nDataLength == 0);
  128. SP_ASSERT(GetData()->nRefs < 0 || GetData()->nAllocLength == 0);
  129. }
  131. void CSPString::CopyBeforeWrite()
  132. {
  133. if (GetData()->nRefs > 1)
  134. {
  135. CSPStringData* pData = GetData();
  136. Release();
  137. AllocBuffer(pData->nDataLength);
  138. memcpy(m_pchData, pData->data(), (pData->nDataLength+1)*sizeof(TCHAR));
  139. }
  140. SP_ASSERT(GetData()->nRefs <= 1);
  141. }
  143. void CSPString::AllocBeforeWrite(int nLen)
  144. {
  145. if (GetData()->nRefs > 1 || nLen > GetData()->nAllocLength)
  146. {
  147. Release();
  148. AllocBuffer(nLen);
  149. }
  150. SP_ASSERT(GetData()->nRefs <= 1);
  151. }
  153. CSPString::~CSPString()
  154. //  free any attached data
  155. {
  156. if (GetData() != _afxSPDataNil)
  157. {
  158. if (InterlockedDecrement(&GetData()->nRefs) <= 0)
  159. FreeData(GetData());
  160. }
  161. }
  163. //////////////////////////////////////////////////////////////////////////////
  164. // Helpers for the rest of the implementation
  166. void CSPString::AllocCopy(CSPString& dest, int nCopyLen, int nCopyIndex,
  167.  int nExtraLen) const
  168. {
  169. // will clone the data attached to this string
  170. // allocating 'nExtraLen' characters
  171. // Places results in uninitialized string 'dest'
  172. // Will copy the part or all of original data to start of new string
  174. int nNewLen = nCopyLen + nExtraLen;
  175. if (nNewLen == 0)
  176. {
  177. dest.Init();
  178. }
  179. else
  180. {
  181. dest.AllocBuffer(nNewLen);
  182. memcpy(dest.m_pchData, m_pchData+nCopyIndex, nCopyLen*sizeof(TCHAR));
  183. }
  184. }
  186. //////////////////////////////////////////////////////////////////////////////
  187. // More sophisticated construction
  189. CSPString::CSPString(LPCTSTR lpsz)
  190. {
  191. Init();
  192. if (lpsz != NULL && HIWORD(lpsz) == NULL)
  193. {
  194. UINT nID = LOWORD((DWORD)lpsz);
  195. if (!LoadString(nID))
  196. SP_TRACE1("Warning: implicit LoadString(%u) failedn", nID);
  197. }
  198. else
  199. {
  200. int nLen = SafeStrlen(lpsz);
  201. if (nLen != 0)
  202. {
  203. AllocBuffer(nLen);
  204. memcpy(m_pchData, lpsz, nLen*sizeof(TCHAR));
  205. }
  206. }
  207. }
  209. /////////////////////////////////////////////////////////////////////////////
  210. // Special conversion constructors
  212. #ifdef _UNICODE
  213. CSPString::CSPString(LPCSTR lpsz)
  214. {
  215. Init();
  216. int nSrcLen = lpsz != NULL ? lstrlenA(lpsz) : 0;
  217. if (nSrcLen != 0)
  218. {
  219. AllocBuffer(nSrcLen);
  220. mbstowcs(m_pchData, lpsz, nSrcLen+1);
  221. ReleaseBuffer();
  222. }
  223. }
  224. #else //_UNICODE
  225. CSPString::CSPString(LPCWSTR lpsz)
  226. {
  227. Init();
  228. int nSrcLen = lpsz != NULL ? wcslen(lpsz) : 0;
  229. if (nSrcLen != 0)
  230. {
  231. AllocBuffer(nSrcLen*2);
  232. wcstombs(m_pchData, lpsz, (nSrcLen*2)+1);
  233. ReleaseBuffer();
  234. }
  235. }
  236. #endif //!_UNICODE
  238. //////////////////////////////////////////////////////////////////////////////
  239. // Assignment operators
  240. //  All assign a new value to the string
  241. //      (a) first see if the buffer is big enough
  242. //      (b) if enough room, copy on top of old buffer, set size and type
  243. //      (c) otherwise free old string data, and create a new one
  244. //
  245. //  All routines return the new string (but as a 'const CSPString&' so that
  246. //      assigning it again will cause a copy, eg: s1 = s2 = "hi there".
  247. //
  249. void CSPString::AssignCopy(int nSrcLen, LPCTSTR lpszSrcData)
  250. {
  251. AllocBeforeWrite(nSrcLen);
  252. memcpy(m_pchData, lpszSrcData, nSrcLen*sizeof(TCHAR));
  253. GetData()->nDataLength = nSrcLen;
  254. m_pchData[nSrcLen] = '';
  255. }
  257. const CSPString& CSPString::operator=(const CSPString& stringSrc)
  258. {
  259. if (m_pchData != stringSrc.m_pchData)
  260. {
  261. if ((GetData()->nRefs < 0 && GetData() != _afxSPDataNil) ||
  262. stringSrc.GetData()->nRefs < 0)
  263. {
  264. // actual copy necessary since one of the strings is locked
  265. AssignCopy(stringSrc.GetData()->nDataLength, stringSrc.m_pchData);
  266. }
  267. else
  268. {
  269. // can just copy references around
  270. Release();
  271. SP_ASSERT(stringSrc.GetData() != _afxSPDataNil);
  272. m_pchData = stringSrc.m_pchData;
  273. InterlockedIncrement(&GetData()->nRefs);
  274. }
  275. }
  276. return *this;
  277. }
  279. const CSPString& CSPString::operator=(LPCTSTR lpsz)
  280. {
  281. SP_ASSERT(lpsz == NULL || SP_IsValidString(lpsz));
  282. AssignCopy(SafeStrlen(lpsz), lpsz);
  283. return *this;
  284. }
  286. /////////////////////////////////////////////////////////////////////////////
  287. // Special conversion assignment
  289. #ifdef _UNICODE
  290. const CSPString& CSPString::operator=(LPCSTR lpsz)
  291. {
  292. int nSrcLen = lpsz != NULL ? lstrlenA(lpsz) : 0;
  293. AllocBeforeWrite(nSrcLen);
  294. mbstowcs(m_pchData, lpsz, nSrcLen+1);
  295. ReleaseBuffer();
  296. return *this;
  297. }
  298. #else //!_UNICODE
  299. const CSPString& CSPString::operator=(LPCWSTR lpsz)
  300. {
  301. int nSrcLen = lpsz != NULL ? wcslen(lpsz) : 0;
  302. AllocBeforeWrite(nSrcLen*2);
  303. wcstombs(m_pchData, lpsz, (nSrcLen*2)+1);
  304. ReleaseBuffer();
  305. return *this;
  306. }
  307. #endif  //!_UNICODE
  309. //////////////////////////////////////////////////////////////////////////////
  310. // concatenation
  312. // NOTE: "operator+" is done as friend functions for simplicity
  313. //      There are three variants:
  314. //          CSPString + CSPString
  315. // and for ? = TCHAR, LPCTSTR
  316. //          CSPString + ?
  317. //          ? + CSPString
  319. void CSPString::ConcatCopy(int nSrc1Len, LPCTSTR lpszSrc1Data,
  320. int nSrc2Len, LPCTSTR lpszSrc2Data)
  321. {
  322.   // -- master concatenation routine
  323.   // Concatenate two sources
  324.   // -- assume that 'this' is a new CSPString object
  326. int nNewLen = nSrc1Len + nSrc2Len;
  327. if (nNewLen != 0)
  328. {
  329. AllocBuffer(nNewLen);
  330. memcpy(m_pchData, lpszSrc1Data, nSrc1Len*sizeof(TCHAR));
  331. memcpy(m_pchData+nSrc1Len, lpszSrc2Data, nSrc2Len*sizeof(TCHAR));
  332. }
  333. }
  335. CSPString __stdcall operator+(const CSPString& string1, const CSPString& string2)
  336. {
  337. CSPString s;
  338. s.ConcatCopy(string1.GetData()->nDataLength, string1.m_pchData,
  339. string2.GetData()->nDataLength, string2.m_pchData);
  340. return s;
  341. }
  343. CSPString __stdcall operator+(const CSPString& string, LPCTSTR lpsz)
  344. {
  345. SP_ASSERT(lpsz == NULL || SP_IsValidString(lpsz));
  346. CSPString s;
  347. s.ConcatCopy(string.GetData()->nDataLength, string.m_pchData,
  348. CSPString::SafeStrlen(lpsz), lpsz);
  349. return s;
  350. }
  352. CSPString __stdcall operator+(LPCTSTR lpsz, const CSPString& string)
  353. {
  354. SP_ASSERT(lpsz == NULL || SP_IsValidString(lpsz));
  355. CSPString s;
  356. s.ConcatCopy(CSPString::SafeStrlen(lpsz), lpsz, string.GetData()->nDataLength,
  357. string.m_pchData);
  358. return s;
  359. }
  361. //////////////////////////////////////////////////////////////////////////////
  362. // concatenate in place
  364. void CSPString::ConcatInPlace(int nSrcLen, LPCTSTR lpszSrcData)
  365. {
  366. //  -- the main routine for += operators
  368. // concatenating an empty string is a no-op!
  369. if (nSrcLen == 0)
  370. return;
  372. // if the buffer is too small, or we have a width mis-match, just
  373. //   allocate a new buffer (slow but sure)
  374. if (GetData()->nRefs > 1 || GetData()->nDataLength + nSrcLen > GetData()->nAllocLength)
  375. {
  376. // we have to grow the buffer, use the ConcatCopy routine
  377. CSPStringData* pOldData = GetData();
  378. ConcatCopy(GetData()->nDataLength, m_pchData, nSrcLen, lpszSrcData);
  379. SP_ASSERT(pOldData != NULL);
  380. CSPString::Release(pOldData);
  381. }
  382. else
  383. {
  384. // fast concatenation when buffer big enough
  385. memcpy(m_pchData+GetData()->nDataLength, lpszSrcData, nSrcLen*sizeof(TCHAR));
  386. GetData()->nDataLength += nSrcLen;
  387. SP_ASSERT(GetData()->nDataLength <= GetData()->nAllocLength);
  388. m_pchData[GetData()->nDataLength] = '';
  389. }
  390. }
  392. const CSPString& CSPString::operator+=(LPCTSTR lpsz)
  393. {
  394. SP_ASSERT(lpsz == NULL || SP_IsValidString(lpsz));
  395. ConcatInPlace(SafeStrlen(lpsz), lpsz);
  396. return *this;
  397. }
  399. const CSPString& CSPString::operator+=(TCHAR ch)
  400. {
  401. ConcatInPlace(1, &ch);
  402. return *this;
  403. }
  405. const CSPString& CSPString::operator+=(const CSPString& string)
  406. {
  407. ConcatInPlace(string.GetData()->nDataLength, string.m_pchData);
  408. return *this;
  409. }
  411. ///////////////////////////////////////////////////////////////////////////////
  412. // Advanced direct buffer access
  414. LPTSTR CSPString::GetBuffer(int nMinBufLength)
  415. {
  416. SP_ASSERT(nMinBufLength >= 0);
  418. if (GetData()->nRefs > 1 || nMinBufLength > GetData()->nAllocLength)
  419. {
  420. #ifdef _DEBUG
  421. // give a warning in case locked string becomes unlocked
  422. if (GetData() != _afxSPDataNil && GetData()->nRefs < 0)
  423. SP_TRACE0("Warning: GetBuffer on locked CSPString creates unlocked CSPString!n");
  424. #endif
  425. // we have to grow the buffer
  426. CSPStringData* pOldData = GetData();
  427. int nOldLen = GetData()->nDataLength;   // AllocBuffer will tromp it
  428. if (nMinBufLength < nOldLen)
  429. nMinBufLength = nOldLen;
  430. AllocBuffer(nMinBufLength);
  431. memcpy(m_pchData, pOldData->data(), (nOldLen+1)*sizeof(TCHAR));
  432. GetData()->nDataLength = nOldLen;
  433. CSPString::Release(pOldData);
  434. }
  435. SP_ASSERT(GetData()->nRefs <= 1);
  437. // return a pointer to the character storage for this string
  438. SP_ASSERT(m_pchData != NULL);
  439. return m_pchData;
  440. }
  442. void CSPString::ReleaseBuffer(int nNewLength)
  443. {
  444. CopyBeforeWrite();  // just in case GetBuffer was not called
  446. if (nNewLength == -1)
  447. nNewLength = lstrlen(m_pchData); // zero terminated
  449. SP_ASSERT(nNewLength <= GetData()->nAllocLength);
  450. GetData()->nDataLength = nNewLength;
  451. m_pchData[nNewLength] = '';
  452. }
  454. LPTSTR CSPString::GetBufferSetLength(int nNewLength)
  455. {
  456. SP_ASSERT(nNewLength >= 0);
  458. GetBuffer(nNewLength);
  459. GetData()->nDataLength = nNewLength;
  460. m_pchData[nNewLength] = '';
  461. return m_pchData;
  462. }
  464. void CSPString::FreeExtra()
  465. {
  466. SP_ASSERT(GetData()->nDataLength <= GetData()->nAllocLength);
  467. if (GetData()->nDataLength != GetData()->nAllocLength)
  468. {
  469. CSPStringData* pOldData = GetData();
  470. AllocBuffer(GetData()->nDataLength);
  471. memcpy(m_pchData, pOldData->data(), pOldData->nDataLength*sizeof(TCHAR));
  472. SP_ASSERT(m_pchData[GetData()->nDataLength] == '');
  473. CSPString::Release(pOldData);
  474. }
  475. SP_ASSERT(GetData() != NULL);
  476. }
  478. LPTSTR CSPString::LockBuffer()
  479. {
  480. LPTSTR lpsz = GetBuffer(0);
  481. GetData()->nRefs = -1;
  482. return lpsz;
  483. }
  485. void CSPString::UnlockBuffer()
  486. {
  487. SP_ASSERT(GetData()->nRefs == -1);
  488. if (GetData() != _afxSPDataNil)
  489. GetData()->nRefs = 1;
  490. }
  492. ///////////////////////////////////////////////////////////////////////////////
  493. // Commonly used routines (rarely used routines in STREX.CPP)
  495. int CSPString::Find(TCHAR ch) const
  496. {
  497. return Find(ch, 0);
  498. }
  500. int CSPString::Find(TCHAR ch, int nStart) const
  501. {
  502. int nLength = GetData()->nDataLength;
  503. if (nStart >= nLength)
  504. return -1;
  506. // find first single character
  507. LPTSTR lpsz = _tcschr(m_pchData + nStart, ch);
  509. // return -1 if not found and index otherwise
  510. return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
  511. }
  513. int CSPString::FindOneOf(LPCTSTR lpszCharSet) const
  514. {
  515. SP_ASSERT(SP_IsValidString(lpszCharSet));
  516. LPTSTR lpsz = _tcspbrk(m_pchData, lpszCharSet);
  517. return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
  518. }
  520. void CSPString::MakeUpper()
  521. {
  522. CopyBeforeWrite();
  523. _tcsupr(m_pchData);
  524. }
  526. void CSPString::MakeLower()
  527. {
  528. CopyBeforeWrite();
  529. _tcslwr(m_pchData);
  530. }
  532. void CSPString::MakeReverse()
  533. {
  534. CopyBeforeWrite();
  535. _tcsrev(m_pchData);
  536. }
  538. void CSPString::SetAt(int nIndex, TCHAR ch)
  539. {
  540. SP_ASSERT(nIndex >= 0);
  541. SP_ASSERT(nIndex < GetData()->nDataLength);
  543. CopyBeforeWrite();
  544. m_pchData[nIndex] = ch;
  545. }
  547. ///////////////////////////////////////////////////////////////////////////////
  549. //////////////////////////////////////////////////////////////////////////////
  550. // More sophisticated construction
  552. CSPString::CSPString(TCHAR ch, int nLength)
  553. {
  554. Init();
  555. if (nLength >= 1)
  556. {
  557. AllocBuffer(nLength);
  558. #ifdef _UNICODE
  559. for (int i = 0; i < nLength; i++)
  560. m_pchData[i] = ch;
  561. #else
  562. memset(m_pchData, ch, nLength);
  563. #endif
  564. }
  565. }
  567. CSPString::CSPString(LPCTSTR lpch, int nLength)
  568. {
  569. Init();
  570. if (nLength != 0)
  571. {
  572. SP_ASSERT(SP_IsValidAddress((void*)lpch, nLength, FALSE));
  573. AllocBuffer(nLength);
  574. memcpy(m_pchData, lpch, nLength*sizeof(TCHAR));
  575. }
  576. }
  578. /////////////////////////////////////////////////////////////////////////////
  579. // Special conversion constructors
  581. #ifdef _UNICODE
  582. CSPString::CSPString(LPCSTR lpsz, int nLength)
  583. {
  584. Init();
  585. if (nLength != 0)
  586. {
  587. AllocBuffer(nLength);
  588. int n = ::MultiByteToWideChar(CP_ACP, 0, lpsz, nLength, m_pchData, nLength+1);
  589. ReleaseBuffer(n >= 0 ? n : -1);
  590. }
  591. }
  592. #else //_UNICODE
  593. CSPString::CSPString(LPCWSTR lpsz, int nLength)
  594. {
  595. Init();
  596. if (nLength != 0)
  597. {
  598. AllocBuffer(nLength*2);
  599. int n = ::WideCharToMultiByte(CP_ACP, 0, lpsz, nLength, m_pchData,
  600. (nLength*2)+1, NULL, NULL);
  601. ReleaseBuffer(n >= 0 ? n : -1);
  602. }
  603. }
  604. #endif //!_UNICODE
  606. //////////////////////////////////////////////////////////////////////////////
  607. // Assignment operators
  609. const CSPString& CSPString::operator=(TCHAR ch)
  610. {
  611. AssignCopy(1, &ch);
  612. return *this;
  613. }
  615. //////////////////////////////////////////////////////////////////////////////
  616. // less common string expressions
  618. CSPString __stdcall operator+(const CSPString& string1, TCHAR ch)
  619. {
  620. CSPString s;
  621. s.ConcatCopy(string1.GetData()->nDataLength, string1.m_pchData, 1, &ch);
  622. return s;
  623. }
  625. CSPString __stdcall operator+(TCHAR ch, const CSPString& string)
  626. {
  627. CSPString s;
  628. s.ConcatCopy(1, &ch, string.GetData()->nDataLength, string.m_pchData);
  629. return s;
  630. }
  632. //////////////////////////////////////////////////////////////////////////////
  633. // Advanced manipulation
  635. int CSPString::Delete(int nIndex, int nCount /* = 1 */)
  636. {
  637. if (nIndex < 0)
  638. nIndex = 0;
  639. int nNewLength = GetData()->nDataLength;
  640. if (nCount > 0 && nIndex < nNewLength)
  641. {
  642. CopyBeforeWrite();
  643. int nBytesToCopy = nNewLength - (nIndex + nCount) + 1;
  645. memcpy(m_pchData + nIndex,
  646. m_pchData + nIndex + nCount, nBytesToCopy * sizeof(TCHAR));
  647. GetData()->nDataLength = nNewLength - nCount;
  648. }
  650. return nNewLength;
  651. }
  653. int CSPString::Insert(int nIndex, TCHAR ch)
  654. {
  655. CopyBeforeWrite();
  657. if (nIndex < 0)
  658. nIndex = 0;
  660. int nNewLength = GetData()->nDataLength;
  661. if (nIndex > nNewLength)
  662. nIndex = nNewLength;
  663. nNewLength++;
  665. if (GetData()->nAllocLength < nNewLength)
  666. {
  667. CSPStringData* pOldData = GetData();
  668. LPTSTR pstr = m_pchData;
  669. AllocBuffer(nNewLength);
  670. memcpy(m_pchData, pstr, (pOldData->nDataLength+1)*sizeof(TCHAR));
  671. CSPString::Release(pOldData);
  672. }
  674. // move existing bytes down
  675. memcpy(m_pchData + nIndex + 1,
  676. m_pchData + nIndex, (nNewLength-nIndex)*sizeof(TCHAR));
  677. m_pchData[nIndex] = ch;
  678. GetData()->nDataLength = nNewLength;
  680. return nNewLength;
  681. }
  683. int CSPString::Insert(int nIndex, LPCTSTR pstr)
  684. {
  685. if (nIndex < 0)
  686. nIndex = 0;
  688. int nInsertLength = SafeStrlen(pstr);
  689. int nNewLength = GetData()->nDataLength;
  690. if (nInsertLength > 0)
  691. {
  692. CopyBeforeWrite();
  693. if (nIndex > nNewLength)
  694. nIndex = nNewLength;
  695. nNewLength += nInsertLength;
  697. if (GetData()->nAllocLength < nNewLength)
  698. {
  699. CSPStringData* pOldData = GetData();
  700. LPTSTR pstr = m_pchData;
  701. AllocBuffer(nNewLength);
  702. memcpy(m_pchData, pstr, (pOldData->nDataLength+1)*sizeof(TCHAR));
  703. CSPString::Release(pOldData);
  704. }
  706. // move existing bytes down
  707. memcpy(m_pchData + nIndex + nInsertLength,
  708. m_pchData + nIndex,
  709. (nNewLength-nIndex-nInsertLength+1)*sizeof(TCHAR));
  710. memcpy(m_pchData + nIndex,
  711. pstr, nInsertLength*sizeof(TCHAR));
  712. GetData()->nDataLength = nNewLength;
  713. }
  715. return nNewLength;
  716. }
  718. int CSPString::Replace(TCHAR chOld, TCHAR chNew)
  719. {
  720. int nCount = 0;
  722. // short-circuit the nop case
  723. if (chOld != chNew)
  724. {
  725. // otherwise modify each character that matches in the string
  726. CopyBeforeWrite();
  727. LPTSTR psz = m_pchData;
  728. LPTSTR pszEnd = psz + GetData()->nDataLength;
  729. while (psz < pszEnd)
  730. {
  731. // replace instances of the specified character only
  732. if (*psz == chOld)
  733. {
  734. *psz = chNew;
  735. nCount++;
  736. }
  737. psz = _tcsinc(psz);
  738. }
  739. }
  740. return nCount;
  741. }
  743. int CSPString::Replace(LPCTSTR lpszOld, LPCTSTR lpszNew)
  744. {
  745. // can't have empty or NULL lpszOld
  747. int nSourceLen = SafeStrlen(lpszOld);
  748. if (nSourceLen == 0)
  749. return 0;
  750. int nReplacementLen = SafeStrlen(lpszNew);
  752. // loop once to figure out the size of the result string
  753. int nCount = 0;
  754. LPTSTR lpszStart = m_pchData;
  755. LPTSTR lpszEnd = m_pchData + GetData()->nDataLength;
  756. LPTSTR lpszTarget;
  757. while (lpszStart < lpszEnd)
  758. {
  759. while ((lpszTarget = _tcsstr(lpszStart, lpszOld)) != NULL)
  760. {
  761. nCount++;
  762. lpszStart = lpszTarget + nSourceLen;
  763. }
  764. lpszStart += lstrlen(lpszStart) + 1;
  765. }
  767. // if any changes were made, make them
  768. if (nCount > 0)
  769. {
  770. CopyBeforeWrite();
  772. // if the buffer is too small, just
  773. //   allocate a new buffer (slow but sure)
  774. int nOldLength = GetData()->nDataLength;
  775. int nNewLength =  nOldLength + (nReplacementLen-nSourceLen)*nCount;
  776. if (GetData()->nAllocLength < nNewLength || GetData()->nRefs > 1)
  777. {
  778. CSPStringData* pOldData = GetData();
  779. LPTSTR pstr = m_pchData;
  780. AllocBuffer(nNewLength);
  781. memcpy(m_pchData, pstr, pOldData->nDataLength*sizeof(TCHAR));
  782. CSPString::Release(pOldData);
  783. }
  784. // else, we just do it in-place
  785. lpszStart = m_pchData;
  786. lpszEnd = m_pchData + GetData()->nDataLength;
  788. // loop again to actually do the work
  789. while (lpszStart < lpszEnd)
  790. {
  791. while ( (lpszTarget = _tcsstr(lpszStart, lpszOld)) != NULL)
  792. {
  793. int nBalance = nOldLength - (lpszTarget - m_pchData + nSourceLen);
  794. memmove(lpszTarget + nReplacementLen, lpszTarget + nSourceLen,
  795. nBalance * sizeof(TCHAR));
  796. memcpy(lpszTarget, lpszNew, nReplacementLen*sizeof(TCHAR));
  797. lpszStart = lpszTarget + nReplacementLen;
  798. lpszStart[nBalance] = '';
  799. nOldLength += (nReplacementLen - nSourceLen);
  800. }
  801. lpszStart += lstrlen(lpszStart) + 1;
  802. }
  803. SP_ASSERT(m_pchData[nNewLength] == '');
  804. GetData()->nDataLength = nNewLength;
  805. }
  807. return nCount;
  808. }
  810. int CSPString::Remove(TCHAR chRemove)
  811. {
  812. CopyBeforeWrite();
  814. LPTSTR pstrSource = m_pchData;
  815. LPTSTR pstrDest = m_pchData;
  816. LPTSTR pstrEnd = m_pchData + GetData()->nDataLength;
  818. while (pstrSource < pstrEnd)
  819. {
  820. if (*pstrSource != chRemove)
  821. {
  822. *pstrDest = *pstrSource;
  823. pstrDest = _tcsinc(pstrDest);
  824. }
  825. pstrSource = _tcsinc(pstrSource);
  826. }
  827. *pstrDest = '';
  828. int nCount = pstrSource - pstrDest;
  829. GetData()->nDataLength -= nCount;
  831. return nCount;
  832. }
  834. //////////////////////////////////////////////////////////////////////////////
  835. // Very simple sub-string extraction
  837. CSPString CSPString::Mid(int nFirst) const
  838. {
  839. return Mid(nFirst, GetData()->nDataLength - nFirst);
  840. }
  842. CSPString CSPString::Mid(int nFirst, int nCount) const
  843. {
  844. // out-of-bounds requests return sensible things
  845. if (nFirst < 0)
  846. nFirst = 0;
  847. if (nCount < 0)
  848. nCount = 0;
  850. if (nFirst + nCount > GetData()->nDataLength)
  851. nCount = GetData()->nDataLength - nFirst;
  852. if (nFirst > GetData()->nDataLength)
  853. nCount = 0;
  855. SP_ASSERT(nFirst >= 0);
  856. SP_ASSERT(nFirst + nCount <= GetData()->nDataLength);
  858. // optimize case of returning entire string
  859. if (nFirst == 0 && nFirst + nCount == GetData()->nDataLength)
  860. return *this;
  862. CSPString dest;
  863. AllocCopy(dest, nCount, nFirst, 0);
  864. return dest;
  865. }
  867. CSPString CSPString::Right(int nCount) const
  868. {
  869. if (nCount < 0)
  870. nCount = 0;
  871. if (nCount >= GetData()->nDataLength)
  872. return *this;
  874. CSPString dest;
  875. AllocCopy(dest, nCount, GetData()->nDataLength-nCount, 0);
  876. return dest;
  877. }
  879. CSPString CSPString::Left(int nCount) const
  880. {
  881. if (nCount < 0)
  882. nCount = 0;
  883. if (nCount >= GetData()->nDataLength)
  884. return *this;
  886. CSPString dest;
  887. AllocCopy(dest, nCount, 0, 0);
  888. return dest;
  889. }
  891. // strspn equivalent
  892. CSPString CSPString::SpanIncluding(LPCTSTR lpszCharSet) const
  893. {
  894. SP_ASSERT(SP_IsValidString(lpszCharSet));
  895. return Left(_tcsspn(m_pchData, lpszCharSet));
  896. }
  898. // strcspn equivalent
  899. CSPString CSPString::SpanExcluding(LPCTSTR lpszCharSet) const
  900. {
  901. SP_ASSERT(SP_IsValidString(lpszCharSet));
  902. return Left(_tcscspn(m_pchData, lpszCharSet));
  903. }
  905. //////////////////////////////////////////////////////////////////////////////
  906. // Finding
  908. int CSPString::ReverseFind(TCHAR ch) const
  909. {
  910. // find last single character
  911. LPTSTR lpsz = _tcsrchr(m_pchData, (_TUCHAR) ch);
  913. // return -1 if not found, distance from beginning otherwise
  914. return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
  915. }
  917. // find a sub-string (like strstr)
  918. int CSPString::Find(LPCTSTR lpszSub) const
  919. {
  920. return Find(lpszSub, 0);
  921. }
  923. int CSPString::Find(LPCTSTR lpszSub, int nStart) const
  924. {
  925. SP_ASSERT(SP_IsValidString(lpszSub));
  927. int nLength = GetData()->nDataLength;
  928. if (nStart > nLength)
  929. return -1;
  931. // find first matching substring
  932. LPTSTR lpsz = _tcsstr(m_pchData + nStart, lpszSub);
  934. // return -1 for not found, distance from beginning otherwise
  935. return (lpsz == NULL) ? -1 : (int)(lpsz - m_pchData);
  936. }
  939. /////////////////////////////////////////////////////////////////////////////
  940. // CSPString formatting
  942. #define TCHAR_ARG   TCHAR
  943. #define WCHAR_ARG   WCHAR
  944. #define CHAR_ARG    char
  946. struct _AFX_DOUBLE  { BYTE doubleBits[sizeof(double)]; };
  947. struct _AFX_FLOAT   { BYTE floatBits[sizeof(float)]; };
  949. #ifdef _X86_
  950. #define DOUBLE_ARG  _AFX_DOUBLE
  951. #else
  952. #define DOUBLE_ARG  double
  953. #endif
  955. #define FORCE_ANSI      0x10000
  956. #define FORCE_UNICODE   0x20000
  957. #define FORCE_INT64     0x40000
  959. void CSPString::FormatV(LPCTSTR lpszFormat, va_list argList)
  960. {
  961. SP_ASSERT(SP_IsValidString(lpszFormat));
  963. va_list argListSave = argList;
  965. // make a guess at the maximum length of the resulting string
  966. int nMaxLen = 0;
  967. for (LPCTSTR lpsz = lpszFormat; *lpsz != ''; lpsz = _tcsinc(lpsz))
  968. {
  969. // handle '%' character, but watch out for '%%'
  970. if (*lpsz != '%' || *(lpsz = _tcsinc(lpsz)) == '%')
  971. {
  972. nMaxLen += _tclen(lpsz);
  973. continue;
  974. }
  976. int nItemLen = 0;
  978. // handle '%' character with format
  979. int nWidth = 0;
  980. for (; *lpsz != ''; lpsz = _tcsinc(lpsz))
  981. {
  982. // check for valid flags
  983. if (*lpsz == '#')
  984. nMaxLen += 2;   // for '0x'
  985. else if (*lpsz == '*')
  986. nWidth = va_arg(argList, int);
  987. else if (*lpsz == '-' || *lpsz == '+' || *lpsz == '0' ||
  988. *lpsz == ' ')
  989. ;
  990. else // hit non-flag character
  991. break;
  992. }
  993. // get width and skip it
  994. if (nWidth == 0)
  995. {
  996. // width indicated by
  997. nWidth = _ttoi(lpsz);
  998. for (; *lpsz != '' && _istdigit(*lpsz); lpsz = _tcsinc(lpsz))
  999. ;
  1000. }
  1001. SP_ASSERT(nWidth >= 0);
  1003. int nPrecision = 0;
  1004. if (*lpsz == '.')
  1005. {
  1006. // skip past '.' separator (width.precision)
  1007. lpsz = _tcsinc(lpsz);
  1009. // get precision and skip it
  1010. if (*lpsz == '*')
  1011. {
  1012. nPrecision = va_arg(argList, int);
  1013. lpsz = _tcsinc(lpsz);
  1014. }
  1015. else
  1016. {
  1017. nPrecision = _ttoi(lpsz);
  1018. for (; *lpsz != '' && _istdigit(*lpsz); lpsz = _tcsinc(lpsz))
  1019. ;
  1020. }
  1021. SP_ASSERT(nPrecision >= 0);
  1022. }
  1024. // should be on type modifier or specifier
  1025. int nModifier = 0;
  1026. if (_tcsncmp(lpsz, _T("I64"), 3) == 0)
  1027. {
  1028. lpsz += 3;
  1029. nModifier = FORCE_INT64;
  1030. #if !defined(_X86_) && !defined(_ALPHA_)
  1031. // __int64 is only available on X86 and ALPHA platforms
  1032. SP_ASSERT(FALSE);
  1033. #endif
  1034. }
  1035. else
  1036. {
  1037. switch (*lpsz)
  1038. {
  1039. // modifiers that affect size
  1040. case 'h':
  1041. nModifier = FORCE_ANSI;
  1042. lpsz = _tcsinc(lpsz);
  1043. break;
  1044. case 'l':
  1045. nModifier = FORCE_UNICODE;
  1046. lpsz = _tcsinc(lpsz);
  1047. break;
  1049. // modifiers that do not affect size
  1050. case 'F':
  1051. case 'N':
  1052. case 'L':
  1053. lpsz = _tcsinc(lpsz);
  1054. break;
  1055. }
  1056. }
  1058. // now should be on specifier
  1059. switch (*lpsz | nModifier)
  1060. {
  1061. // single characters
  1062. case 'c':
  1063. case 'C':
  1064. nItemLen = 2;
  1065. va_arg(argList, TCHAR_ARG);
  1066. break;
  1067. case 'c'|FORCE_ANSI:
  1068. case 'C'|FORCE_ANSI:
  1069. nItemLen = 2;
  1070. va_arg(argList, CHAR_ARG);
  1071. break;
  1072. case 'c'|FORCE_UNICODE:
  1073. case 'C'|FORCE_UNICODE:
  1074. nItemLen = 2;
  1075. va_arg(argList, WCHAR_ARG);
  1076. break;
  1078. // strings
  1079. case 's':
  1080. {
  1081. LPCTSTR pstrNextArg = va_arg(argList, LPCTSTR);
  1082. if (pstrNextArg == NULL)
  1083.    nItemLen = 6;  // "(null)"
  1084. else
  1085. {
  1086.    nItemLen = lstrlen(pstrNextArg);
  1087.    nItemLen = max(1, nItemLen);
  1088. }
  1089. }
  1090. break;
  1092. case 'S':
  1093. {
  1094. #ifndef _UNICODE
  1095. LPWSTR pstrNextArg = va_arg(argList, LPWSTR);
  1096. if (pstrNextArg == NULL)
  1097.    nItemLen = 6;  // "(null)"
  1098. else
  1099. {
  1100.    nItemLen = wcslen(pstrNextArg);
  1101.    nItemLen = max(1, nItemLen);
  1102. }
  1103. #else
  1104. LPCSTR pstrNextArg = va_arg(argList, LPCSTR);
  1105. if (pstrNextArg == NULL)
  1106.    nItemLen = 6; // "(null)"
  1107. else
  1108. {
  1109.    nItemLen = lstrlenA(pstrNextArg);
  1110.    nItemLen = max(1, nItemLen);
  1111. }
  1112. #endif
  1113. }
  1114. break;
  1116. case 's'|FORCE_ANSI:
  1117. case 'S'|FORCE_ANSI:
  1118. {
  1119. LPCSTR pstrNextArg = va_arg(argList, LPCSTR);
  1120. if (pstrNextArg == NULL)
  1121.    nItemLen = 6; // "(null)"
  1122. else
  1123. {
  1124.    nItemLen = lstrlenA(pstrNextArg);
  1125.    nItemLen = max(1, nItemLen);
  1126. }
  1127. }
  1128. break;
  1130. case 's'|FORCE_UNICODE:
  1131. case 'S'|FORCE_UNICODE:
  1132. {
  1133. LPWSTR pstrNextArg = va_arg(argList, LPWSTR);
  1134. if (pstrNextArg == NULL)
  1135.    nItemLen = 6; // "(null)"
  1136. else
  1137. {
  1138.    nItemLen = wcslen(pstrNextArg);
  1139.    nItemLen = max(1, nItemLen);
  1140. }
  1141. }
  1142. break;
  1143. }
  1145. // adjust nItemLen for strings
  1146. if (nItemLen != 0)
  1147. {
  1148. if (nPrecision != 0)
  1149. nItemLen = min(nItemLen, nPrecision);
  1150. nItemLen = max(nItemLen, nWidth);
  1151. }
  1152. else
  1153. {
  1154. switch (*lpsz)
  1155. {
  1156. // integers
  1157. case 'd':
  1158. case 'i':
  1159. case 'u':
  1160. case 'x':
  1161. case 'X':
  1162. case 'o':
  1163. if (nModifier & FORCE_INT64)
  1164. va_arg(argList, __int64);
  1165. else
  1166. va_arg(argList, int);
  1167. nItemLen = 32;
  1168. nItemLen = max(nItemLen, nWidth+nPrecision);
  1169. break;
  1171. case 'e':
  1172. case 'g':
  1173. case 'G':
  1174. va_arg(argList, DOUBLE_ARG);
  1175. nItemLen = 128;
  1176. nItemLen = max(nItemLen, nWidth+nPrecision);
  1177. break;
  1179. case 'f':
  1180. va_arg(argList, DOUBLE_ARG);
  1181. nItemLen = 128; // width isn't truncated
  1182. // 312 == strlen("-1+(309 zeroes).")
  1183. // 309 zeroes == max precision of a double
  1184. nItemLen = max(nItemLen, 312+nPrecision);
  1185. break;
  1187. case 'p':
  1188. va_arg(argList, void*);
  1189. nItemLen = 32;
  1190. nItemLen = max(nItemLen, nWidth+nPrecision);
  1191. break;
  1193. // no output
  1194. case 'n':
  1195. va_arg(argList, int*);
  1196. break;
  1198. default:
  1199. SP_ASSERT(FALSE);  // unknown formatting option
  1200. }
  1201. }
  1203. // adjust nMaxLen for output nItemLen
  1204. nMaxLen += nItemLen;
  1205. }
  1207. GetBuffer(nMaxLen);
  1208. SP_VERIFY(_vstprintf(m_pchData, lpszFormat, argListSave) <= GetAllocLength());
  1209. ReleaseBuffer();
  1211. va_end(argListSave);
  1212. }
  1214. /* My Version
  1215. // formatting (using wsprintf style formatting)
  1216. void __cdecl CSPString::Format(LPCTSTR lpszFormat, ...)
  1217. {
  1218. // 暂不支持较长字符串
  1219. SP_ASSERT( NULL != lpszFormat && strlen(lpszFormat) < 1024 );
  1220. size_t nSize = 1024+4*strlen(lpszFormat);
  1221. TCHAR * lpBuf = new TCHAR[nSize];
  1223. va_list argList;
  1224. va_start(argList, lpszFormat);
  1225. vsprintf( lpBuf, lpszFormat, argList);
  1226. va_end(argList);
  1228. *this = lpBuf;
  1229. delete [] lpBuf;
  1230. }
  1231. */
  1233. // formatting (using wsprintf style formatting)
  1234. void __cdecl CSPString::Format(LPCTSTR lpszFormat, ...)
  1235. {
  1236. SP_ASSERT(SP_IsValidString(lpszFormat));
  1238. va_list argList;
  1239. va_start(argList, lpszFormat);
  1240. FormatV(lpszFormat, argList);
  1241. va_end(argList);
  1242. }
  1244. void __cdecl CSPString::Format(UINT nFormatID, ...)
  1245. {
  1246. CSPString strFormat;
  1247. SP_VERIFY(strFormat.LoadString(nFormatID) != 0);
  1249. va_list argList;
  1250. va_start(argList, nFormatID);
  1251. FormatV(strFormat, argList);
  1252. va_end(argList);
  1253. }
  1255. BOOL CSPString::LoadString(UINT nID)
  1256. {
  1257. SP_ASSERT( FALSE ); // Not supported Now!!!
  1258. return FALSE;
  1259. }
  1261. void CSPString::TrimRight(LPCTSTR lpszTargetList)
  1262. {
  1263. // find beginning of trailing matches
  1264. // by starting at beginning (DBCS aware)
  1266. CopyBeforeWrite();
  1267. LPTSTR lpsz = m_pchData;
  1268. LPTSTR lpszLast = NULL;
  1270. while (*lpsz != '')
  1271. {
  1272. if (_tcschr(lpszTargetList, *lpsz) != NULL)
  1273. {
  1274. if (lpszLast == NULL)
  1275. lpszLast = lpsz;
  1276. }
  1277. else
  1278. lpszLast = NULL;
  1279. lpsz = _tcsinc(lpsz);
  1280. }
  1282. if (lpszLast != NULL)
  1283. {
  1284. // truncate at left-most matching character
  1285. *lpszLast = '';
  1286. GetData()->nDataLength = lpszLast - m_pchData;
  1287. }
  1288. }
  1290. void CSPString::TrimRight(TCHAR chTarget)
  1291. {
  1292. // find beginning of trailing matches
  1293. // by starting at beginning (DBCS aware)
  1295. CopyBeforeWrite();
  1296. LPTSTR lpsz = m_pchData;
  1297. LPTSTR lpszLast = NULL;
  1299. while (*lpsz != '')
  1300. {
  1301. if (*lpsz == chTarget)
  1302. {
  1303. if (lpszLast == NULL)
  1304. lpszLast = lpsz;
  1305. }
  1306. else
  1307. lpszLast = NULL;
  1308. lpsz = _tcsinc(lpsz);
  1309. }
  1311. if (lpszLast != NULL)
  1312. {
  1313. // truncate at left-most matching character
  1314. *lpszLast = '';
  1315. GetData()->nDataLength = lpszLast - m_pchData;
  1316. }
  1317. }
  1319. void CSPString::TrimRight()
  1320. {
  1321. // find beginning of trailing spaces by starting at beginning (DBCS aware)
  1323. CopyBeforeWrite();
  1324. LPTSTR lpsz = m_pchData;
  1325. LPTSTR lpszLast = NULL;
  1327. while (*lpsz != '')
  1328. {
  1329. if (_istspace(*lpsz))
  1330. {
  1331. if (lpszLast == NULL)
  1332. lpszLast = lpsz;
  1333. }
  1334. else
  1335. lpszLast = NULL;
  1336. lpsz = _tcsinc(lpsz);
  1337. }
  1339. if (lpszLast != NULL)
  1340. {
  1341. // truncate at trailing space start
  1342. *lpszLast = '';
  1343. GetData()->nDataLength = lpszLast - m_pchData;
  1344. }
  1345. }
  1347. void CSPString::TrimLeft(LPCTSTR lpszTargets)
  1348. {
  1349. // if we're not trimming anything, we're not doing any work
  1350. if (SafeStrlen(lpszTargets) == 0)
  1351. return;
  1353. CopyBeforeWrite();
  1354. LPCTSTR lpsz = m_pchData;
  1356. while (*lpsz != '')
  1357. {
  1358. if (_tcschr(lpszTargets, *lpsz) == NULL)
  1359. break;
  1360. lpsz = _tcsinc(lpsz);
  1361. }
  1363. if (lpsz != m_pchData)
  1364. {
  1365. // fix up data and length
  1366. int nDataLength = GetData()->nDataLength - (lpsz - m_pchData);
  1367. memmove(m_pchData, lpsz, (nDataLength+1)*sizeof(TCHAR));
  1368. GetData()->nDataLength = nDataLength;
  1369. }
  1370. }
  1372. void CSPString::TrimLeft(TCHAR chTarget)
  1373. {
  1374. // find first non-matching character
  1376. CopyBeforeWrite();
  1377. LPCTSTR lpsz = m_pchData;
  1379. while (chTarget == *lpsz)
  1380. lpsz = _tcsinc(lpsz);
  1382. if (lpsz != m_pchData)
  1383. {
  1384. // fix up data and length
  1385. int nDataLength = GetData()->nDataLength - (lpsz - m_pchData);
  1386. memmove(m_pchData, lpsz, (nDataLength+1)*sizeof(TCHAR));
  1387. GetData()->nDataLength = nDataLength;
  1388. }
  1389. }
  1391. void CSPString::TrimLeft()
  1392. {
  1393. // find first non-space character
  1395. CopyBeforeWrite();
  1396. LPCTSTR lpsz = m_pchData;
  1398. while (_istspace(*lpsz))
  1399. lpsz = _tcsinc(lpsz);
  1401. if (lpsz != m_pchData)
  1402. {
  1403. // fix up data and length
  1404. int nDataLength = GetData()->nDataLength - (lpsz - m_pchData);
  1405. memmove(m_pchData, lpsz, (nDataLength+1)*sizeof(TCHAR));
  1406. GetData()->nDataLength = nDataLength;
  1407. }
  1408. }