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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
atlstr.h
资源名称：CreatBMP.rar　[点击查看]
上传用户：hfwmdy
上传日期：2016-01-14
资源大小：83k
文件大小：33k
源码类别：

GDI/图象编程

开发平台：

Visual C++

atlstr.h：源码内容
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  10. #ifndef __ATLSTR_H__
  11. #define __ATLSTR_H__
  13. #pragma once
  15. #ifndef __cplusplus
  16. #error ATL requires C++ compilation (use a .cpp suffix)
  17. #endif
  19. #include <atlbase.h>
  21. #include <winnls.h>
  22. #include <limits.h>
  24. #include <cstringt.h>
  27. #pragma pack(push,_ATL_PACKING)
  29.  
  30. namespace ATL
  31. {
  33. class CAtlStringMgr :
  34. public IAtlStringMgr
  35. {
  36. public:
  37. CAtlStringMgr( __in_opt IAtlMemMgr* pMemMgr = NULL ) throw() :
  38. m_pMemMgr( pMemMgr )
  39. {
  40. m_nil.SetManager( this );
  41. }
  42. virtual ~CAtlStringMgr() throw()
  43. {
  44. }
  46. void SetMemoryManager( __reserved IAtlMemMgr* pMemMgr ) throw()
  47. {
  48. ATLASSUME( m_pMemMgr == NULL );
  49. m_pMemMgr = pMemMgr;
  50. }
  52. // IAtlStringMgr
  53. public:
  54. virtual __bcount_opt(sizeof(CStringData) + nChars*nCharSize) CStringData* Allocate( __in int nChars, __in int nCharSize ) throw()
  55. {
  56. size_t nTotalSize;
  57. CStringData* pData;
  58. size_t nDataBytes;
  60. nChars = AtlAlignUp( nChars + 1, 8 );  // Prevent excessive reallocation.  The heap will usually round up anyway.
  62. if( FAILED(::ATL::AtlMultiply(&nDataBytes, static_cast<size_t>(nChars), static_cast<size_t>(nCharSize))) ||
  63. FAILED(::ATL::AtlAdd(&nTotalSize, static_cast<size_t>(sizeof( CStringData )), nDataBytes)))
  64. {
  65. return NULL;
  66. }
  67. pData = static_cast< CStringData* >( m_pMemMgr->Allocate( nTotalSize ) );
  68. if( pData == NULL )
  69. {
  70. return( NULL );
  71. }
  72. pData->pStringMgr = this;
  73. pData->nRefs = 1;
  74. pData->nAllocLength = nChars - 1;
  75. pData->nDataLength = 0;
  77. return( pData );
  78. }
  79. virtual void Free( __inout CStringData* pData ) throw()
  80. {
  81. ATLASSERT( pData->pStringMgr == this );
  82. m_pMemMgr->Free( pData );
  83. }
  84. virtual __bcount_opt(sizeof(CStringData) + nChars*nCharSize) CStringData* Reallocate( __inout CStringData* pData, __in int nChars, __in int nCharSize ) throw()
  85. {
  86. CStringData* pNewData;
  87. ULONG nTotalSize;
  88. ULONG nDataBytes;
  90. ATLASSERT( pData->pStringMgr == this );
  91. nChars = AtlAlignUp( nChars+1, 8 );  // Prevent excessive reallocation.  The heap will usually round up anyway.
  93. if( FAILED(::ATL::AtlMultiply(&nDataBytes, static_cast<ULONG>(nChars), static_cast<ULONG>(nCharSize))) ||
  94. FAILED(::ATL::AtlAdd(&nTotalSize, static_cast<ULONG>(sizeof( CStringData )), nDataBytes)))
  95. {
  96. return NULL;
  97. }
  98. pNewData = static_cast< CStringData* >( m_pMemMgr->Reallocate( pData, nTotalSize ) );
  99. if( pNewData == NULL )
  100. {
  101. return NULL;
  102. }
  103. pNewData->nAllocLength = nChars - 1;
  105. return pNewData;
  106. }
  107. virtual CStringData* GetNilString() throw()
  108. {
  109. m_nil.AddRef();
  110. return &m_nil;
  111. }
  112. virtual IAtlStringMgr* Clone() throw()
  113. {
  114. return this;
  115. }
  117. protected:
  118. IAtlMemMgr* m_pMemMgr;
  119. CNilStringData m_nil;
  120. };
  122. extern CAtlStringMgr g_strmgr;
  124. template <class ChTraits>
  125. inline typename ChTraits::PCXSTR strstrT(typename ChTraits::PCXSTR pStr,typename ChTraits::PCXSTR pCharSet);
  127. template< typename _CharType = char >
  128. class ChTraitsOS :
  129. public ChTraitsBase< _CharType >
  130. {
  131. public:
  132. static int tclen(__in_z LPCSTR p) throw()
  133. {
  134. ATLASSERT(p != NULL);
  135. LPCSTR pnext = CharNext(p);
  136. return ((pnext-p)>1) ? 2 : 1;
  137. }
  138. static LPCSTR strchr(__in_z LPCSTR p, __in char ch) throw()
  139. {
  140. return AtlstrchrT(p,ch);
  141. }
  142. static LPCSTR strchr_db(__in_z LPCSTR p, __in char ch1, __in char ch2) throw()
  143. {
  144. ATLASSERT(p != NULL);
  145. while (*p != 0)
  146. {
  147. if (*p == ch1 && *(p+1) == ch2)
  148. {
  149. return p;
  150. }
  151. p = CharNext(p);
  152. }
  153. return NULL;
  154. }
  155. static LPCSTR strrchr(__in_z LPCSTR p, __in char ch) throw()
  156. {
  157. ATLASSERT(p != NULL);
  158. const _CharType* pch = NULL;
  159. while (*p != 0)
  160. {
  161. if (*p == ch)
  162. {
  163. pch = p;
  164. }
  165. p = CharNext(p);
  166. }
  167. //for strrchr(buff,'')
  168. if (*p == ch) 
  169. {
  170. pch = p;
  171. }
  172. return const_cast< _CharType* >( pch );
  173. }
  174. static _CharType* _strrev(__inout _CharType* psz) throw()
  175. {
  176. // Optimize NULL, zero-length, and single-char case.
  177. if ((psz == NULL) || (psz[0] == '') || (psz[1] == ''))
  178. return psz;
  180. _CharType* p = psz;
  181. // first go through and reverse the bytes in MBCS chars
  182. while (*p != _T('')) 
  183. {
  184. if (IsDBCSLeadByte(*p++))
  185. {
  186. if (*p)
  187. {
  188. _CharType c = *p;
  189. *p=*(p-1);
  190. *(p-1)=c;
  191. p++;
  193. } else
  194. {
  195.         //  second byte is EOS
  196.                         //There is nothing really satisfying to do here. We have a string
  197.                         //that ends in leadbyte,''. Reversing this would lead to the leadbyte
  198.                         //becoming falsely attached to the character before it:
  199.                         //(XL0 -> LX0, X has suddenly become a trailbyte)
  201.                         //So what we choose to do is assert and purge the dud byte from within the
  202.                         //string.
  203.                     
  204.                     ATLASSERT(FALSE && _T("Bad MBCS string passed into __strev"));
  206.                     // String has at least moved once already, so this is safe 
  207.                     ATLASSERT(p>psz);
  209.                     // move back one to point at the dud leadbyte
  210.                     --p;
  212.                     // now truncate the string one byte earlier 
  213.                     *p='';
  215. }
  216. }
  219. } //end while
  221. _CharType* q = psz;
  222. --p;
  223. while (q < p)
  224. {
  225. _CharType t = *q;
  226. *q = *p;
  227. *p = t;
  228. q++;
  229. p--;
  230. }
  231. return psz;
  232. }
  233. static LPCSTR strstr(__in_z LPCSTR pStr, __in_z LPCSTR pCharSet) throw()
  234. {
  235. return strstrT< ChTraitsOS<XCHAR> >(pStr,pCharSet);
  236. }
  237. static int strspn(__in const _CharType* pStr, __in const _CharType* pCharSet) throw()
  238. {
  239. ATLASSERT(pStr != NULL);
  240. int nRet = 0;
  241. _CharType* p = const_cast<_CharType*>(pStr);
  242. while (*p != 0)
  243. {
  244. _CharType* pNext = CharNext(p);
  245. if(pNext > p + 1)
  246. {
  247. if(strchr_db(pCharSet, *p, *(p+1)) == NULL)
  248. break;
  249. nRet += 2;
  250. }
  251. else
  252. {
  253. if(strchr(pCharSet, *p) == NULL)
  254. break;
  255. nRet++;
  256. }
  257. p = pNext;
  258. }
  259. return nRet;
  260. }
  261. static int strcspn(__in const _CharType* pStr, __in const _CharType* pCharSet) throw()
  262. {
  263. ATLASSERT(pStr != NULL);
  264. int nRet = 0;
  265. _CharType* p = const_cast<_CharType*>(pStr);
  266. while (*p != 0)
  267. {
  268. _CharType* pNext = CharNext(p);
  269. if(pNext > p + 1)
  270. {
  271. if(strchr_db(pCharSet, *p, *(p+1)) != NULL)
  272. break;
  273. nRet += 2;
  274. }
  275. else
  276. {
  277. if(strchr(pCharSet, *p) != NULL)
  278. break;
  279. nRet++;
  280. }
  281. p = pNext;
  282. }
  283. return nRet;
  284. }
  285. static LPCSTR strpbrk(__in_z LPCSTR p, __in_z LPCSTR lpszCharSet) throw()
  286. {
  287. int nRet=0;
  288. nRet=strcspn(p,lpszCharSet);
  289. if (p[nRet]){
  290. p+=nRet;
  291. return p;
  292. }
  293.      return NULL;
  294. }
  296. static _CharType* CharNext(__in const _CharType* p) throw()
  297. {
  298. return AtlCharNext(p);
  299. }
  301. static int IsDigit(__in _CharType ch) throw()
  302. {
  303. WORD type;
  304. GetStringTypeExA(GetThreadLocale(), CT_CTYPE1, &ch, 1, &type);
  305. return (type & C1_DIGIT) == C1_DIGIT;
  306. }
  308. static int IsSpace(__in _CharType ch) throw()
  309. {
  310. WORD type;
  311. GetStringTypeExA(GetThreadLocale(), CT_CTYPE1, &ch, 1, &type);
  312. return (type & C1_SPACE) == C1_SPACE;
  313. }
  315. static int StringCompare(__in const _CharType* pstrOne,
  316. __in const _CharType* pstrOther) throw()
  317. {
  318. return lstrcmpA((LPCSTR) pstrOne, (LPCSTR) pstrOther);
  319. }
  321. static int StringCompareIgnore(__in const _CharType* pstrOne,
  322. __in const _CharType* pstrOther) throw()
  323. {
  324. return lstrcmpiA((LPCSTR) pstrOne, (LPCSTR) pstrOther);
  325. }
  327. static int StringCollate(__in const _CharType* pstrOne,
  328. __in const _CharType* pstrOther) throw()
  329. {
  330. int nRet = CompareStringA(GetThreadLocale(), 0, (LPCSTR)pstrOne, -1, 
  331. (LPCSTR)pstrOther, -1);
  332. ATLASSERT(nRet != 0);
  333. return nRet-2;  // Convert to strcmp convention.  This really is documented.
  334. }
  336. static int StringCollateIgnore(__in const _CharType* pstrOne,
  337. __in const _CharType* pstrOther) throw()
  338. {
  339. int nRet = CompareStringA(GetThreadLocale(), NORM_IGNORECASE, (LPCSTR)pstrOne, -1, 
  340. (LPCSTR)pstrOther, -1);
  341. ATLASSERT(nRet != 0);
  342. return nRet-2;  // Convert to strcmp convention.  This really is documented.
  343. }
  345. static LPCSTR StringFindString(__in_z LPCSTR pstrBlock,
  346. __in_z LPCSTR pstrMatch) throw()
  347. {
  348. return strstr(pstrBlock, pstrMatch);
  349. }
  351. static LPSTR StringFindString(__in_z LPSTR pszBlock, __in_z LPCSTR pszMatch) throw()
  352. {
  353. return( const_cast< LPSTR >( StringFindString( const_cast< LPCSTR >( pszBlock ), pszMatch ) ) );
  354. }
  356. static LPCSTR StringFindChar(__in_z LPCSTR pszBlock,
  357. __in char chMatch) throw()
  358. {
  359. return strchr(pszBlock, chMatch);
  360. }
  362. static LPCSTR StringFindCharRev(__in_z LPCSTR psz, __in char ch) throw()
  363. {
  364. return strrchr(psz, ch);
  365. }
  367. static LPCSTR StringScanSet(__in_z LPCSTR pszBlock,
  368. __in_z LPCSTR pszMatch) throw()
  369. {
  370. return strpbrk(pszBlock, pszMatch);
  371. }
  373. static int StringSpanIncluding(__in const _CharType* pstrBlock,
  374. __in const _CharType* pstrSet) throw()
  375. {
  376. return strspn(pstrBlock, pstrSet);
  377. }
  379. static int StringSpanExcluding(__in const _CharType* pstrBlock,
  380. __in const _CharType* pstrSet) throw()
  381. {
  382. return strcspn(pstrBlock, pstrSet);
  383. }
  385. _ATL_INSECURE_DEPRECATE("ChTraitsOS::StringUppercase must be passed a buffer size")
  386. static _CharType* StringUppercase(__inout _CharType* psz) throw()
  387. {
  388. return CharUpperA( psz );
  389. }
  391. _ATL_INSECURE_DEPRECATE("ChTraitsOS::StringLowercase must be passed a buffer size")
  392. static _CharType* StringLowercase(__inout _CharType* psz) throw()
  393. {
  394. return CharLowerA( psz );
  395. }
  397. static _CharType* StringUppercase(__inout_ecount(size) _CharType* psz, __in size_t size) throw()
  398. {
  399. if(size>UINT_MAX)
  400. {
  401. // API only allows DWORD size
  402. AtlThrow(E_INVALIDARG);
  403. }
  404. DWORD dwSize=static_cast<DWORD>(size);
  405. CharUpperBuffA( psz, dwSize );
  406. return psz;
  407. }
  409. static _CharType* StringLowercase(__inout_ecount(size) _CharType* psz, size_t size) throw()
  410. {
  411. if(size>UINT_MAX)
  412. {
  413. // API only allows DWORD size
  414. AtlThrow(E_INVALIDARG);
  415. }
  416. DWORD dwSize=static_cast<DWORD>(size);
  417. CharLowerBuffA( psz, dwSize );
  418. return psz;
  419. }
  423. static _CharType* StringReverse(__inout _CharType* psz) throw()
  424. {
  425. return _strrev( psz );
  426. }
  428. static int GetFormattedLength(__in __format_string const _CharType* pszFormat, va_list args)
  429. {
  430. _CharType szBuffer[1028];
  431. int nLength = 0;
  433. SetLastError(ERROR_SUCCESS);
  434. #pragma warning(push)
  435. #pragma warning(disable:4996)
  436. // wvsprintf always truncates the output to 1024 character plus the ''.
  437. // Note that we are using wvsprintf only in the MIN_CRT case; wvsprintf is
  438. // an insecure function and should be avoided. Here the use of wvsprintf
  439. // is safe and the only way to get a string formatted without using the CRT.
  440. nLength = wvsprintfA(szBuffer, pszFormat, args);
  441. #pragma warning(pop)
  442. ATLENSURE(GetLastError() == ERROR_SUCCESS);
  443. ATLASSERT(nLength >= 0);
  444. ATLASSERT(nLength <= 1024);
  446. return nLength;
  447. }
  449. _ATL_INSECURE_DEPRECATE("CSimpleStringT::Format must be passed a buffer size")
  450. static int Format(__out _CharType* pszBuffer, __in __format_string const _CharType* pszFormat,
  451. va_list args) throw()
  452. {
  453. #pragma warning(push)
  454. #pragma warning(disable:4996)
  455. return wvsprintfA(pszBuffer, pszFormat, args);
  456. #pragma warning(pop)
  457. }
  458. static int Format(__out_ecount_part(nlength, return) _CharType*  pszBuffer, __in size_t nlength, __in __format_string const _CharType* pszFormat, va_list args )
  459. {
  460. _CharType buffSafe[1030]; //wvsprintf output is max 1024.
  461. int nCharsWritten = 0;
  463. SetLastError(ERROR_SUCCESS);
  464. #pragma warning(push)
  465. #pragma warning(disable:4996)
  466. // wvsprintf always truncates the output to 1024 character plus the ''.
  467. // Note that we are using wvsprintf only in the MIN_CRT case; wvsprintf is
  468. // an insecure function and should be avoided. Here the use of wvsprintf
  469. // is safe and the only way to get a string formatted without using the CRT.
  470. nCharsWritten = wvsprintfA(buffSafe, pszFormat, args);
  471. #pragma warning(pop)
  472. ATLENSURE(GetLastError() == ERROR_SUCCESS);
  473. ATLENSURE(nCharsWritten <= 1024);
  474. //nlength should have room for nCharsWritten + NULL
  475. ATLENSURE_THROW((size_t)nCharsWritten < nlength ,E_INVALIDARG);
  476. Checked::strcpy_s(pszBuffer,nlength,buffSafe);
  477. return nCharsWritten;
  478. }
  480. static int GetBaseTypeLength(__in_z const char* pszSrc) throw()
  481. {
  482. // Returns required buffer length in XCHARs
  483. return lstrlenA(pszSrc);
  484. }
  486. static int GetBaseTypeLength(__in_z const char* pszSrc, __in int nLength) throw()
  487. {
  488. (void)pszSrc;
  489. // Returns required buffer length in XCHARs
  490. return nLength;
  491. }
  493. static int GetBaseTypeLength(__in_z const wchar_t* pszSrc) throw()
  494. {
  495. // Returns required buffer length in XCHARs
  496. return ::WideCharToMultiByte(_AtlGetConversionACP(), 0, pszSrc, -1, NULL, 0, NULL, NULL)-1;
  497. }
  499. static int GetBaseTypeLength(__in_ecount(nLength) const wchar_t* pszSrc, __in int nLength) throw()
  500. {
  501. // Returns required buffer length in XCHARs
  502. return ::WideCharToMultiByte(_AtlGetConversionACP(), 0, pszSrc, nLength, NULL, 0, NULL, NULL);
  503. }
  505. static void ConvertToBaseType(__out_ecount(nDestLength) _CharType* pszDest, __in int nDestLength,
  506. __in_ecount(nSrcLength) const char* pszSrc, __in int nSrcLength = -1) throw()
  507. {
  508. if (nSrcLength == -1) { nSrcLength=1 + GetBaseTypeLength(pszSrc); }
  509. // nLen is in chars
  510. Checked::memcpy_s(pszDest, nDestLength*sizeof(_CharType), 
  511. pszSrc, nSrcLength*sizeof(_CharType));
  512. }
  514. static void ConvertToBaseType(__out_ecount(nDestLength) _CharType* pszDest, __in int nDestLength,
  515. __in_ecount(nSrcLength) const wchar_t* pszSrc, __in int nSrcLength = -1) throw()
  516. {
  517. // nLen is in XCHARs
  518. ::WideCharToMultiByte(_AtlGetConversionACP(), 0, pszSrc, nSrcLength, pszDest, nDestLength, NULL, NULL);
  519. }
  521. _ATL_INSECURE_DEPRECATE("ChTraitsOS::ConvertToOem must be passed a buffer size")
  522. static void ConvertToOem(__inout _CharType* pstrString) throw()
  523. {
  524. BOOL fSuccess=::CharToOemA(pstrString, pstrString);
  525. // old version can't report error
  526. ATLASSERT(fSuccess);
  527. }
  529. _ATL_INSECURE_DEPRECATE("ChTraitsOS::ConvertToAnsi must be passed a buffer size")
  530. static void ConvertToAnsi(__inout _CharType* pstrString) throw()
  531. {
  532. BOOL fSuccess=::OemToCharA(pstrString, pstrString);
  533. // old version can't report error
  534. ATLASSERT(fSuccess);
  535. }
  537. static void ConvertToOem(__out_ecount(size) _CharType* pstrString, __in size_t size)
  538. {
  539. if(size>UINT_MAX)
  540. {
  541. // API only allows DWORD size
  542. AtlThrow(E_INVALIDARG);
  543. }
  544. DWORD dwSize=static_cast<DWORD>(size);
  545. BOOL fSuccess=::CharToOemBuffA(pstrString, pstrString, dwSize);
  546. if(!fSuccess)
  547. {
  548. AtlThrowLastWin32();
  549. }
  550. }
  552. static void ConvertToAnsi(__out_ecount(size) _CharType* pstrString, __in size_t size)
  553. {
  554. if(size>UINT_MAX)
  555. {
  556. // API only allows DWORD size
  557. AtlThrow(E_INVALIDARG);
  558. }
  559. DWORD dwSize=static_cast<DWORD>(size);
  560. BOOL fSuccess=::OemToCharBuffA(pstrString, pstrString, dwSize);
  561. if(!fSuccess)
  562. {
  563. AtlThrowLastWin32();
  564. }
  565. }
  567. static void FloodCharacters(__in _CharType ch, __in int nLength, __out_bcount_full(nLength) _CharType* pstr) throw()
  568. {
  569. // nLength is in XCHARs
  570. memset(pstr, ch, nLength);
  571. }
  573. static BSTR AllocSysString(__in_ecount(nDataLength) const _CharType* pchData, __in int nDataLength) throw()
  574. {
  575. int nLen = MultiByteToWideChar(_AtlGetConversionACP(), 0, pchData, nDataLength,
  576. NULL, NULL);
  577. BSTR bstr = ::SysAllocStringLen(NULL, nLen);
  578. if (bstr != NULL)
  579. {
  580. MultiByteToWideChar(_AtlGetConversionACP(), 0, pchData, nDataLength,
  581. bstr, nLen);
  582. }
  584. return bstr;
  585. }
  587. static BOOL ReAllocSysString(__in_bcount(nDataLength) const _CharType* pchData, __inout BSTR* pbstr,
  588. __in int nDataLength) throw()
  589. {
  590. int nLen = MultiByteToWideChar(_AtlGetConversionACP(), 0, pchData,
  591. nDataLength, NULL, NULL);
  592. BOOL bSuccess =::SysReAllocStringLen(pbstr, NULL, nLen);
  593. if (bSuccess)
  594. {
  595. MultiByteToWideChar(_AtlGetConversionACP(), 0, pchData, nDataLength,
  596. *pbstr, nLen);
  597. }
  599. return bSuccess;
  600. }
  602. static DWORD FormatMessage(__in DWORD dwFlags, __in LPCVOID lpSource,
  603. __in DWORD dwMessageID, __in DWORD dwLanguageID, __out_ecount(nSize) char* pstrBuffer,
  604. __in DWORD nSize, va_list* pArguments) throw()
  605. {
  606. return ::FormatMessageA(dwFlags, lpSource, dwMessageID, dwLanguageID,
  607. pstrBuffer, nSize, pArguments);
  608. }
  610. static int SafeStringLen(__in_opt const char* psz) throw()
  611. {
  612. // returns length in bytes
  613. return (psz != NULL) ? lstrlenA(psz) : 0;
  614. }
  616. static int SafeStringLen(__in_opt const wchar_t* psz) throw()
  617. {
  618. // returns length in wchar_ts
  619. return (psz != NULL) ? lstrlenW(psz) : 0;
  620. }
  622. static int GetCharLen(const wchar_t*) throw()
  623. {
  624. // returns char length
  625. return 1;
  626. }
  627. static int GetCharLen(__in_z const char* psz) throw()
  628. {
  629. const char* p = ::CharNextA(psz);
  630. return (p - psz);
  631. }
  633. static DWORD GetEnvironmentVariable(__in const _CharType* pstrVar,
  634. __out_ecount_opt(dwSize) _CharType* pstrBuffer, __in DWORD dwSize) throw()
  635. {
  636. return ::GetEnvironmentVariableA(pstrVar, pstrBuffer, dwSize);
  637. }
  638. };
  640. // specialization for wchar_t
  641. template<>
  642. class ChTraitsOS< wchar_t > :
  643. public ChTraitsBase< wchar_t >
  644. {
  645. protected:
  646. #if defined(_UNICODE) && !defined(_CSTRING_ALWAYS_THUNK)
  647. static int CompareStringW(__in LCID lcid, __in DWORD dwFlags, 
  648. __in_ecount(nLength1) LPCWSTR pszString1, __in int nLength1, __in_ecount(nLength2) LPCWSTR pszString2, __in int nLength2)
  649. {
  650. return ::CompareStringW(lcid, dwFlags, pszString1, nLength1, 
  651. pszString2, nLength2);
  652. }
  653. static BOOL GetStringTypeExW(__in LCID lcid, __in DWORD dwInfoType, __in_ecount(nLength) LPCWSTR pszSrc,
  654. __in int nLength, __out LPWORD pwCharType)
  655. {
  656. return ::GetStringTypeExW(lcid, dwInfoType, pszSrc, nLength, pwCharType);
  657. }
  658. static int lstrcmpiW(__in_z LPCWSTR psz1, __in_z LPCWSTR psz2)
  659. {
  660. return ::lstrcmpiW(psz1, psz2);
  661. }
  662. static LPWSTR CharLowerW(__inout LPWSTR psz)
  663. {
  664. return ::CharLowerW(psz);
  665. }
  666. static LPWSTR CharUpperW(__inout LPWSTR psz)
  667. {
  668. return ::CharUpperW(psz);
  669. }
  670. static DWORD _GetEnvironmentVariableW(__in_z LPCWSTR pszName, __out_ecount_opt(nSize) LPWSTR pszBuffer, __in DWORD nSize)
  671. {
  672. return ::GetEnvironmentVariableW(pszName, pszBuffer, nSize);
  673. }
  674. #else  // !_UNICODE
  675. static int WINAPI CompareStringW(__in LCID lcid, __in DWORD dwFlags, 
  676. __in_ecount(nLength1) LPCWSTR pszString1, __in int nLength1, __in_ecount(nLength2) LPCWSTR pszString2, __in int nLength2)
  677. {
  678. return _strthunks.pfnCompareStringW(lcid, dwFlags, pszString1, nLength1, pszString2, nLength2);
  679. }
  680. static BOOL WINAPI GetStringTypeExW(__in LCID lcid, __in DWORD dwInfoType, __in_ecount(nLength) LPCWSTR pszSrc,
  681. __in int nLength, __out LPWORD pwCharType)
  682. {
  683. return _strthunks.pfnGetStringTypeExW(lcid, dwInfoType, pszSrc, nLength, pwCharType);
  684. }
  685. static int WINAPI lstrcmpiW(__in_z LPCWSTR psz1, __in_z LPCWSTR psz2)
  686. {
  687. return _strthunks.pfnlstrcmpiW(psz1, psz2);
  688. }
  689. static LPWSTR WINAPI CharLowerW(__inout LPWSTR psz)
  690. {
  691. ATLASSERT(HIWORD(psz) != 0);  // No single chars
  692. return _strthunks.pfnCharLowerW(psz);
  693. }
  694. static LPWSTR WINAPI CharUpperW(__inout LPWSTR psz)
  695. {
  696. ATLASSERT(HIWORD(psz) != 0);  // No single chars
  697. return _strthunks.pfnCharUpperW(psz);
  698. }
  699. static DWORD _GetEnvironmentVariableW(__in_z LPCWSTR pszName, __out_ecount_opt(nSize) LPWSTR pszBuffer, DWORD nSize)
  700. {
  701. return _strthunks.pfnGetEnvironmentVariableW(pszName, pszBuffer, nSize);
  702. }
  703. #endif  // !_UNICODE
  705. public:
  706. static int tclen(const wchar_t*) throw()
  707. {
  708. return 1;
  709. }
  710. static LPCWSTR strchr(__in_z LPCWSTR p, __in wchar_t ch) throw()
  711. {
  712. return AtlstrchrT(p,ch);
  713. }
  714. static LPCWSTR strrchr(__in_z LPCWSTR p, __in wchar_t ch) throw()
  715. {
  716. const wchar_t* pch = p+lstrlenW(p);
  717. while ((pch != p) && (*pch != ch))
  718. {
  719. pch--;
  720. }
  721. if (*pch == ch)
  722. {
  723. return pch;
  724. }
  725. else
  726. {
  727. return NULL;
  728. }
  729. }
  730. static wchar_t* _strrev(__inout_z wchar_t* psz) throw()
  731. {
  732. // Optimize NULL, zero-length, and single-char case.
  733. if ((psz == NULL) || (psz[0] == L'') || (psz[1] == L''))
  734. return psz;
  736. wchar_t* p = psz+(lstrlenW( psz )-1);
  737. wchar_t* q = psz;
  738. while(q < p)
  739. {
  740. wchar_t t = *q;
  741. *q = *p;
  742. *p = t;
  743. q++;
  744. p--;
  745. }
  746. return psz;
  747. }
  748. static LPCWSTR strstr(__in_z LPCWSTR pStr, __in_z LPCWSTR pCharSet) throw()
  749. {
  750. return strstrT< ChTraitsOS<XCHAR> >(pStr,pCharSet);
  751. }
  752. static int strspn(__in_z const wchar_t* psz, __in_z const wchar_t* pszCharSet) throw()
  753. {
  754. int nRet = 0;
  755. const wchar_t* p = psz;
  756. while (*p != 0)
  757. {
  758. if(strchr(pszCharSet, *p) == NULL)
  759. break;
  760. nRet++;
  761. p++;
  762. }
  763. return nRet;
  764. }
  765. static int strcspn(__in_z const wchar_t* psz, __in_z const wchar_t* pszCharSet) throw()
  766. {
  767. int nRet = 0;
  768. const wchar_t* p = psz;
  769. while (*p != 0)
  770. {
  771. if(strchr(pszCharSet, *p) != NULL)
  772. break;
  773. nRet++;
  774. p++;
  775. }
  776. return nRet;
  777. }
  778. static LPCWSTR strpbrk(__in_z LPCWSTR psz, __in_z LPCWSTR pszCharSet) throw()
  779. {
  780. const wchar_t* p = psz;
  781. while (*p != 0)
  782. {
  783. if (strchr(pszCharSet, *p) != NULL)
  784. return p;
  785. p++;
  786. }
  787. return NULL;
  788. }
  790. static wchar_t* CharNext(__in_z const wchar_t* p) throw()
  791. {
  792. return AtlCharNext(p);
  793. }
  795. static int IsDigit(__in wchar_t ch) throw()
  796. {
  797. WORD type;
  798. GetStringTypeExW(0, CT_CTYPE1, &ch, 1, &type);
  799. return (type & C1_DIGIT) == C1_DIGIT;
  800. }
  802. static int IsSpace(__in wchar_t ch) throw()
  803. {
  804. WORD type;
  805. GetStringTypeExW(0, CT_CTYPE1, &ch, 1, &type);
  806. return (type & C1_SPACE) == C1_SPACE;
  807. }
  810. static int StringCompare(__in_z const wchar_t* pstrOne,
  811. __in_z const wchar_t* pstrOther) throw()
  812. {
  813. return wcscmp(pstrOne, pstrOther);
  814. }
  816. static int StringCompareIgnore(__in_z const wchar_t* pstrOne,
  817. __in_z const wchar_t* pstrOther) throw()
  818. {
  819. return lstrcmpiW(pstrOne, pstrOther);
  820. }
  822. static int StringCollate(__in_z const wchar_t* pstrOne,
  823. __in_z const wchar_t* pstrOther) throw()
  824. { 
  825. int nRet;
  827. nRet = CompareStringW(GetThreadLocale(), 0, pstrOne, UINT_MAX/sizeof(wchar_t), pstrOther, UINT_MAX/sizeof(wchar_t));
  828. ATLASSERT(nRet != 0);
  829. return nRet-2;  // Convert to strcmp convention.  This really is documented.
  830. }
  832. static int StringCollateIgnore(__in_z const wchar_t* pstrOne,
  833. __in_z const wchar_t* pstrOther) throw()
  834. {
  835. int nRet = CompareStringW(GetThreadLocale(), NORM_IGNORECASE, pstrOne, UINT_MAX/sizeof(wchar_t), pstrOther, UINT_MAX/sizeof(wchar_t));
  836. ATLASSERT(nRet != 0);
  837. return nRet-2;  // Convert to strcmp convention.  This really is documented.
  838. }
  840. static LPCWSTR StringFindString(__in_z LPCWSTR pstrBlock,
  841. __in_z LPCWSTR pstrMatch) throw()
  842. {
  843. return strstr(pstrBlock, pstrMatch);
  844. }
  846. static LPWSTR StringFindString( __in_z LPWSTR pszBlock, __in_z LPCWSTR pszMatch ) throw()
  847. {
  848. return( const_cast< LPWSTR >( StringFindString( const_cast< LPCWSTR >( pszBlock ), pszMatch ) ) );
  849. }
  851. static LPCWSTR StringFindChar(__in_z LPCWSTR pstrBlock,
  852. __in wchar_t pstrMatch) throw()
  853. {
  854. return strchr(pstrBlock, pstrMatch);
  855. }
  857. static LPCWSTR StringFindCharRev(__in_z LPCWSTR pstr, __in wchar_t ch) throw()
  858. {
  859. return strrchr(pstr, ch);
  860. }
  862. static LPCWSTR StringScanSet(__in_z LPCWSTR pszBlock,
  863. __in_z LPCWSTR pszMatch) throw()
  864. {
  865. return strpbrk(pszBlock, pszMatch);
  866. }
  868. static int StringSpanIncluding(__in_z const wchar_t* pszBlock,
  869. __in_z const wchar_t* pszSet) throw()
  870. {
  871. return strspn(pszBlock, pszSet);
  872. }
  874. static int StringSpanExcluding(__in_z const wchar_t* pszBlock,
  875. __in_z const wchar_t* pszSet) throw()
  876. {
  877. return strcspn(pszBlock, pszSet);
  878. }
  880. _ATL_INSECURE_DEPRECATE("ChTraitsOS::StringUppercase must be passed a buffer size")
  881. static wchar_t* StringUppercase(__inout wchar_t* psz) throw()
  882. {
  883. CharUpperW(psz);
  884. return psz;
  885. }
  887. _ATL_INSECURE_DEPRECATE("ChTraitsOS::StringUppercase must be passed a buffer size")
  888. static wchar_t* StringLowercase(__inout wchar_t* psz) throw()
  889. {
  890. CharLowerW(psz);
  891. return psz;
  892. }
  894. static wchar_t* StringUppercase(__inout_ecount(size) wchar_t* psz, __in size_t size) throw()
  895. {
  896. if(size>(UINT_MAX/sizeof(wchar_t)))
  897. {
  898. // API only allows DWORD size
  899. AtlThrow(E_INVALIDARG);
  900. }
  901. DWORD dwSize=static_cast<DWORD>(size);
  902. CharUpperBuffW(psz, dwSize);
  903. return psz;
  904. }
  906. static wchar_t* StringLowercase(__inout_ecount(size) wchar_t* psz, __in size_t size) throw()
  907. {
  908. if(size>(UINT_MAX/sizeof(wchar_t)))
  909. {
  910. // API only allows DWORD size
  911. AtlThrow(E_INVALIDARG);
  912. }
  913. DWORD dwSize=static_cast<DWORD>(size);
  914. CharLowerBuffW(psz, dwSize);
  915. return psz;
  916. }
  918. static wchar_t* StringReverse(__inout_z wchar_t* psz) throw()
  919. {
  920. return _strrev(psz);
  921. }
  923. #ifdef _UNICODE
  924. static int GetFormattedLength(__in __format_string const wchar_t* pszFormat, va_list args)
  925. {
  926. wchar_t szBuffer[1028];
  927. int nLength = 0;
  929. SetLastError(ERROR_SUCCESS);
  930. #pragma warning(push)
  931. #pragma warning(disable:4996)
  932. // wvsprintf always truncates the output to 1024 character plus the ''.
  933. // Note that we are using wvsprintf only in the MIN_CRT case; wvsprintf is
  934. // an insecure function and should be avoided. Here the use of wvsprintf
  935. // is safe and the only way to get a string formatted without using the CRT.
  936. nLength = wvsprintfW(szBuffer, pszFormat, args);
  937. #pragma warning(pop)
  938. ATLENSURE(GetLastError() == ERROR_SUCCESS);
  939. ATLASSERT(nLength >= 0);
  940. ATLASSERT(nLength <= 1024);
  942. return nLength;
  943. }
  945. _ATL_INSECURE_DEPRECATE("ChTraitsOS::Format must be passed a buffer size")
  946. static int Format(__out wchar_t* pszBuffer, __in __format_string const wchar_t* pszFormat,
  947. va_list args) throw()
  948. {
  949. #pragma warning(push)
  950. #pragma warning(disable:4996)
  951. return wvsprintfW(pszBuffer, pszFormat, args);
  952. #pragma warning(pop)
  953. }
  955. static int Format(__out_ecount(nLength) wchar_t* pszBuffer, __in size_t nLength, __in __format_string const wchar_t* pszFormat, va_list args )
  956. {
  957. wchar_t buffSafe[1028];
  958. int nCharsWritten = 0;
  960. SetLastError(ERROR_SUCCESS);
  961. #pragma warning(push)
  962. #pragma warning(disable:4996)
  963. // wvsprintf always truncates the output to 1024 character plus the ''.
  964. // Note that we are using wvsprintf only in the MIN_CRT case; wvsprintf is
  965. // an insecure function and should be avoided. Here the use of wvsprintf
  966. // is safe and the only way to get a string formatted without using the CRT.
  967. nCharsWritten = wvsprintfW(buffSafe, pszFormat, args);
  968. #pragma warning(pop)
  969. ATLENSURE(GetLastError() == ERROR_SUCCESS);
  970. ATLENSURE(nCharsWritten <= 1024);
  971. //nlength should have room for nCharsWritten + NULL
  972. ATLENSURE_THROW((size_t)nCharsWritten < nLength ,E_INVALIDARG);
  973. ATLENSURE_THROW(wcslen(buffSafe) < nLength ,E_INVALIDARG);
  974. #pragma warning(push)
  975. #pragma warning(disable:6386)
  976. /* prefast noise 497597 */
  977. Checked::wcscpy_s(pszBuffer,nLength,buffSafe);
  978. #pragma warning(pop)
  979. return nCharsWritten;
  980. }
  981. #endif
  983. static int GetBaseTypeLength(__in_z const char* pszSrc) throw()
  984. {
  985. // Returns required buffer size in wchar_ts
  986. return ::MultiByteToWideChar(_AtlGetConversionACP(), 0, pszSrc, -1, NULL, 0)-1;
  987. }
  989. static int GetBaseTypeLength(__in_ecount(nLength) const char* pszSrc, __in int nLength) throw()
  990. {
  991. // Returns required buffer size in wchar_ts
  992. return ::MultiByteToWideChar(_AtlGetConversionACP(), 0, pszSrc, nLength, NULL, 0);
  993. }
  995. static int GetBaseTypeLength(__in_z const wchar_t* pszSrc) throw()
  996. {
  997. // Returns required buffer size in wchar_ts
  998. return lstrlenW(pszSrc);
  999. }
  1001. static int GetBaseTypeLength(__in_ecount(nLength) const wchar_t* pszSrc, __in int nLength) throw()
  1002. {
  1003. (void)pszSrc;
  1004. // Returns required buffer size in wchar_ts
  1005. return nLength;
  1006. }
  1008. static void ConvertToBaseType(__out_ecount(nDestLength) wchar_t* pszDest, int nDestLength,
  1009. __in_ecount(nSrcLength) const char* pszSrc, __in int nSrcLength = -1) throw()
  1010. {
  1011. // nLen is in wchar_ts
  1012. ::MultiByteToWideChar(_AtlGetConversionACP(), 0, pszSrc, nSrcLength, pszDest, nDestLength);
  1013. }
  1015. static void ConvertToBaseType(__out_ecount(nDestLength) wchar_t* pszDest, __in int nDestLength,
  1016. __in_ecount(nSrcLength) const wchar_t* pszSrc, int nSrcLength = -1) throw()
  1017. {
  1018. if (nSrcLength == -1) { nSrcLength=1 + GetBaseTypeLength(pszSrc); }
  1019. // nLen is in wchar_ts
  1020. Checked::wmemcpy_s(pszDest, nDestLength, pszSrc, nSrcLength);
  1021. }
  1023. // this conversion on Unicode strings makes no sense
  1024. /*
  1025. static void ConvertToOem(wchar_t*)
  1026. {
  1027. ATLASSERT(FALSE);
  1028. }
  1029. */
  1031. // this conversion on Unicode strings makes no sense
  1032. /*
  1033. static void ConvertToAnsi(wchar_t*)
  1034. {
  1035. ATLASSERT(FALSE);
  1036. }
  1037. */
  1039. static void FloodCharacters(__in wchar_t ch, __in int nLength, __out_ecount_full(nLength) wchar_t* pstr) throw()
  1040. {
  1041. // nLength is in XCHARs
  1042. for (int i = 0; i < nLength; i++)
  1043. pstr[i] = ch;
  1044. }
  1046. static BSTR AllocSysString(__in_ecount(nDataLength) const wchar_t* pchData, __in int nDataLength) throw()
  1047. {
  1048. BSTR bstr = ::SysAllocStringLen(pchData, nDataLength);
  1049. return bstr;
  1050. }
  1052. static BOOL ReAllocSysString(__in_ecount(nDataLength) const wchar_t* pchData, __inout BSTR* pbstr,
  1053. __in int nDataLength) throw()
  1054. {
  1055. return ::SysReAllocStringLen(pbstr, pchData, nDataLength);
  1056. }
  1058. #ifdef _UNICODE
  1059. static DWORD FormatMessage(__in DWORD dwFlags, __in LPCVOID lpSource,
  1060. __in DWORD dwMessageID, __in DWORD dwLanguageID, __out_ecount(nSize) wchar_t* pstrBuffer,
  1061. __in DWORD nSize, va_list* pArguments) throw()
  1062. {
  1063. return ::FormatMessageW(dwFlags, lpSource, dwMessageID, dwLanguageID,
  1064. pstrBuffer, nSize, pArguments);
  1065. }
  1066. #endif
  1067. static int SafeStringLen(__in_opt const char* psz) throw()
  1068. {
  1069. // returns length in bytes
  1070. return (psz != NULL) ? lstrlenA(psz) : 0;
  1071. }
  1073. static int SafeStringLen(__in_opt const wchar_t* psz) throw()
  1074. {
  1075. // returns length in wchar_ts
  1076. return (psz != NULL) ? lstrlenW(psz) : 0;
  1077. }
  1079. static int GetCharLen(const wchar_t*) throw()
  1080. {
  1081. // returns char length
  1082. return 1;
  1083. }
  1084. static int GetCharLen(__in_z const char* psz) throw()
  1085. {
  1086. LPCSTR p = ::CharNextA( psz );
  1087. return int( p-psz );
  1088. }
  1090. static DWORD GetEnvironmentVariable(__in_z const wchar_t* pstrVar,
  1091. __out_ecount_opt(dwSize) wchar_t* pstrBuffer, __in DWORD dwSize) throw()
  1092. {
  1093. return ::GetEnvironmentVariableW(pstrVar, pstrBuffer, dwSize);
  1094. }
  1095. };
  1097. template <class ChTraits>
  1098. inline typename ChTraits::PCXSTR strstrT(__in typename ChTraits::PCXSTR pStr,__in typename ChTraits::PCXSTR pCharSet)
  1099. {
  1100. ATLASSERT(pStr != NULL);
  1101. size_t nCharSetLen = ChTraits::GetBaseTypeLength(pCharSet);
  1102. if (nCharSetLen == 0)
  1103. return pStr;
  1104. //lstrlenA returns length in bytes, not chars.
  1105. size_t nStrLen = ChTraits::GetBaseTypeLength(pStr);
  1106. ChTraits::PCXSTR pStrEnd=pStr + nStrLen;
  1107. const ChTraits::XCHAR* pMatch;
  1108. const ChTraits::XCHAR* pStart = pStr;
  1109. while ((pMatch = ChTraits::strchr(pStart, *pCharSet)) != NULL)
  1110. {
  1111. size_t nCharsLeftInStr=pStrEnd - pMatch;
  1112. if (nCharsLeftInStr < nCharSetLen)
  1113. {
  1114. break;
  1115. }
  1116. if (memcmp(pMatch, pCharSet, nCharSetLen*sizeof(ChTraits::XCHAR)) == 0)
  1117. {
  1118. return pMatch;
  1119. }
  1120. pStart = ChTraits::CharNext(pMatch);
  1121. }
  1123. return NULL;
  1124. }
  1126. template< typename _BaseType = char, class StringIterator = ChTraitsOS< _BaseType > >
  1127. class StrTraitATL : public StringIterator
  1128. {
  1129. public:
  1130. static HINSTANCE FindStringResourceInstance(__in UINT nID) throw()
  1131. {
  1132. return( AtlFindStringResourceInstance( nID ) );
  1133. }
  1135. static IAtlStringMgr* GetDefaultManager() throw()
  1136. {
  1137. return( &g_strmgr );
  1138. }
  1139. };
  1141. #if !defined(_ATL_CSTRING_NO_CRT) && defined(_ATL_MIN_CRT)
  1142. #define _ATL_CSTRING_NO_CRT
  1143. #endif
  1145. #ifndef _ATL_CSTRING_NO_CRT
  1146. typedef CStringT< wchar_t, StrTraitATL< wchar_t, ChTraitsCRT< wchar_t > > > CAtlStringW;
  1147. typedef CStringT< char, StrTraitATL< char, ChTraitsCRT< char > > > CAtlStringA;
  1148. typedef CStringT< TCHAR, StrTraitATL< TCHAR, ChTraitsCRT< TCHAR > > > CAtlString;
  1149. #else  // _ATL_CSTRING_NO_CRT
  1150. typedef CStringT< wchar_t, StrTraitATL< wchar_t > > CAtlStringW;
  1151. typedef CStringT< char, StrTraitATL< char > > CAtlStringA;
  1152. typedef CStringT< TCHAR, StrTraitATL< TCHAR > > CAtlString;
  1153. #endif  // _ATL_CSTRING_NO_CRT
  1155. #ifndef _AFX
  1156. typedef CAtlStringW CStringW;
  1157. typedef CAtlStringA CStringA;
  1158. typedef CAtlString CString;
  1159. #endif
  1161. template< typename T >
  1162. class CElementTraits;
  1164. template<>
  1165. class CElementTraits< ATL::CAtlStringA > :
  1166. public CStringElementTraits< ATL::CAtlStringA >
  1167. {
  1168. };
  1170. template<>
  1171. class CElementTraits< ATL::CAtlStringW > :
  1172. public CStringElementTraits< ATL::CAtlStringW >
  1173. {
  1174. };
  1176. }; //namespace ATL
  1178. #pragma pack(pop)
  1179. #endif // __ATLSTR_H__
  1181. /////////////////////////////////////////////////////////////////////////////