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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 杀毒 > 查看源码
StdString.h
资源名称：10040637740.zip　[点击查看]
上传用户：lswyart
上传日期：2008-06-12
资源大小：3441k
文件大小：87k
源码类别：

杀毒

开发平台：

Visual C++

StdString.h：源码内容
  1. /*-----------------------------------------------------------------------------
  2. # Name:        StdString.h
  3. # Product:     ClamWin Antivirus
  4. # Licence:     
  5. #   This program is free software; you can redistribute it and/or modify
  6. #   it under the terms of the GNU General Public License as published by
  7. #   the Free Software Foundation; either version 2 of the License, or
  8. #   (at your option) any later version.
  9. # 
  10. #   This program is distributed in the hope that it will be useful,
  11. #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. #   GNU General Public License for more details.
  14. # 
  15. #   You should have received a copy of the GNU General Public License
  16. #   along with this program; if not, write to the Free Software
  17. #   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. #-----------------------------------------------------------------------------
  19. */
  21. // =============================================================================
  22. //  FILE:  StdString.h
  23. //  AUTHOR: Joe O'Leary (with outside help noted in comments)
  24. //  REMARKS:
  25. // This header file declares the CStdStr template.  This template derives
  26. // the Standard C++ Library basic_string<> template and add to it the
  27. // the following conveniences:
  28. // - The full MFC CString set of functions (including implicit cast)
  29. // - writing to/reading from COM IStream interfaces
  30. // - Functional objects for use in STL algorithms
  31. //
  32. // From this template, we intstantiate two classes:  CStdStringA and
  33. // CStdStringW.  The name "CStdString" is just a #define of one of these,
  34. // based upone the _UNICODE macro setting
  35. //
  36. // This header also declares our own version of the MFC/ATL UNICODE-MBCS
  37. // conversion macros.  Our version looks exactly like the Microsoft's to
  38. // facilitate portability.
  39. //
  40. // NOTE:
  41. // If you you use this in an MFC or ATL build, you should include either
  42. // afx.h or atlbase.h first, as appropriate.
  43. //
  44. // PEOPLE WHO HAVE CONTRIBUTED TO THIS CLASS:
  45. //
  46. // Several people have helped me iron out problems and othewise improve
  47. // this class.  OK, this is a long list but in my own defense, this code
  48. // has undergone two major rewrites.  Many of the improvements became
  49. // necessary after I rewrote the code as a template.  Others helped me
  50. // improve the CString facade.
  51. //
  52. // Anyway, these people are (in chronological order):
  53. //
  54. // - Pete the Plumber (???)
  55. // - Julian Selman
  56. // - Chris (of Melbsys)
  57. // - Dave Plummer
  58. // - John C Sipos
  59. // - Chris Sells
  60. // - Nigel Nunn
  61. // - Fan Xia
  62. // - Matthew Williams
  63. // - Carl Engman
  64. // - Mark Zeren
  65. // - Craig Watson
  66. // - Rich Zuris
  67. // - Karim Ratib
  68. // - Chris Conti
  69. // - Baptiste Lepilleur
  70. // - Greg Pickles
  71. // - Jim Cline
  72. // - Jeff Kohn
  73. // - Todd Heckel
  74. // - Ullrich Poll鋒ne
  75. // - Joe Vitaterna
  76. // - Joe Woodbury
  77. // - Aaron (no last name)
  78. // - Joldakowski (???)
  79. // - Scott Hathaway
  80. // - Eric Nitzche
  81. // - Pablo Presedo
  82. //
  83. // REVISION HISTORY
  84. //   2001-APR-27 - StreamLoad was calculating the number of BYTES in one
  85. // case, not characters.  Thanks to Pablo Presedo for this.
  86. //
  87. //    2001-FEB-23 - Replace() had a bug which caused infinite loops if the
  88. // source string was empty.  Fixed thanks to Eric Nitzsche.
  89. //
  90. //    2001-FEB-23 - Scott Hathaway was a huge help in providing me with the
  91. // ability to build CStdString on Sun Unix systems.  He
  92. // sent me detailed build reports about what works and what
  93. // does not.  If CStdString compiles on your Unix box, you
  94. // can thank Scott for it.
  95. //
  96. //   2000-DEC-29 - Joldakowski noticed one overload of Insert failed to do
  97. // range check as CString's does.  Now fixed -- thanks!
  98. //
  99. //   2000-NOV-07 - Aaron pointed out that I was calling static member
  100. // functions of char_traits via a temporary.  This was not
  101. // technically wrong, but it was unnecessary and caused
  102. // problems for poor old buggy VC5.  Thanks Aaron!
  103. //
  104. //   2000-JUL-11 - Joe Woodbury noted that the CString::Find docs don't match
  105. // what the CString::Find code really ends up doing.   I was
  106. // trying to match the docs.  Now I match the CString code
  107. //   - Joe also caught me truncating strings for GetBuffer() calls
  108. // when the supplied length was less than the current length.
  109. //
  110. //   2000-MAY-25 - Better support for STLPORT's Standard library distribution
  111. //   - Got rid of the NSP macro - it interfered with Koenig lookup
  112. //   - Thanks to Joe Woodbury for catching a TrimLeft() bug that
  113. // I introduced in January.  Empty strings were not getting
  114. // trimmed
  115. //
  116. //   2000-APR-17 - Thanks to Joe Vitaterna for pointing out that ReverseFind
  117. // is supposed to be a const function.
  118. //
  119. //   2000-MAR-07 - Thanks to Ullrich Poll鋒ne for catching a range bug in one
  120. // of the overloads of assign.
  121. //
  122. //    2000-FEB-01 - You can now use CStdString on the Mac with CodeWarrior!
  123. // Thanks to Todd Heckel for helping out with this.
  124. //
  125. //   2000-JAN-23 - Thanks to Jim Cline for pointing out how I could make the
  126. // Trim() function more efficient.
  127. //   - Thanks to Jeff Kohn for prompting me to find and fix a typo
  128. // in one of the addition operators that takes _bstr_t.
  129. //   - Got rid of the .CPP file -  you only need StdString.h now!
  130. //
  131. //   1999-DEC-22 - Thanks to Greg Pickles for helping me identify a problem
  132. // with my implementation of CStdString::FormatV in which
  133. // resulting string might not be properly NULL terminated.
  134. //
  135. //   1999-DEC-06 - Chris Conti pointed yet another basic_string<> assignment
  136. // bug that MS has not fixed.  CStdString did nothing to fix
  137. // it either but it does now!  The bug was: create a string
  138. // longer than 31 characters, get a pointer to it (via c_str())
  139. // and then assign that pointer to the original string object.
  140. // The resulting string would be empty.  Not with CStdString!
  141. //
  142. //   1999-OCT-06 - BufferSet was erasing the string even when it was merely
  143. // supposed to shrink it.  Fixed.  Thanks to Chris Conti.
  144. //   - Some of the Q172398 fixes were not checking for assignment-
  145. // to-self.  Fixed.  Thanks to Baptiste Lepilleur.
  146. //
  147. //   1999-AUG-20 - Improved Load() function to be more efficient by using 
  148. // SizeOfResource().  Thanks to Rich Zuris for this.
  149. //   - Corrected resource ID constructor, again thanks to Rich.
  150. //   - Fixed a bug that occurred with UNICODE characters above
  151. // the first 255 ANSI ones.  Thanks to Craig Watson. 
  152. //   - Added missing overloads of TrimLeft() and TrimRight().
  153. // Thanks to Karim Ratib for pointing them out
  154. //
  155. //   1999-JUL-21 - Made all calls to GetBuf() with no args check length first.
  156. //
  157. //   1999-JUL-10 - Improved MFC/ATL independence of conversion macros
  158. //   - Added SS_NO_REFCOUNT macro to allow you to disable any
  159. // reference-counting your basic_string<> impl. may do.
  160. //   - Improved ReleaseBuffer() to be as forgiving as CString.
  161. // Thanks for Fan Xia for helping me find this and to
  162. // Matthew Williams for pointing it out directly.
  163. //
  164. //   1999-JUL-06 - Thanks to Nigel Nunn for catching a very sneaky bug in
  165. // ToLower/ToUpper.  They should call GetBuf() instead of
  166. // data() in order to ensure the changed string buffer is not
  167. // reference-counted (in those implementations that refcount).
  168. //
  169. //   1999-JUL-01 - Added a true CString facade.  Now you can use CStdString as
  170. // a drop-in replacement for CString.  If you find this useful,
  171. // you can thank Chris Sells for finally convincing me to give
  172. // in and implement it.
  173. //   - Changed operators << and >> (for MFC CArchive) to serialize
  174. // EXACTLY as CString's do.  So now you can send a CString out
  175. // to a CArchive and later read it in as a CStdString.   I have
  176. // no idea why you would want to do this but you can. 
  177. //
  178. //   1999-JUN-21 - Changed the CStdString class into the CStdStr template.
  179. //   - Fixed FormatV() to correctly decrement the loop counter.
  180. // This was harmless bug but a bug nevertheless.  Thanks to
  181. // Chris (of Melbsys) for pointing it out
  182. //   - Changed Format() to try a normal stack-based array before
  183. // using to _alloca().
  184. //   - Updated the text conversion macros to properly use code
  185. // pages and to fit in better in MFC/ATL builds.  In other
  186. // words, I copied Microsoft's conversion stuff again. 
  187. //   - Added equivalents of CString::GetBuffer, GetBufferSetLength
  188. //   - new sscpy() replacement of CStdString::CopyString()
  189. //   - a Trim() function that combines TrimRight() and TrimLeft().
  190. //
  191. //   1999-MAR-13 - Corrected the "NotSpace" functional object to use _istpace()
  192. // instead of _isspace()   Thanks to Dave Plummer for this.
  193. //
  194. //   1999-FEB-26 - Removed errant line (left over from testing) that #defined
  195. // _MFC_VER.  Thanks to John C Sipos for noticing this.
  196. //
  197. //   1999-FEB-03 - Fixed a bug in a rarely-used overload of operator+() that
  198. // caused infinite recursion and stack overflow
  199. //   - Added member functions to simplify the process of
  200. // persisting CStdStrings to/from DCOM IStream interfaces 
  201. //   - Added functional objects (e.g. StdStringLessNoCase) that
  202. // allow CStdStrings to be used as keys STL map objects with
  203. // case-insensitive comparison 
  204. //   - Added array indexing operators (i.e. operator[]).  I
  205. // originally assumed that these were unnecessary and would be
  206. // inherited from basic_string.  However, without them, Visual
  207. // C++ complains about ambiguous overloads when you try to use
  208. // them.  Thanks to Julian Selman to pointing this out. 
  209. //
  210. //   1998-FEB-?? - Added overloads of assign() function to completely account
  211. // for Q172398 bug.  Thanks to "Pete the Plumber" for this
  212. //
  213. //   1998-FEB-?? - Initial submission
  214. //
  215. // COPYRIGHT:
  216. // 1999 Joseph M. O'Leary.  This code is free.  Use it anywhere you want.
  217. // Rewrite it, restructure it, whatever.  Please don't blame me if it makes
  218. // your $30 billion dollar satellite explode in orbit.  If you redistribute
  219. // it in any form, I'd appreciate it if you would leave this notice here.
  220. //
  221. // If you find any bugs, please let me know:
  222. //
  223. // jmoleary@earthlink.net
  224. // http://home.earthlink.net/~jmoleary
  225. // =============================================================================
  227. // Avoid multiple inclusion the VC++ way,
  228. // Turn off browser references
  229. // Turn off unavoidable compiler warnings
  231. #if defined(_MSC_VER) && (_MSC_VER > 1100)
  232. #pragma once
  233. #pragma component(browser, off, references, "CStdString")
  234. #pragma warning (disable : 4290) // C++ Exception Specification ignored
  235. #pragma warning (disable : 4127) // Conditional expression is constant
  236. #pragma warning (disable : 4097) // typedef name used as synonym for class name
  237. #endif
  239. #ifndef STDSTRING_H
  240. #define STDSTRING_H
  242. // MACRO: SS_NO_REFCOUNT:
  243. // turns off reference counting at the assignment level
  244. // I define this by default.  comment it out if you don't want it.
  246. #define SS_NO_REFCOUNT
  248. // In non-Visual C++ and/or non-Win32 builds, we can't use some cool stuff.
  250. #if !defined(_MSC_VER) || !defined(_WIN32)
  251. #define SS_ANSI
  252. #endif
  254. // Avoid legacy code screw up: if _UNICODE is defined, UNICODE must be as well
  256. #if defined (_UNICODE) && !defined (UNICODE)
  257. #define UNICODE
  258. #endif
  259. #if defined (UNICODE) && !defined (_UNICODE)
  260. #define _UNICODE
  261. #endif
  263. // -----------------------------------------------------------------------------
  264. // MIN and MAX.  The Standard C++ template versions go by so many names (at
  265. // at least in the MS implementation) that you never know what's available 
  266. // -----------------------------------------------------------------------------
  267. template<class Type>
  268. inline const Type& SSMIN(const Type& arg1, const Type& arg2)
  269. {
  270. return arg2 < arg1 ? arg2 : arg1;
  271. }
  272. template<class Type>
  273. inline const Type& SSMAX(const Type& arg1, const Type& arg2)
  274. {
  275. return arg2 > arg1 ? arg2 : arg1;
  276. }
  278. // If they have not #included W32Base.h (part of my W32 utility library) then
  279. // we need to define some stuff.  Otherwise, this is all defined there.
  281. #if !defined(W32BASE_H)
  283. // If they want us to use only standard C++ stuff (no Win32 stuff)
  285. #ifdef SS_ANSI
  287. // On non-Win32 platforms, there is no TCHAR.H so define what we need
  289. #ifndef _WIN32
  291. typedef const char* PCSTR;
  292. typedef char* PSTR;
  293. typedef const wchar_t* PCWSTR;
  294. typedef wchar_t* PWSTR;
  295. #ifdef UNICODE
  296. typedef wchar_t TCHAR;
  297. #else
  298. typedef char TCHAR;
  299. #endif
  300. typedef wchar_t OLECHAR;
  302. #else
  304. #include <TCHAR.H>
  305. #include <WTYPES.H>
  306. #ifndef STRICT
  307. #define STRICT
  308. #endif
  310. #endif // #ifndef _WIN32
  313. // Make sure ASSERT and verify are defined in an ANSI fashion
  315. #ifndef ASSERT
  316. #include <assert.h>
  317. #define ASSERT(f) assert((f))
  318. #endif
  319. #ifndef VERIFY
  320. #ifdef _DEBUG
  321. #define VERIFY(x) ASSERT((x))
  322. #else
  323. #define VERIFY(x) x
  324. #endif
  325. #endif
  327. #else // #ifdef SS_ANSI
  329. #include <TCHAR.H>
  330. #include <WTYPES.H>
  331. #ifndef STRICT
  332. #define STRICT
  333. #endif
  335. // Make sure ASSERT and verify are defined
  337. #ifndef ASSERT
  338. #include <crtdbg.h>
  339. #define ASSERT(f) _ASSERTE((f))
  340. #endif
  341. #ifndef VERIFY
  342. #ifdef _DEBUG
  343. #define VERIFY(x) ASSERT((x))
  344. #else
  345. #define VERIFY(x) x
  346. #endif
  347. #endif
  349. #endif // #ifdef SS_ANSI
  351. #ifndef UNUSED
  352. #define UNUSED(x) x
  353. #endif
  355. #endif // #ifndef W32BASE_H
  357. // Standard headers needed
  359. #include <string> // basic_string
  360. #include <algorithm> // for_each, etc.
  361. #include <functional> // for StdStringLessNoCase, et al
  362. #include <locale> // for various facets
  364. // If this is a recent enough version of VC include comdef.h, so we can write
  365. // member functions to deal with COM types & compiler support classes e.g. _bstr_t
  367. #if defined (_INCLUDE_COMDEF) && (_MSC_VER) && (_MSC_VER >= 1100)
  368. #include <comdef.h>
  369. #define SS_INC_COMDEF // signal that we #included MS comdef.h file
  370. #define STDSTRING_INC_COMDEF
  371. #define SS_NOTHROW __declspec(nothrow)
  372. #else
  373. #define SS_NOTHROW
  374. #endif
  376. #ifndef TRACE
  377. #define TRACE_DEFINED_HERE
  378. #define TRACE
  379. #endif
  381. // Microsoft defines PCSTR, PCWSTR, etc, but no PCTSTR.  I hate to use the
  382. // versions with the "L" in front of them because that's a leftover from Win 16
  383. // days, even though it evaluates to the same thing.  Therefore, Define a PCSTR
  384. // as an LPCTSTR.
  386. #if !defined(PCTSTR) && !defined(PCTSTR_DEFINED)
  387. typedef const TCHAR* PCTSTR;
  388. #define PCTSTR_DEFINED
  389. #endif
  391. #if !defined(PCOLESTR) && !defined(PCOLESTR_DEFINED)
  392. typedef const OLECHAR* PCOLESTR;
  393. #define PCOLESTR_DEFINED
  394. #endif
  396. #if !defined(POLESTR) && !defined(POLESTR_DEFINED)
  397. typedef OLECHAR* POLESTR;
  398. #define POLESTR_DEFINED
  399. #endif
  401. #if !defined(PCUSTR) && !defined(PCUSTR_DEFINED)
  402. typedef const unsigned char* PCUSTR;
  403. typedef unsigned char* PUSTR;
  404. #define PCUSTR_DEFINED
  405. #endif
  407. // SS_USE_FACET macro and why we need it:
  408. //
  409. // Since I'm a good little Standard C++ programmer, I use locales.  Thus, I
  410. // need to make use of the use_facet<> template function here.   Unfortunately,
  411. // this need is complicated by the fact the MS' implementation of the Standard
  412. // C++ Library has a non-standard version of use_facet that takes more
  413. // arguments than the standard dictates.  Since I'm trying to write CStdString
  414. // to work with any version of the Standard library, this presents a problem.
  415. //
  416. // The upshot of this is that I can't do 'use_facet' directly.  The MS' docs
  417. // tell me that I have to use a macro, _USE() instead.  Since _USE obviously
  418. // won't be available in other implementations, this means that I have to write
  419. // my OWN macro -- SS_USE_FACET -- that evaluates either to _USE or to the
  420. // standard, use_facet.
  421. //
  422. // If you are having trouble with the SS_USE_FACET macro, in your implementation
  423. // of the Standard C++ Library, you can define your own version of SS_USE_FACET.
  424. #ifndef schMSG
  425. #define schSTR(x)    #x
  426. #define schSTR2(x) schSTR(x)
  427. #define schMSG(desc) message(__FILE__ "(" schSTR2(__LINE__) "):" #desc)
  428. #endif
  430. #ifndef SS_USE_FACET
  431. // STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for
  432. // all MSVC builds, erroneously in my opinion.  It causes problems for
  433. // my SS_ANSI builds.  In my code, I always comment out that line.  You'll
  434. // find it in   stlportconfigstl_msvc.h
  435. #if defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= 0x400 )
  436. #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && defined(_MSC_VER)
  437. #ifdef SS_ANSI
  438. #pragma schMSG(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS defined!!)
  439. #endif
  440. #endif
  441. #define SS_USE_FACET(loc, fac) std::use_facet<fac >(loc)
  442. #elif defined(_MSC_VER )
  443. #define SS_USE_FACET(loc, fac) _USE(loc, fac)
  445. // ...and
  446. #elif defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE)
  447.         #define SS_USE_FACET(loc, fac) std::use_facet(loc, (fac*)0)
  448. #else
  449. #define SS_USE_FACET(loc, fac) std::use_facet<fac >(loc)
  450. #endif
  451. #endif
  453. // =============================================================================
  454. // UNICODE/MBCS conversion macros.  Made to work just like the MFC/ATL ones.
  455. // =============================================================================
  457. // First define the conversion helper functions.  We define these regardless of
  458. // any preprocessor macro settings since their names won't collide. 
  460. #ifdef SS_ANSI // Are we doing things the standard, non-Win32 way?...
  462. typedef std::codecvt<wchar_t, char, mbstate_t> SSCodeCvt;
  464. // Not sure if we need all these headers.   I believe ANSI says we do.
  466. #include <stdio.h>
  467. #include <stdarg.h>
  468. #include <wchar.h>
  469. #ifndef va_start
  470. #include <varargs.h>
  471. #endif
  473. // StdCodeCvt - made to look like Win32 functions WideCharToMultiByte annd
  474. //              MultiByteToWideChar but uses locales in SS_ANSI builds
  475. inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars,
  476. const std::locale& loc=std::locale())
  477. {
  478. ASSERT(0 != pA);
  479. ASSERT(0 != pW);
  480. pW[0] = '';
  481. PCSTR pBadA = 0;
  482. PWSTR pBadW = 0;
  483. SSCodeCvt::result res = SSCodeCvt::ok;
  484. const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt);
  485.         SSCodeCvt::state_type st= { 0 };
  486. res = conv.in(st,
  487.   pA, pA + nChars, pBadA,
  488.   pW, pW + nChars, pBadW);
  489. ASSERT(SSCodeCvt::ok == res);
  490. return pW;
  491. }
  492. inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars,
  493. const std::locale& loc=std::locale())
  494. {
  495. return StdCodeCvt(pW, (PCSTR)pA, nChars, loc);
  496. }
  498. inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars,
  499. const std::locale& loc=std::locale())
  500. {
  501. ASSERT(0 != pA);
  502. ASSERT(0 != pW);
  503. pA[0] = '';
  504. PSTR pBadA = 0;
  505. PCWSTR pBadW = 0;
  506. SSCodeCvt::result res = SSCodeCvt::ok;
  507. const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt);
  508.         SSCodeCvt::state_type st= { 0 };
  509. res = conv.out(st,
  510.    pW, pW + nChars, pBadW,
  511.    pA, pA + nChars, pBadA);
  512. ASSERT(SSCodeCvt::ok == res);
  513. return pA;
  514. }
  515. inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars,
  516. const std::locale& loc=std::locale())
  517. {
  518. return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, loc);
  519. }
  521. #else   // ...or are we doing things assuming win32 and Visual C++?
  523. #include <malloc.h> // needed for _alloca
  525. inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars, UINT acp=CP_ACP)
  526. {
  527. ASSERT(0 != pA);
  528. ASSERT(0 != pW);
  529. pW[0] = '';
  530. MultiByteToWideChar(acp, 0, pA, -1, pW, nChars);
  531. return pW;
  532. }
  533. inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars, UINT acp=CP_ACP)
  534. {
  535. return StdCodeCvt(pW, (PCSTR)pA, nChars, acp);
  536. }
  538. inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP)
  539. {
  540. ASSERT(0 != pA);
  541. ASSERT(0 != pW);
  542. pA[0] = '';
  543. WideCharToMultiByte(acp, 0, pW, -1, pA, nChars, 0, 0);
  544. return pA;
  545. }
  546. inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP)
  547. {
  548. return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, acp);
  549. }
  551. // Define our conversion macros to look exactly like Microsoft's to
  552. // facilitate using this stuff both with and without MFC/ATL
  554. #ifdef _CONVERSION_USES_THREAD_LOCALE
  555. #ifndef _DEBUG
  556. #define SSCVT int _cvt; _cvt; UINT _acp=GetACP(); 
  557. _acp; PCWSTR _pw; _pw; PCSTR _pa; _pa
  558. #else
  559. #define SSCVT int _cvt = 0; _cvt; UINT _acp=GetACP();
  560.  _acp; PCWSTR _pw=0; _pw; PCSTR _pa=0; _pa
  561. #endif
  562. #else
  563. #ifndef _DEBUG
  564. #define SSCVT int _cvt; _cvt; UINT _acp=CP_ACP; _acp;
  565.  PCWSTR _pw; _pw; PCSTR _pa; _pa
  566. #else
  567. #define SSCVT int _cvt = 0; _cvt; UINT _acp=CP_ACP; 
  568. _acp; PCWSTR _pw=0; _pw; PCSTR _pa=0; _pa
  569. #endif
  570. #endif
  572. #ifdef _CONVERSION_USES_THREAD_LOCALE
  573. #define SSA2W(pa) (
  574. ((_pa = pa) == 0) ? 0 : (
  575. _cvt = (strlen(_pa)+1),
  576. StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt, _acp)))
  577. #define SSW2A(pw) (
  578. ((_pw = pw) == 0) ? 0 : (
  579. _cvt = (wcslen(_pw)+1)*2,
  580. StdW2AHelper((LPSTR) _alloca(_cvt), _pw, _cvt, _acp)))
  581. #else
  582. #define SSA2W(pa) (
  583. ((_pa = pa) == 0) ? 0 : (
  584. _cvt = (strlen(_pa)+1),
  585. StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt)))
  586. #define SSW2A(pw) (
  587. ((_pw = pw) == 0) ? 0 : (
  588. _cvt = (wcslen(_pw)+1)*2,
  589. StdCodeCvt((LPSTR) _alloca(_cvt), _pw, _cvt)))
  590. #endif
  592. #define SSA2CW(pa) ((PCWSTR)SSA2W((pa)))
  593. #define SSW2CA(pw) ((PCSTR)SSW2A((pw)))
  595. #ifdef UNICODE
  596. #define SST2A SSW2A
  597. #define SSA2T SSA2W
  598. #define SST2CA SSW2CA
  599. #define SSA2CT SSA2CW
  600. inline PWSTR SST2W(PTSTR p) { return p; }
  601. inline PTSTR SSW2T(PWSTR p) { return p; }
  602. inline PCWSTR SST2CW(PCTSTR p) { return p; }
  603. inline PCTSTR SSW2CT(PCWSTR p) { return p; }
  604. #else
  605. #define SST2W SSA2W
  606. #define SSW2T SSW2A
  607. #define SST2CW SSA2CW
  608. #define SSW2CT SSW2CA
  609. inline PSTR SST2A(PTSTR p) { return p; }
  610. inline PTSTR SSA2T(PSTR p) { return p; }
  611. inline PCSTR SST2CA(PCTSTR p) { return p; }
  612. inline PCTSTR SSA2CT(PCSTR p) { return p; }
  613. #endif // #ifdef UNICODE
  615. #if defined(UNICODE)
  616. // in these cases the default (TCHAR) is the same as OLECHAR
  617. inline PCOLESTR SST2COLE(PCTSTR p) { return p; }
  618. inline PCTSTR SSOLE2CT(PCOLESTR p) { return p; }
  619. inline POLESTR SST2OLE(PTSTR p) { return p; }
  620. inline PTSTR SSOLE2T(POLESTR p) { return p; }
  621. #elif defined(OLE2ANSI)
  622. // in these cases the default (TCHAR) is the same as OLECHAR
  623. inline PCOLESTR SST2COLE(PCTSTR p) { return p; }
  624. inline PCTSTR SSOLE2CT(PCOLESTR p) { return p; }
  625. inline POLESTR SST2OLE(PTSTR p) { return p; }
  626. inline PTSTR SSOLE2T(POLESTR p) { return p; }
  627. #else
  628. //CharNextW doesn't work on Win95 so we use this
  629. #define SST2COLE(pa) SSA2CW((pa))
  630. #define SST2OLE(pa) SSA2W((pa))
  631. #define SSOLE2CT(po) SSW2CA((po))
  632. #define SSOLE2T(po) SSW2A((po))
  633. #endif
  635. #ifdef OLE2ANSI
  636. #define SSW2OLE SSW2A
  637. #define SSOLE2W SSA2W
  638. #define SSW2COLE SSW2CA
  639. #define SSOLE2CW SSA2CW
  640. inline POLESTR SSA2OLE(PSTR p) { return p; }
  641. inline PSTR SSOLE2A(POLESTR p) { return p; }
  642. inline PCOLESTR SSA2COLE(PCSTR p) { return p; }
  643. inline PCSTR SSOLE2CA(PCOLESTR p){ return p; }
  644. #else
  645. #define SSA2OLE SSA2W
  646. #define SSOLE2A SSW2A
  647. #define SSA2COLE SSA2CW
  648. #define SSOLE2CA SSW2CA
  649. inline POLESTR SSW2OLE(PWSTR p) { return p; }
  650. inline PWSTR SSOLE2W(POLESTR p) { return p; }
  651. inline PCOLESTR SSW2COLE(PCWSTR p) { return p; }
  652. inline PCWSTR SSOLE2CW(PCOLESTR p){ return p; }
  653. #endif
  655. // Above we've defined macros that look like MS' but all have
  656. // an 'SS' prefix.  Now we need the real macros.  We'll either
  657. // get them from the macros above or from MFC/ATL.  If
  658. // SS_NO_CONVERSION is #defined, we'll forgo them
  660. #ifndef SS_NO_CONVERSION
  662. #if defined (USES_CONVERSION)
  664. #define _NO_STDCONVERSION // just to be consistent
  666. #else
  668. #ifdef _MFC_VER
  670. #include <afxconv.h>
  671. #define _NO_STDCONVERSION // just to be consistent
  673. #else
  675. #define USES_CONVERSION SSCVT
  676. #define A2CW SSA2CW
  677. #define W2CA SSW2CA
  678. #define T2A SST2A
  679. #define A2T SSA2T
  680. #define T2W SST2W
  681. #define W2T SSW2T
  682. #define T2CA SST2CA
  683. #define A2CT SSA2CT
  684. #define T2CW SST2CW
  685. #define W2CT SSW2CT
  686. #define ocslen sslen
  687. #define ocscpy sscpy
  688. #define T2COLE SST2COLE
  689. #define OLE2CT SSOLE2CT
  690. #define T2OLE SST2COLE
  691. #define OLE2T SSOLE2CT
  692. #define A2OLE SSA2OLE
  693. #define OLE2A SSOLE2A
  694. #define W2OLE SSW2OLE
  695. #define OLE2W SSOLE2W
  696. #define A2COLE SSA2COLE
  697. #define OLE2CA SSOLE2CA
  698. #define W2COLE SSW2COLE
  699. #define OLE2CW SSOLE2CW
  701. #endif // #ifdef _MFC_VER
  702. #endif // #ifndef USES_CONVERSION
  703. #endif // #ifndef SS_NO_CONVERSION
  705. // Define ostring - generic name for std::basic_string<OLECHAR>
  707. #if !defined(ostring) && !defined(OSTRING_DEFINED)
  708. typedef std::basic_string<OLECHAR> ostring;
  709. #define OSTRING_DEFINED
  710. #endif
  712. #endif // #ifndef SS_ANSI
  714. // StdCodeCvt when there's no conversion to be done
  715. inline PSTR StdCodeCvt(PSTR pDst, PCSTR pSrc, int nChars)
  716. {
  717. pDst[0] = '';
  718. std::char_traits<char>::copy(pDst, pSrc, nChars);
  719. if ( nChars > 0 )
  720. pDst[nChars] = '';
  722. return pDst;
  723. }
  724. inline PSTR StdCodeCvt(PSTR pDst, PCUSTR pSrc, int nChars)
  725. {
  726. return StdCodeCvt(pDst, (PCSTR)pSrc, nChars);
  727. }
  728. inline PUSTR StdCodeCvt(PUSTR pDst, PCSTR pSrc, int nChars)
  729. {
  730. return (PUSTR)StdCodeCvt((PSTR)pDst, pSrc, nChars);
  731. }
  733. inline PWSTR StdCodeCvt(PWSTR pDst, PCWSTR pSrc, int nChars)
  734. {
  735. pDst[0] = '';
  736. std::char_traits<wchar_t>::copy(pDst, pSrc, nChars);
  737. if ( nChars > 0 )
  738. pDst[nChars] = '';
  740. return pDst;
  741. }
  744. // Define tstring -- generic name for std::basic_string<TCHAR>
  746. #if !defined(tstring) && !defined(TSTRING_DEFINED)
  747. typedef std::basic_string<TCHAR> tstring;
  748. #define TSTRING_DEFINED
  749. #endif
  751. // a very shorthand way of applying the fix for KB problem Q172398
  752. // (basic_string assignment bug)
  754. #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )
  755. #define Q172398(x) (x).erase()
  756. #else
  757. #define Q172398(x)
  758. #endif
  760. // =============================================================================
  761. // INLINE FUNCTIONS ON WHICH CSTDSTRING RELIES
  762. //
  763. // Usually for generic text mapping, we rely on preprocessor macro definitions
  764. // to map to string functions.  However the CStdStr<> template cannot use
  765. // macro-based generic text mappings because its character types do not get
  766. // resolved until template processing which comes AFTER macro processing.  In
  767. // other words, UNICODE is of little help to us in the CStdStr template
  768. //
  769. // Therefore, to keep the CStdStr declaration simple, we have these inline
  770. // functions.  The template calls them often.  Since they are inline (and NOT
  771. // exported when this is built as a DLL), they will probably be resolved away
  772. // to nothing. 
  773. //
  774. // Without these functions, the CStdStr<> template would probably have to broken
  775. // out into two, almost identical classes.  Either that or it would be a huge,
  776. // convoluted mess, with tons of "if" statements all over the place checking the
  777. // size of template parameter CT.
  778. // 
  779. // In several cases, you will see two versions of each function.  One version is
  780. // the more portable, standard way of doing things, while the other is the
  781. // non-standard, but often significantly faster Visual C++ way.
  782. // =============================================================================
  784. // If they defined SS_NO_REFCOUNT, then we must convert all assignments
  786. #ifdef SS_NO_REFCOUNT
  787. #define SSREF(x) (x).c_str()
  788. #else
  789. #define SSREF(x) (x)
  790. #endif
  792. // -----------------------------------------------------------------------------
  793. // sslen: strlen/wcslen wrappers
  794. // -----------------------------------------------------------------------------
  795. template<typename CT> inline int sslen(const CT* pT)
  796. {
  797. return 0 == pT ? 0 : std::char_traits<CT>::length(pT);
  798. }
  799. inline SS_NOTHROW int sslen(const std::string& s)
  800. {
  801. return s.length();
  802. }
  803. inline SS_NOTHROW int sslen(const std::wstring& s)
  804. {
  805. return s.length();
  806. }
  809. // -----------------------------------------------------------------------------
  810. // ssasn: assignment functions -- assign "sSrc" to "sDst"
  811. // -----------------------------------------------------------------------------
  812. typedef std::string::size_type SS_SIZETYPE; // just for shorthand, really
  813. typedef std::string::pointer SS_PTRTYPE;  
  814. typedef std::wstring::size_type SW_SIZETYPE;
  815. typedef std::wstring::pointer SW_PTRTYPE;  
  817. inline void ssasn(std::string& sDst, const std::string& sSrc)
  818. {
  819. if ( sDst.c_str() != sSrc.c_str() )
  820. {
  821. sDst.erase();
  822. sDst.assign(SSREF(sSrc));
  823. }
  824. }
  825. inline void ssasn(std::string& sDst, PCSTR pA)
  826. {
  827. // Watch out for NULLs, as always.
  829. if ( 0 == pA )
  830. {
  831. sDst.erase();
  832. }
  834. // If pA actually points to part of sDst, we must NOT erase(), but
  835. // rather take a substring
  837. else if ( pA >= sDst.c_str() && pA <= sDst.c_str() + sDst.size() )
  838. {
  839. sDst =sDst.substr(static_cast<SS_SIZETYPE>(pA-sDst.c_str()));
  840. }
  842. // Otherwise (most cases) apply the assignment bug fix, if applicable
  843. // and do the assignment
  845. else
  846. {
  847. Q172398(sDst);
  848. sDst.assign(pA);
  849. }
  850. }
  851. inline void ssasn(std::string& sDst, const std::wstring& sSrc)
  852. {
  853. #ifdef SS_ANSI
  854. int nLen = sSrc.size();
  855. sDst.resize(0);
  856. sDst.resize(nLen);
  857. StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen);
  858. #else
  859. SSCVT;
  860. sDst.assign(SSW2CA(sSrc.c_str()));
  861. #endif
  862. }
  863. inline void ssasn(std::string& sDst, PCWSTR pW)
  864. {
  865. #ifdef SS_ANSI
  866. int nLen = sslen(pW);
  867. sDst.resize(0);
  868. sDst.resize(nLen);
  869. StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()), pW, nLen);
  870. #else
  871. SSCVT;
  872. sDst.assign(pW ? SSW2CA(pW) : "");
  873. #endif
  874. }
  875. inline void ssasn(std::string& sDst, const int nNull)
  876. {
  877. UNUSED(nNull);
  878. ASSERT(nNull==0);
  879. sDst.assign("");
  880. }
  881. inline void ssasn(std::wstring& sDst, const std::wstring& sSrc)
  882. {
  883. if ( sDst.c_str() != sSrc.c_str() )
  884. {
  885. sDst.erase();
  886. sDst.assign(SSREF(sSrc));
  887. }
  888. }
  889. inline void ssasn(std::wstring& sDst, PCWSTR pW)
  890. {
  891. // Watch out for NULLs, as always.
  893. if ( 0 == pW )
  894. {
  895. sDst.erase();
  896. }
  898. // If pW actually points to part of sDst, we must NOT erase(), but
  899. // rather take a substring
  901. else if ( pW >= sDst.c_str() && pW <= sDst.c_str() + sDst.size() )
  902. {
  903. sDst = sDst.substr(static_cast<SW_SIZETYPE>(pW-sDst.c_str()));
  904. }
  906. // Otherwise (most cases) apply the assignment bug fix, if applicable
  907. // and do the assignment
  909. else
  910. {
  911. Q172398(sDst);
  912. sDst.assign(pW);
  913. }
  914. }
  915. #undef StrSizeType
  916. inline void ssasn(std::wstring& sDst, const std::string& sSrc)
  917. {
  918. #ifdef SS_ANSI
  919. int nLen = sSrc.size();
  920. sDst.resize(0);
  921. sDst.resize(nLen);
  922. StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), sSrc.c_str(), nLen);
  923. #else
  924. SSCVT;
  925. sDst.assign(SSA2CW(sSrc.c_str()));
  926. #endif
  927. }
  928. inline void ssasn(std::wstring& sDst, PCSTR pA)
  929. {
  930. #ifdef SS_ANSI
  931. int nLen = sslen(pA);
  932. sDst.resize(0);
  933. sDst.resize(nLen);
  934. StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()), pA, nLen);
  935. #else
  936. SSCVT;
  937. sDst.assign(pA ? SSA2CW(pA) : L"");
  938. #endif
  939. }
  940. inline void ssasn(std::wstring& sDst, const int nNull)
  941. {
  942. UNUSED(nNull);
  943. ASSERT(nNull==0);
  944. sDst.assign(L"");
  945. }
  948. // -----------------------------------------------------------------------------
  949. // ssadd: string object concatenation -- add second argument to first
  950. // -----------------------------------------------------------------------------
  951. inline void ssadd(std::string& sDst, const std::wstring& sSrc)
  952. {
  953. #ifdef SS_ANSI
  954. int nLen = sSrc.size();
  955. sDst.resize(sDst.size() + nLen);
  956. StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nLen), sSrc.c_str(), nLen);
  957. #else
  958. SSCVT; 
  959. sDst.append(SSW2CA(sSrc.c_str())); 
  960. #endif
  961. }
  962. inline void ssadd(std::string& sDst, const std::string& sSrc)
  963. { 
  964. sDst.append(sSrc.c_str());
  965. }
  966. inline void ssadd(std::string& sDst, PCWSTR pW)
  967. {
  968. #ifdef SS_ANSI
  969. int nLen = sslen(pW);
  970. sDst.resize(sDst.size() + nLen);
  971. StdCodeCvt(const_cast<SS_PTRTYPE>(sDst.data()+nLen), pW, nLen);
  972. #else
  973. SSCVT;
  974. if ( 0 != pW )
  975. sDst.append(SSW2CA(pW)); 
  976. #endif
  977. }
  978. inline void ssadd(std::string& sDst, PCSTR pA)
  979. {
  980. if ( pA )
  981. sDst.append(pA); 
  982. }
  983. inline void ssadd(std::wstring& sDst, const std::wstring& sSrc)
  984. {
  985. sDst.append(sSrc.c_str());
  986. }
  987. inline void ssadd(std::wstring& sDst, const std::string& sSrc)
  988. {
  989. #ifdef SS_ANSI
  990. int nLen = sSrc.size();
  991. sDst.resize(sDst.size() + nLen);
  992. StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nLen), sSrc.c_str(), nLen);
  993. #else
  994. SSCVT;
  995. sDst.append(SSA2CW(sSrc.c_str()));
  996. #endif
  997. }
  998. inline void ssadd(std::wstring& sDst, PCSTR pA)
  999. {
  1000. #ifdef SS_ANSI
  1001. int nLen = sslen(pA);
  1002. sDst.resize(sDst.size() + nLen);
  1003. StdCodeCvt(const_cast<SW_PTRTYPE>(sDst.data()+nLen), pA, nLen);
  1004. #else
  1005. SSCVT;
  1006. if ( 0 != pA )
  1007. sDst.append(SSA2CW(pA));
  1008. #endif
  1009. }
  1010. inline void ssadd(std::wstring& sDst, PCWSTR pW)
  1011. {
  1012. if ( pW )
  1013. sDst.append(pW);
  1014. }
  1017. // -----------------------------------------------------------------------------
  1018. // ssicmp: comparison (case insensitive )
  1019. // -----------------------------------------------------------------------------
  1020. #ifdef SS_ANSI
  1021. template<typename CT>
  1022. inline int ssicmp(const CT* pA1, const CT* pA2)
  1023. {
  1024. std::locale loc;
  1025. const std::ctype<CT>& ct = SS_USE_FACET(loc, std::ctype<CT>);
  1026. CT f;
  1027. CT l;
  1029.             do 
  1030. {
  1031. f = ct.tolower(*(pA1++));
  1032. l = ct.tolower(*(pA2++));
  1033.             } while ( (f) && (f == l) );
  1035.         return (int)(f - l);
  1036. }
  1037. #else
  1038. #ifdef _MBCS
  1039. inline long sscmp(PCSTR pA1, PCSTR pA2)
  1040. {
  1041. return _mbscmp((PCUSTR)pA1, (PCUSTR)pA2);
  1042. }
  1043. inline long ssicmp(PCSTR pA1, PCSTR pA2)
  1044. {
  1045. return _mbsicmp((PCUSTR)pA1, (PCUSTR)pA2);
  1046. }
  1047. #else
  1048. inline long sscmp(PCSTR pA1, PCSTR pA2)
  1049. {
  1050. return strcmp(pA1, pA2);
  1051. }
  1052. inline long ssicmp(PCSTR pA1, PCSTR pA2)
  1053. {
  1054. return _stricmp(pA1, pA2);
  1055. }
  1056. #endif
  1057. inline long sscmp(PCWSTR pW1, PCWSTR pW2)
  1058. {
  1059. return wcscmp(pW1, pW2);
  1060. }
  1061. inline long ssicmp(PCWSTR pW1, PCWSTR pW2)
  1062. {
  1063. return _wcsicmp(pW1, pW2);
  1064. }
  1065. #endif
  1067. // -----------------------------------------------------------------------------
  1068. // ssupr/sslwr: Uppercase/Lowercase conversion functions
  1069. // -----------------------------------------------------------------------------
  1070. #ifdef SS_ANSI
  1071. template<typename CT>
  1072. inline void sslwr(CT* pT, size_t nLen)
  1073. {
  1074. SS_USE_FACET(std::locale(), std::ctype<CT>).tolower(pT, pT+nLen);
  1075. }
  1076. template<typename CT>
  1077. inline void ssupr(CT* pT, size_t nLen)
  1078. {
  1079. SS_USE_FACET(std::locale(), std::ctype<CT>).toupper(pT, pT+nLen);
  1080. }
  1081. #else  // #else we must be on Win32
  1082. #ifdef _MBCS
  1083. inline void ssupr(PSTR pA, size_t /*nLen*/)
  1084. {
  1085. _mbsupr((PUSTR)pA);
  1086. }
  1087. inline void sslwr(PSTR pA, size_t /*nLen*/)
  1088. {
  1089. _mbslwr((PUSTR)pA);
  1090. }
  1091. #else
  1092. inline void ssupr(PSTR pA, size_t /*nLen*/)
  1093. {
  1094. _strupr(pA); 
  1095. }
  1096. inline void sslwr(PSTR pA, size_t /*nLen*/)
  1097. {
  1098. _strlwr(pA);
  1099. }
  1100. #endif
  1101. inline void ssupr(PWSTR pW, size_t /*nLen*/)
  1102. {
  1103. _wcsupr(pW);
  1104. }
  1105. inline void sslwr(PWSTR pW, size_t /*nLen*/)
  1106. {
  1107. _wcslwr(pW);
  1108. }
  1109. #endif // #ifdef SS_ANSI
  1111. // -----------------------------------------------------------------------------
  1112. //  vsprintf/vswprintf or _vsnprintf/_vsnwprintf equivalents.  In standard
  1113. //  builds we can't use _vsnprintf/_vsnwsprintf because they're MS extensions.
  1114. // -----------------------------------------------------------------------------
  1115. #ifdef SS_ANSI
  1116. inline int ssvsprintf(PSTR pA, size_t /*nCount*/, PCSTR pFmtA, va_list vl)
  1117. {
  1118. return vsprintf(pA, pFmtA, vl);
  1119. }
  1120. inline int ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl)
  1121. {
  1122. // JMO: It is beginning to seem like Microsoft Visual C++ is the only
  1123. // CRT distribution whose version of vswprintf takes THREE arguments.
  1124. // All others seem to take FOUR arguments.  Therefore instead of 
  1125. // checking for every possible distro here, I'll assume that unless
  1126. // I am running with Microsoft's CRT, then vswprintf takes four
  1127. // arguments.  If you get a compilation error here, then you can just
  1128. // change this code to call the three-argument version.
  1129. // #if !defined(__MWERKS__) && !defined(__SUNPRO_CC_COMPAT) && !defined(__SUNPRO_CC)
  1130. //#ifndef _MSC_VER
  1131. // return vswprintf(pW, nCount, pFmtW, vl);
  1132. // #else
  1133. nCount;
  1134. return vswprintf(pW, pFmtW, vl);
  1135. // #endif
  1136. }
  1137. #else
  1138. inline int ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl)
  1139. { 
  1140. return _vsnprintf(pA, nCount, pFmtA, vl);
  1141. }
  1142. inline int ssnprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl)
  1143. {
  1144. return _vsnwprintf(pW, nCount, pFmtW, vl);
  1145. }
  1146. #endif
  1149. // -----------------------------------------------------------------------------
  1150. // ssload: Type safe, overloaded ::LoadString wrappers
  1151. // There is no equivalent of these in non-Win32-specific builds.  However, I'm
  1152. // thinking that with the message facet, there might eventually be one
  1153. // -----------------------------------------------------------------------------
  1154. #ifdef SS_ANSI
  1155. #else
  1156. inline int ssload(HMODULE hInst, UINT uId, PSTR pBuf, int nMax)
  1157. {
  1158. return ::LoadStringA(hInst, uId, pBuf, nMax);
  1159. }
  1160. inline int ssload(HMODULE hInst, UINT uId, PWSTR pBuf, int nMax)
  1161. {
  1162. return ::LoadStringW(hInst, uId, pBuf, nMax);
  1163. }
  1164. #endif
  1167. // -----------------------------------------------------------------------------
  1168. // sscoll/ssicoll: Collation wrappers
  1169. // -----------------------------------------------------------------------------
  1170. #ifdef SS_ANSI
  1171. template <typename CT>
  1172. inline int sscoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2)
  1173. {
  1174. const std::collate<CT>& coll =
  1175. SS_USE_FACET(std::locale(), std::collate<CT>);
  1176. return coll.compare(sz1, sz1+nLen1, sz2, sz2+nLen2);
  1177. }
  1178. template <typename CT>
  1179. inline int ssicoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2)
  1180. {
  1181. const std::locale loc;
  1182. const std::collate<CT>& coll = SS_USE_FACET(loc, std::collate<CT>);
  1184. // Some implementations seem to have trouble using the collate<>
  1185. // facet typedefs so we'll just default to basic_string and hope
  1186. // that's what the collate facet uses (which it generally should)
  1188. // std::collate<CT>::string_type s1(sz1);
  1189. // std::collate<CT>::string_type s2(sz2);
  1190. std::basic_string<CT> s1(sz1);
  1191. std::basic_string<CT> s2(sz2);
  1193. sslwr(const_cast<CT*>(s1.c_str()), nLen1);
  1194. sslwr(const_cast<CT*>(s2.c_str()), nLen2);
  1195. return coll.compare(s1.c_str(), s1.c_str()+nLen1,
  1196. s2.c_str(), s2.c_str()+nLen2);
  1197. }
  1198. #else
  1199. #ifdef _MBCS
  1200. inline int sscoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/)
  1201. {
  1202. return _mbscoll((PCUSTR)sz1, (PCUSTR)sz2);
  1203. }
  1204. inline int ssicoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/)
  1205. {
  1206. return _mbsicoll((PCUSTR)sz1, (PCUSTR)sz2);
  1207. }
  1208. #else
  1209. inline int sscoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/)
  1210. {
  1211. return strcoll(sz1, sz2);
  1212. }
  1213. inline int ssicoll(PCSTR sz1, int /*nLen1*/, PCSTR sz2, int /*nLen2*/)
  1214. {
  1215. return _stricoll(sz1, sz2);
  1216. }
  1217. #endif
  1218. inline int sscoll(PCWSTR sz1, int /*nLen1*/, PCWSTR sz2, int /*nLen2*/)
  1219. {
  1220. return wcscoll(sz1, sz2);
  1221. }
  1222. inline int ssicoll(PCWSTR sz1, int /*nLen1*/, PCWSTR sz2, int /*nLen2*/)
  1223. {
  1224. return _wcsicoll(sz1, sz2);
  1225. }
  1226. #endif
  1229. // -----------------------------------------------------------------------------
  1230. // ssfmtmsg: FormatMessage equivalents.  Needed because I added a CString facade
  1231. // Again -- no equivalent of these on non-Win32 builds but their might one day
  1232. // be one if the message facet gets implemented
  1233. // -----------------------------------------------------------------------------
  1234. #ifdef SS_ANSI
  1235. #else
  1236. inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId,
  1237.   DWORD dwLangId, PSTR pBuf, DWORD nSize,
  1238.   va_list* vlArgs)
  1239. { 
  1240. return FormatMessageA(dwFlags, pSrc, dwMsgId, dwLangId,
  1241.   pBuf, nSize,vlArgs);
  1242. }
  1243. inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId,
  1244.   DWORD dwLangId, PWSTR pBuf, DWORD nSize,
  1245.   va_list* vlArgs)
  1246. {
  1247. return FormatMessageW(dwFlags, pSrc, dwMsgId, dwLangId,
  1248.   pBuf, nSize,vlArgs);
  1249. }
  1250. #endif
  1251.  
  1254. // FUNCTION: sscpy.  Copies up to 'nMax' characters from pSrc to pDst.
  1255. // -----------------------------------------------------------------------------
  1256. // FUNCTION:  sscpy
  1257. // inline int sscpy(PSTR pDst, PCSTR pSrc, int nMax=-1);
  1258. // inline int sscpy(PUSTR pDst,  PCSTR pSrc, int nMax=-1)
  1259. // inline int sscpy(PSTR pDst, PCWSTR pSrc, int nMax=-1);
  1260. // inline int sscpy(PWSTR pDst, PCWSTR pSrc, int nMax=-1);
  1261. // inline int sscpy(PWSTR pDst, PCSTR pSrc, int nMax=-1);
  1262. //
  1263. // DESCRIPTION:
  1264. // This function is very much (but not exactly) like strcpy.  These
  1265. // overloads simplify copying one C-style string into another by allowing
  1266. // the caller to specify two different types of strings if necessary.
  1267. //
  1268. // The strings must NOT overlap
  1269. //
  1270. // "Character" is expressed in terms of the destination string, not
  1271. // the source.  If no 'nMax' argument is supplied, then the number of
  1272. // characters copied will be sslen(pSrc).  A NULL terminator will
  1273. // also be added so pDst must actually be big enough to hold nMax+1
  1274. // characters.  The return value is the number of characters copied,
  1275. // not including the NULL terminator.
  1276. //
  1277. // PARAMETERS: 
  1278. // pSrc - the string to be copied FROM.  May be a char based string, an
  1279. //    MBCS string (in Win32 builds) or a wide string (wchar_t).
  1280. // pSrc - the string to be copied TO.  Also may be either MBCS or wide
  1281. // nMax - the maximum number of characters to be copied into szDest.  Note
  1282. //    that this is expressed in whatever a "character" means to pDst.
  1283. //    If pDst is a wchar_t type string than this will be the maximum
  1284. //    number of wchar_ts that my be copied.  The pDst string must be
  1285. //    large enough to hold least nMaxChars+1 characters.
  1286. //    If the caller supplies no argument for nMax this is a signal to
  1287. //    the routine to copy all the characters in pSrc, regardless of
  1288. //    how long it is.
  1289. //
  1290. // RETURN VALUE: none
  1291. // -----------------------------------------------------------------------------
  1292. template<typename CT1, typename CT2>
  1293. inline int sscpycvt(CT1* pDst, const CT2* pSrc, int nChars)
  1294. {
  1295. StdCodeCvt(pDst, pSrc, nChars);
  1296. pDst[SSMAX(nChars, 0)] = '';
  1297. return nChars;
  1298. }
  1300. template<typename CT1, typename CT2>
  1301. inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax, int nLen)
  1302. {
  1303. return sscpycvt(pDst, pSrc, SSMIN(nMax, nLen));
  1304. }
  1305. template<typename CT1, typename CT2>
  1306. inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax)
  1307. {
  1308. return sscpycvt(pDst, pSrc, SSMIN(nMax, sslen(pSrc)));
  1309. }
  1310. template<typename CT1, typename CT2>
  1311. inline int sscpy(CT1* pDst, const CT2* pSrc)
  1312. {
  1313. return sscpycvt(pDst, pSrc, sslen(pSrc));
  1314. }
  1315. template<typename CT1, typename CT2>
  1316. inline int sscpy(CT1* pDst, const std::basic_string<CT2>& sSrc, int nMax)
  1317. {
  1318. return sscpycvt(pDst, sSrc.c_str(), SSMIN(nMax, (int)sSrc.length()));
  1319. }
  1320. template<typename CT1, typename CT2>
  1321. inline int sscpy(CT1* pDst, const std::basic_string<CT2>& sSrc)
  1322. {
  1323. return sscpycvt(pDst, sSrc.c_str(), (int)sSrc.length());
  1324. }
  1326. #ifdef SS_INC_COMDEF
  1327. template<typename CT1>
  1328. inline int sscpy(CT1* pDst, const _bstr_t& bs, int nMax)
  1329. {
  1330. return sscpycvt(pDst, static_cast<PCOLESTR>(bs), SSMIN(nMax, (int)bs.length()));
  1331. }
  1332. template<typename CT1>
  1333. inline int sscpy(CT1* pDst, const _bstr_t& bs)
  1334. {
  1335. return sscpy(pDst, bs, bs.length());
  1336. }
  1337. #endif
  1340. // -----------------------------------------------------------------------------
  1341. // Functional objects for changing case.  They also let you pass locales
  1342. // -----------------------------------------------------------------------------
  1344. #ifdef SS_ANSI
  1345. template<typename CT>
  1346. struct SSToUpper : public std::binary_function<CT, std::locale, CT>
  1347. {
  1348. inline CT operator()(const CT& t, const std::locale& loc) const
  1349. {
  1350. return std::toupper<CT>(t, loc);
  1351. }
  1352. };
  1353. template<typename CT>
  1354. struct SSToLower : public std::binary_function<CT, std::locale, CT>
  1355. {
  1356. inline CT operator()(const CT& t, const std::locale& loc) const
  1357. {
  1358. return std::tolower<CT>(t, loc);
  1359. }
  1360. };
  1361. #endif
  1363. // This struct is used for TrimRight() and TrimLeft() function implementations.
  1364. //template<typename CT>
  1365. //struct NotSpace : public std::unary_function<CT, bool>
  1366. //{
  1367. // const std::locale& loc;
  1368. // inline NotSpace(const std::locale& locArg) : loc(locArg) {}
  1369. // inline bool operator() (CT t) { return !std::isspace(t, loc); }
  1370. //};
  1371. template<typename CT>
  1372. struct NotSpace : public std::unary_function<CT, bool>
  1373. {
  1374. const std::locale& loc;
  1375. NotSpace(const std::locale& locArg) : loc(locArg) {}
  1377. // DINKUMWARE BUG:
  1378. // Note -- using std::isspace in a COM DLL gives us access violations
  1379. // because it causes the dynamic addition of a function to be called
  1380. // when the library shuts down.  Unfortunately the list is maintained
  1381. // in DLL memory but the function is in static memory.  So the COM DLL
  1382. // goes away along with the function that was supposed to be called,
  1383. // and then later when the DLL CRT shuts down it unloads the list and
  1384. // tries to call the long-gone function.
  1385. // This is DinkumWare's implementation problem.  Until then, we will
  1386. // use good old isspace and iswspace from the CRT unless they
  1387. // specify SS_ANSI
  1388. #ifdef SS_ANSI
  1389. bool operator() (CT t) const { return !std::isspace(t, loc); }
  1390. #else
  1391. bool ssisp(char c) const { return FALSE != ::isspace((int) c); }
  1392. bool ssisp(wchar_t c) const { return FALSE != ::iswspace((wint_t) c); }
  1393. bool operator()(CT t) const  { return !ssisp(t); }
  1394. #endif
  1395. };
  1400. // Now we can define the template (finally!)
  1401. // =============================================================================
  1402. // TEMPLATE: CStdStr
  1403. // template<typename CT> class CStdStr : public std::basic_string<CT>
  1404. //
  1405. // REMARKS:
  1406. // This template derives from basic_string<CT> and adds some MFC CString-
  1407. // like functionality
  1408. //
  1409. // Basically, this is my attempt to make Standard C++ library strings as
  1410. // easy to use as the MFC CString class.
  1411. //
  1412. // Note that although this is a template, it makes the assumption that the
  1413. // template argument (CT, the character type) is either char or wchar_t.  
  1414. // =============================================================================
  1416. //#define CStdStr _SS // avoid compiler warning 4786
  1419. template<typename CT>
  1420. class CStdStr : public std::basic_string<CT>
  1421. {
  1422. // Typedefs for shorter names.  Using these names also appears to help
  1423. // us avoid some ambiguities that otherwise arise on some platforms
  1425. typedef typename std::basic_string<CT> MYBASE;  // my base class
  1426. typedef CStdStr<CT> MYTYPE;  // myself
  1427. typedef typename MYBASE::const_pointer PCMYSTR; // PCSTR or PCWSTR 
  1428. typedef typename MYBASE::pointer PMYSTR;  // PSTR or PWSTR
  1429. typedef typename MYBASE::iterator MYITER;  // my iterator type
  1430. typedef typename MYBASE::const_iterator MYCITER; // you get the idea...
  1431. typedef typename MYBASE::reverse_iterator MYRITER;
  1432. typedef typename MYBASE::size_type MYSIZE;   
  1433. typedef typename MYBASE::value_type MYVAL; 
  1434. typedef typename MYBASE::allocator_type MYALLOC;
  1436. public:
  1438. // shorthand conversion from PCTSTR to string resource ID
  1439. #define _TRES(pctstr) (LOWORD((DWORD)(pctstr)))
  1441. // CStdStr inline constructors
  1442. CStdStr()
  1443. {
  1444. }
  1446. CStdStr(const MYTYPE& str) : MYBASE(SSREF(str))
  1447. {
  1448. }
  1450. CStdStr(const std::string& str)
  1451. {
  1452. ssasn(*this, SSREF(str));
  1453. }
  1455. CStdStr(const std::wstring& str)
  1456. {
  1457. ssasn(*this, SSREF(str));
  1458. }
  1460. CStdStr(PCMYSTR pT, MYSIZE n) : MYBASE(pT, n)
  1461. {
  1462. }
  1464. CStdStr(PCSTR pA)
  1465. {
  1466. #ifdef SS_ANSI
  1467. *this = pA;
  1468. #else
  1469. if ( 0 != HIWORD(pA) )
  1470. *this = pA;
  1471. else if ( 0 != pA && !Load(_TRES(pA)) )
  1472. TRACE(_T("Can't load string %un"), _TRES(pA));
  1473. #endif
  1474. }
  1476. CStdStr(PCWSTR pW)
  1477. {
  1478. #ifdef SS_ANSI
  1479. *this = pW;
  1480. #else
  1481. if ( 0 != HIWORD(pW) )
  1482. *this = pW;
  1483. else if ( 0 != pW && !Load(_TRES(pW)) )
  1484. TRACE(_T("Can't load string %un"), _TRES(pW));
  1485. #endif
  1486. }
  1488. CStdStr(MYCITER first, MYCITER last)
  1489. : MYBASE(first, last)
  1490. {
  1491. }
  1493. CStdStr(MYSIZE nSize, MYVAL ch, const MYALLOC& al=MYALLOC())
  1494. : MYBASE(nSize, ch, al)
  1495. {
  1496. }
  1498. #ifdef SS_INC_COMDEF
  1499. CStdStr(const _bstr_t& bstr)
  1500. {
  1501. if ( bstr.length() > 0 )
  1502. append(static_cast<PCMYSTR>(bstr), bstr.length());
  1503. }
  1504. #endif
  1506. // CStdStr inline assignment operators -- the ssasn function now takes care
  1507. // of fixing  the MSVC assignment bug (see knowledge base article Q172398).
  1508. MYTYPE& operator=(const MYTYPE& str)
  1509. { 
  1510. ssasn(*this, str); 
  1511. return *this;
  1512. }
  1514. MYTYPE& operator=(const std::string& str)
  1515. {
  1516. ssasn(*this, str);
  1517. return *this;
  1518. }
  1520. MYTYPE& operator=(const std::wstring& str)
  1521. {
  1522. ssasn(*this, str);
  1523. return *this;
  1524. }
  1526. MYTYPE& operator=(PCSTR pA)
  1527. {
  1528. ssasn(*this, pA);
  1529. return *this;
  1530. }
  1532. MYTYPE& operator=(PCWSTR pW)
  1533. {
  1534. ssasn(*this, pW);
  1535. return *this;
  1536. }
  1538. MYTYPE& operator=(CT t)
  1539. {
  1540. Q172398(*this);
  1541. MYBASE::assign(1, t);
  1542. return *this;
  1543. }
  1545. #ifdef SS_INC_COMDEF
  1546. MYTYPE& operator=(const _bstr_t& bstr)
  1547. {
  1548. if ( bstr.length() > 0 )
  1549. return assign(static_cast<PCMYSTR>(bstr), bstr.length());
  1550. else
  1551. {
  1552. erase();
  1553. return *this;
  1554. }
  1555. }
  1556. #endif
  1559. // Overloads  also needed to fix the MSVC assignment bug (KB: Q172398)
  1560. //  *** Thanks to Pete The Plumber for catching this one ***
  1561. // They also are compiled if you have explicitly turned off refcounting
  1562. #if ( defined(_MSC_VER) && ( _MSC_VER < 1200 ) ) || defined(SS_NO_REFCOUNT) 
  1564. MYTYPE& assign(const MYTYPE& str)
  1565. {
  1566. ssasn(*this, str);
  1567. return *this;
  1568. }
  1570. MYTYPE& assign(const MYTYPE& str, MYSIZE nStart, MYSIZE nChars)
  1571. {
  1572. // This overload of basic_string::assign is supposed to assign up to
  1573. // <nChars> or the NULL terminator, whichever comes first.  Since we
  1574. // are about to call a less forgiving overload (in which <nChars>
  1575. // must be a valid length), we must adjust the length here to a safe
  1576. // value.  Thanks to Ullrich Poll鋒ne for catching this bug
  1578. nChars = SSMIN(nChars, str.length() - nStart);
  1580. // Watch out for assignment to self
  1582. if ( this == &str )
  1583. {
  1584. MYTYPE strTemp(str.c_str()+nStart, nChars);
  1585. assign(strTemp);
  1586. }
  1587. else
  1588. {
  1589. Q172398(*this);
  1590. MYBASE::assign(str.c_str()+nStart, nChars);
  1591. }
  1592. return *this;
  1593. }
  1595. MYTYPE& assign(const MYBASE& str)
  1596. {
  1597. ssasn(*this, str);
  1598. return *this;
  1599. }
  1601. MYTYPE& assign(const MYBASE& str, MYSIZE nStart, MYSIZE nChars)
  1602. {
  1603. // This overload of basic_string::assign is supposed to assign up to
  1604. // <nChars> or the NULL terminator, whichever comes first.  Since we
  1605. // are about to call a less forgiving overload (in which <nChars>
  1606. // must be a valid length), we must adjust the length here to a safe
  1607. // value. Thanks to Ullrich Poll鋒ne for catching this bug
  1609. nChars = SSMIN(nChars, str.length() - nStart);
  1611. // Watch out for assignment to self
  1613. if ( this == &str ) // watch out for assignment to self
  1614. {
  1615. MYTYPE strTemp(str.c_str() + nStart, nChars);
  1616. assign(strTemp);
  1617. }
  1618. else
  1619. {
  1620. Q172398(*this);
  1621. MYBASE::assign(str.c_str()+nStart, nChars);
  1622. }
  1623. return *this;
  1624. }
  1626. MYTYPE& assign(const CT* pC, MYSIZE nChars)
  1627. {
  1628. // Q172398 only fix -- erase before assigning, but not if we're
  1629. // assigning from our own buffer
  1631. #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )
  1632. if ( !empty() && ( pC < data() || pC > data() + capacity() ) )
  1633. erase();
  1634. #endif
  1635. Q172398(*this);
  1636. MYBASE::assign(pC, nChars);
  1637. return *this;
  1638. }
  1640. MYTYPE& assign(MYSIZE nChars, MYVAL val)
  1641. {
  1642. Q172398(*this);
  1643. MYBASE::assign(nChars, val);
  1644. return *this;
  1645. }
  1647. MYTYPE& assign(const CT* pT)
  1648. {
  1649. return assign(pT, CStdStr::traits_type::length(pT));
  1650. }
  1652. MYTYPE& assign(MYCITER iterFirst, MYCITER iterLast)
  1653. {
  1654. #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 ) 
  1655. // Q172398 fix.  don't call erase() if we're assigning from ourself
  1656. if ( iterFirst < begin() || iterFirst > begin() + size() )
  1657. erase()
  1658. #endif
  1659. replace(begin(), end(), iterFirst, iterLast);
  1660. return *this;
  1661. }
  1662. #endif
  1665. // -------------------------------------------------------------------------
  1666. // CStdStr inline concatenation.
  1667. // -------------------------------------------------------------------------
  1668. MYTYPE& operator+=(const MYTYPE& str)
  1669. {
  1670. ssadd(*this, str);
  1671. return *this;
  1672. }
  1674. MYTYPE& operator+=(const std::string& str)
  1675. {
  1676. ssadd(*this, str);
  1677. return *this; 
  1678. }
  1680. MYTYPE& operator+=(const std::wstring& str)
  1681. {
  1682. ssadd(*this, str);
  1683. return *this;
  1684. }
  1686. MYTYPE& operator+=(PCSTR pA)
  1687. {
  1688. ssadd(*this, pA);
  1689. return *this;
  1690. }
  1692. MYTYPE& operator+=(PCWSTR pW)
  1693. {
  1694. ssadd(*this, pW);
  1695. return *this;
  1696. }
  1698. MYTYPE& operator+=(CT t)
  1699. {
  1700. append(1, t);
  1701. return *this;
  1702. }
  1703. #ifdef SS_INC_COMDEF // if we have _bstr_t, define a += for it too.
  1704. MYTYPE& operator+=(const _bstr_t& bstr)
  1705. {
  1706. return operator+=(static_cast<PCMYSTR>(bstr));
  1707. }
  1708. #endif
  1711. // addition operators -- global friend functions.
  1713. friend MYTYPE operator+(const MYTYPE& str1, const MYTYPE& str2);
  1714. friend MYTYPE operator+(const MYTYPE& str, CT t);
  1715. friend MYTYPE operator+(const MYTYPE& str, PCSTR sz);
  1716. friend MYTYPE operator+(const MYTYPE& str, PCWSTR sz);
  1717. friend MYTYPE operator+(PCSTR pA, const MYTYPE& str);
  1718. friend MYTYPE operator+(PCWSTR pW, const MYTYPE& str);
  1719. #ifdef SS_INC_COMDEF
  1720. friend MYTYPE operator+(const _bstr_t& bstr, const MYTYPE& str);
  1721. friend MYTYPE operator+(const MYTYPE& str, const _bstr_t& bstr);
  1722. #endif
  1724. // -------------------------------------------------------------------------
  1725. // Case changing functions
  1726. // -------------------------------------------------------------------------
  1727. // -------------------------------------------------------------------------
  1728. MYTYPE& ToUpper()
  1729. {
  1730. //  Strictly speaking, this would be about the most portable way
  1732. // std::transform(begin(),
  1733. //    end(),
  1734. //    begin(),
  1735. //    std::bind2nd(SSToUpper<CT>(), std::locale()));
  1737. // But practically speaking, this works faster
  1739. if ( !empty() )
  1740. ssupr(GetBuf(), size());
  1742. return *this;
  1743. }
  1747. MYTYPE& ToLower()
  1748. {
  1749. //  Strictly speaking, this would be about the most portable way
  1751. // std::transform(begin(),
  1752. //    end(),
  1753. //    begin(),
  1754. //    std::bind2nd(SSToLower<CT>(), std::locale()));
  1756. // But practically speaking, this works faster
  1758. if ( !empty() )
  1759. sslwr(GetBuf(), size());
  1761. return *this;
  1762. }
  1766. MYTYPE& Normalize()
  1767. {
  1768. return Trim().ToLower();
  1769. }
  1772. // -------------------------------------------------------------------------
  1773. // CStdStr -- Direct access to character buffer.  In the MS' implementation,
  1774. // the at() function that we use here also calls _Freeze() providing us some
  1775. // protection from multithreading problems associated with ref-counting.
  1776. // -------------------------------------------------------------------------
  1777. CT* GetBuf(int nMinLen=-1)
  1778. {
  1779. if ( static_cast<int>(size()) < nMinLen )
  1780. resize(static_cast<MYSIZE>(nMinLen));
  1782. return empty() ? const_cast<CT*>(data()) : &(at(0));
  1783. }
  1785. CT* SetBuf(int nLen)
  1786. {
  1787. nLen = ( nLen > 0 ? nLen : 0 );
  1788. if ( capacity() < 1 && nLen == 0 )
  1789. resize(1);
  1791. resize(static_cast<MYSIZE>(nLen));
  1792. return const_cast<CT*>(data());
  1793. }
  1794. void RelBuf(int nNewLen=-1)
  1795. {
  1796. resize(static_cast<MYSIZE>(nNewLen > -1 ? nNewLen : sslen(c_str())));
  1797. }
  1799. void BufferRel()  { RelBuf(); } // backwards compatability
  1800. CT*  Buffer()  { return GetBuf(); } // backwards compatability
  1801. CT*  BufferSet(int nLen) { return SetBuf(nLen);}// backwards compatability
  1803. bool Equals(const CT* pT, bool bUseCase=false) const
  1804. { // get copy, THEN compare (thread safe)
  1805. return  bUseCase ? compare(pT) == 0 : ssicmp(MYTYPE(*this), pT) == 0;
  1806. } 
  1808. // -------------------------------------------------------------------------
  1809. // FUNCTION:  CStdStr::Load
  1810. // REMARKS:
  1811. // Loads string from resource specified by nID
  1812. //
  1813. // PARAMETERS:
  1814. // nID - resource Identifier.  Purely a Win32 thing in this case
  1815. //
  1816. // RETURN VALUE:
  1817. // true if successful, false otherwise
  1818. // -------------------------------------------------------------------------
  1819. #ifndef SS_ANSI
  1820. bool Load(UINT nId, HMODULE hModule=NULL)
  1821. {
  1822. bool bLoaded = false; // set to true of we succeed.
  1824. #ifdef _MFC_VER // When in Rome...
  1826. CString strRes;
  1827. bLoaded = FALSE != strRes.LoadString(nId);
  1828. if ( bLoaded )
  1829. *this = strRes;
  1831. #else
  1833. // Get the resource name and module handle
  1835. if ( NULL == hModule )
  1836. hModule = GetResourceHandle();
  1838. PCTSTR szName = MAKEINTRESOURCE((nId>>4)+1); // lifted 
  1839. DWORD dwSize = 0;
  1841. // No sense continuing if we can't find the resource
  1843. HRSRC hrsrc = ::FindResource(hModule, szName, RT_STRING);
  1845. if ( NULL == hrsrc )
  1846. TRACE(_T("Cannot find resource %d: 0x%X"), nId, ::GetLastError());
  1847. else if ( 0 == (dwSize = ::SizeofResource(hModule, hrsrc) / sizeof(CT)))
  1848. TRACE(_T("Cant get size of resource %d 0x%Xn"),nId,GetLastError());
  1849. else
  1850. {
  1851. bLoaded = 0 != ssload(hModule, nId, GetBuf(dwSize), dwSize);
  1852. ReleaseBuffer();
  1853. }
  1855. #endif
  1857. if ( !bLoaded )
  1858. TRACE(_T("String not loaded 0x%Xn"), ::GetLastError());
  1860. return bLoaded;
  1861. }
  1862. #endif
  1864. // -------------------------------------------------------------------------
  1865. // FUNCTION:  CStdStr::Format
  1866. // void _cdecl Formst(CStdStringA& PCSTR szFormat, ...)
  1867. // void _cdecl Format(PCSTR szFormat);
  1868. //           
  1869. // DESCRIPTION:
  1870. // This function does sprintf/wsprintf style formatting on CStdStringA
  1871. // objects.  It looks a lot like MFC's CString::Format.  Some people
  1872. // might even call this identical.  Fortunately, these people are now
  1873. // dead.
  1874. //
  1875. // PARAMETERS: 
  1876. // nId - ID of string resource holding the format string
  1877. // szFormat - a PCSTR holding the format specifiers
  1878. // argList - a va_list holding the arguments for the format specifiers.
  1879. //
  1880. // RETURN VALUE:  None.
  1881. // -------------------------------------------------------------------------
  1882. // formatting (using wsprintf style formatting)
  1883. #ifndef SS_ANSI
  1884. void Format(UINT nId, ...)
  1885. {
  1886. va_list argList;
  1887. va_start(argList, nId);
  1888. va_start(argList, nId);
  1890. MYTYPE strFmt;
  1891. if ( strFmt.Load(nId) )
  1892. FormatV(strFmt, argList);
  1894. va_end(argList);
  1895. }
  1896. #endif
  1897. void Format(const CT* szFmt, ...)
  1898. {
  1899. va_list argList;
  1900. va_start(argList, szFmt);
  1901. FormatV(szFmt, argList);
  1902. va_end(argList);
  1903. }
  1904. void AppendFormat(const CT* szFmt, ...)
  1905. {
  1906. va_list argList;
  1907. va_start(argList, szFmt);
  1908. AppendFormatV(szFmt, argList);
  1909. va_end(argList);
  1910. }
  1912. #define MAX_FMT_TRIES 5  // #of times we try 
  1913. #define FMT_BLOCK_SIZE 2048 // # of bytes to increment per try
  1914. #define BUFSIZE_1ST 256
  1915. #define BUFSIZE_2ND 512
  1916. #define STD_BUF_SIZE 1024
  1918. // an efficient way to add formatted characters to the string.  You may only
  1919. // add up to STD_BUF_SIZE characters at a time, though
  1920. void AppendFormatV(const CT* szFmt, va_list argList)
  1921. {
  1922. CT szBuf[STD_BUF_SIZE];
  1923. #ifdef SS_ANSI
  1924. int nLen = ssvsprintf(szBuf, STD_BUF_SIZE-1, szFmt, argList);
  1925. #else
  1926. int nLen = ssnprintf(szBuf, STD_BUF_SIZE-1, szFmt, argList);
  1927. #endif
  1928. if ( 0 < nLen )
  1929. append(szBuf, nLen);
  1930. }
  1932. // -------------------------------------------------------------------------
  1933. // FUNCTION:  FormatV
  1934. // void FormatV(PCSTR szFormat, va_list, argList);
  1935. //           
  1936. // DESCRIPTION:
  1937. // This function formats the string with sprintf style format-specs. 
  1938. // It makes a general guess at required buffer size and then tries
  1939. // successively larger buffers until it finds one big enough or a
  1940. // threshold (MAX_FMT_TRIES) is exceeded.
  1941. //
  1942. // PARAMETERS: 
  1943. // szFormat - a PCSTR holding the format of the output
  1944. // argList - a Microsoft specific va_list for variable argument lists
  1945. //
  1946. // RETURN VALUE: 
  1947. // -------------------------------------------------------------------------
  1949. void FormatV(const CT* szFormat, va_list argList)
  1950. {
  1951. #ifdef SS_ANSI
  1953. int nLen = sslen(szFormat) + STD_BUF_SIZE;
  1954. ssvsprintf(GetBuffer(nLen), nLen-1, szFormat, argList);
  1955. ReleaseBuffer();
  1957. #else
  1959. CT* pBuf = NULL;
  1960. int nChars = 1;
  1961. int nUsed = 0;
  1962. size_type nActual = 0;
  1963. int nTry = 0;
  1965. do
  1966. {
  1967. // Grow more than linearly (e.g. 512, 1536, 3072, etc)
  1969. nChars += ((nTry+1) * FMT_BLOCK_SIZE);
  1970. pBuf = reinterpret_cast<CT*>(_alloca(sizeof(CT)*nChars));
  1971. nUsed = ssnprintf(pBuf, nChars-1, szFormat, argList);
  1973. // Ensure proper NULL termination.
  1975. nActual = nUsed == -1 ? nChars-1 : SSMIN(nUsed, nChars-1);
  1976. pBuf[nActual+1]= '';
  1979. } while ( nUsed < 0 && nTry++ < MAX_FMT_TRIES );
  1981. // assign whatever we managed to format
  1983. assign(pBuf, nActual);
  1985. #endif
  1986. }
  1989. // -------------------------------------------------------------------------
  1990. // CString Facade Functions:
  1991. //
  1992. // The following methods are intended to allow you to use this class as a
  1993. // drop-in replacement for CString.
  1994. // -------------------------------------------------------------------------
  1995. #ifndef SS_ANSI
  1996. BSTR AllocSysString() const
  1997. {
  1998. ostring os;
  1999. ssasn(os, *this);
  2000. return ::SysAllocString(os.c_str());
  2001. }
  2002. #endif
  2004. int Collate(PCMYSTR szThat) const
  2005. {
  2006. return sscoll(c_str(), length(), szThat, sslen(szThat));
  2007. }
  2009. int CollateNoCase(PCMYSTR szThat) const
  2010. {
  2011. return ssicoll(c_str(), length(), szThat, sslen(szThat));
  2012. }
  2014. int Compare(PCMYSTR szThat) const
  2015. {
  2016. return MYBASE::compare(szThat);
  2017. }
  2019. int CompareNoCase(PCMYSTR szThat) const
  2020. {
  2021. return ssicmp(c_str(), szThat);
  2022. }
  2024. int Delete(int nIdx, int nCount=1)
  2025. {
  2026. if ( nIdx < GetLength() )
  2027. erase(static_cast<MYSIZE>(nIdx), static_cast<MYSIZE>(nCount));
  2029. return GetLength();
  2030. }
  2032. void Empty()
  2033. {
  2034. erase();
  2035. }
  2037. int Find(CT ch) const
  2038. {
  2039. MYSIZE nIdx = find_first_of(ch);
  2040. return static_cast<int>(MYBASE::npos == nIdx  ? -1 : nIdx);
  2041. }
  2043. int Find(PCMYSTR szSub) const
  2044. {
  2045. MYSIZE nIdx = find(szSub);
  2046. return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);
  2047. }
  2049. int Find(CT ch, int nStart) const
  2050. {
  2051. // CString::Find docs say add 1 to nStart when it's not zero
  2052. // CString::Find code doesn't do that however.  We'll stick
  2053. // with what the code does
  2055. MYSIZE nIdx = find_first_of(ch, static_cast<MYSIZE>(nStart));
  2056. return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);
  2057. }
  2059. int Find(PCMYSTR szSub, int nStart) const
  2060. {
  2061. // CString::Find docs say add 1 to nStart when it's not zero
  2062. // CString::Find code doesn't do that however.  We'll stick
  2063. // with what the code does
  2065. MYSIZE nIdx = find(szSub, static_cast<MYSIZE>(nStart));
  2066. return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);
  2067. }
  2069. int FindOneOf(PCMYSTR szCharSet) const
  2070. {
  2071. MYSIZE nIdx = find_first_of(szCharSet);
  2072. return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);
  2073. }
  2075. #ifndef SS_ANSI
  2076. void FormatMessage(PCMYSTR szFormat, ...) throw(std::exception)
  2077. {
  2078. va_list argList;
  2079. va_start(argList, szFormat);
  2080. PMYSTR szTemp;
  2081. if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  2082.    szFormat, 0, 0,
  2083.    reinterpret_cast<PMYSTR>(&szTemp), 0, &argList) == 0 ||
  2084.  szTemp == 0 )
  2085. {
  2086. throw std::runtime_error("out of memory");
  2087. }
  2088. *this = szTemp;
  2089. LocalFree(szTemp);
  2090. va_end(argList);
  2091. }
  2093. void FormatMessage(UINT nFormatId, ...) throw(std::exception)
  2094. {
  2095. MYTYPE sFormat;
  2096. VERIFY(sFormat.LoadString(nFormatId) != 0);
  2097. va_list argList;
  2098. va_start(argList, nFormatId);
  2099. PMYSTR szTemp;
  2100. if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER,
  2101.    sFormat, 0, 0,
  2102.    reinterpret_cast<PMYSTR>(&szTemp), 0, &argList) == 0 ||
  2103. szTemp == 0)
  2104. {
  2105. throw std::runtime_error("out of memory");
  2106. }
  2107. *this = szTemp;
  2108. LocalFree(szTemp);
  2109. va_end(argList);
  2110. }
  2111. #endif
  2114. // -------------------------------------------------------------------------
  2115. // GetXXXX -- Direct access to character buffer
  2116. // -------------------------------------------------------------------------
  2117. CT GetAt(int nIdx) const
  2118. {
  2119. return at(static_cast<MYSIZE>(nIdx));
  2120. }
  2122. CT* GetBuffer(int nMinLen=-1)
  2123. {
  2124. return GetBuf(nMinLen);
  2125. }
  2127. CT* GetBufferSetLength(int nLen)
  2128. {
  2129. return BufferSet(nLen);
  2130. }
  2132. // GetLength() -- MFC docs say this is the # of BYTES but
  2133. // in truth it is the number of CHARACTERs (chars or wchar_ts)
  2134. int GetLength() const
  2135. {
  2136. return static_cast<int>(length());
  2137. }
  2140. int Insert(int nIdx, CT ch)
  2141. {
  2142. if ( static_cast<MYSIZE>(nIdx) > size() -1 )
  2143. append(1, ch);
  2144. else
  2145. insert(static_cast<MYSIZE>(nIdx), 1, ch);
  2147. return GetLength();
  2148. }
  2149. int Insert(int nIdx, PCMYSTR sz)
  2150. {
  2151. if ( nIdx >= size() )
  2152. append(sz, sslen(sz));
  2153. else
  2154. insert(static_cast<MYSIZE>(nIdx), sz);
  2156. return GetLength();
  2157. }
  2159. bool IsEmpty() const
  2160. {
  2161. return empty();
  2162. }
  2164. MYTYPE Left(int nCount) const
  2165. {
  2166. return substr(0, static_cast<MYSIZE>(nCount)); 
  2167. }
  2169. #ifndef SS_ANSI
  2170. bool LoadString(UINT nId)
  2171. {
  2172. return this->Load(nId);
  2173. }
  2174. #endif
  2176. void MakeLower()
  2177. {
  2178. ToLower();
  2179. }
  2181. void MakeReverse()
  2182. {
  2183. std::reverse(begin(), end());
  2184. }
  2186. void MakeUpper()
  2187. { 
  2188. ToUpper();
  2189. }
  2191. MYTYPE Mid(int nFirst ) const
  2192. {
  2193. return substr(static_cast<MYSIZE>(nFirst));
  2194. }
  2196. MYTYPE Mid(int nFirst, int nCount) const
  2197. {
  2198. return substr(static_cast<MYSIZE>(nFirst), static_cast<MYSIZE>(nCount));
  2199. }
  2201. void ReleaseBuffer(int nNewLen=-1)
  2202. {
  2203. RelBuf(nNewLen);
  2204. }
  2206. int Remove(CT ch)
  2207. {
  2208. MYSIZE nIdx = 0;
  2209. int nRemoved = 0;
  2210. while ( (nIdx=find_first_of(ch)) != MYBASE::npos )
  2211. {
  2212. erase(nIdx, 1);
  2213. nRemoved++;
  2214. }
  2215. return nRemoved;
  2216. }
  2218. int Replace(CT chOld, CT chNew)
  2219. {
  2220. int nReplaced = 0;
  2221. for ( MYITER iter=begin(); iter != end(); iter++ )
  2222. {
  2223. if ( *iter == chOld )
  2224. {
  2225. *iter = chNew;
  2226. nReplaced++;
  2227. }
  2228. }
  2229. return nReplaced;
  2230. }
  2232. int Replace(PCMYSTR szOld, PCMYSTR szNew)
  2233. {
  2234. int nReplaced = 0;
  2235. MYSIZE nIdx = 0;
  2236. MYSIZE nOldLen = sslen(szOld);
  2237. if ( 0 == nOldLen )
  2238. return 0;
  2240. static const CT ch = CT(0);
  2241. MYSIZE nNewLen = sslen(szNew);
  2242. PCMYSTR szRealNew = szNew == 0 ? &ch : szNew;
  2244. while ( (nIdx=find(szOld, nIdx)) != MYBASE::npos )
  2245. {
  2246. replace(begin()+nIdx, begin()+nIdx+nOldLen, szRealNew);
  2247. nReplaced++;
  2248. nIdx += nNewLen;
  2249. }
  2250. return nReplaced;
  2251. }
  2253. int ReverseFind(CT ch) const
  2254. {
  2255. MYSIZE nIdx = find_last_of(ch);
  2256. return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);
  2257. }
  2259. // ReverseFind overload that's not in CString but might be useful
  2260. int ReverseFind(PCMYSTR szFind, MYSIZE pos=MYBASE::npos) const
  2261. {
  2262. MYSIZE nIdx = rfind(0 == szFind ? MYTYPE() : szFind, pos);
  2263. return static_cast<int>(MYBASE::npos == nIdx ? -1 : nIdx);
  2264. }
  2266. MYTYPE Right(int nCount) const
  2267. {
  2268. nCount = SSMIN(nCount, static_cast<int>(size()));
  2269. return substr(size()-static_cast<MYSIZE>(nCount));
  2270. }
  2272. void SetAt(int nIndex, CT ch)
  2273. {
  2274. ASSERT(size() > static_cast<MYSIZE>(nIndex));
  2275. at(static_cast<MYSIZE>(nIndex)) = ch;
  2276. }
  2278. #ifndef SS_ANSI
  2279. BSTR SetSysString(BSTR* pbstr) const
  2280. {
  2281. ostring os;
  2282. ssasn(os, *this);
  2283. if ( !::SysReAllocStringLen(pbstr, os.c_str(), os.length()) )
  2284. throw std::runtime_error("out of memory");
  2286. ASSERT(*pbstr != 0);
  2287. return *pbstr;
  2288. }
  2289. #endif
  2291. MYTYPE SpanExcluding(PCMYSTR szCharSet) const
  2292. {
  2293. return Left(find_first_of(szCharSet));
  2294. }
  2296. MYTYPE SpanIncluding(PCMYSTR szCharSet) const
  2297. {
  2298. return Left(find_first_not_of(szCharSet));
  2299. }
  2301. #if !defined(UNICODE) && !defined(SS_ANSI)
  2303. // CString's OemToAnsi and AnsiToOem functions are available only in
  2304. // Unicode builds.  However since we're a template we also need a
  2305. // runtime check of CT and a reinterpret_cast to account for the fact
  2306. // that CStdStringW gets instantiated even in non-Unicode builds.
  2308. void AnsiToOem()
  2309. {
  2310. if ( sizeof(CT) == sizeof(char) && !empty() )
  2311. {
  2312. ::CharToOem(reinterpret_cast<PCSTR>(c_str()),
  2313. reinterpret_cast<PSTR>(GetBuf()));
  2314. }
  2315. else
  2316. {
  2317. ASSERT(false);
  2318. }
  2319. }
  2321. void OemToAnsi()
  2322. {
  2323. if ( sizeof(CT) == sizeof(char) && !empty() )
  2324. {
  2325. ::OemToChar(reinterpret_cast<PCSTR>(c_str()),
  2326. reinterpret_cast<PSTR>(GetBuf()));
  2327. }
  2328. else
  2329. {
  2330. ASSERT(false);
  2331. }
  2332. }
  2334. #endif
  2337. // -------------------------------------------------------------------------
  2338. // Trim and its variants
  2339. // -------------------------------------------------------------------------
  2340. MYTYPE& Trim()
  2341. {
  2342. return TrimLeft().TrimRight();
  2343. }
  2345. MYTYPE& TrimLeft()
  2346. {
  2347. erase(begin(), std::find_if(begin(),end(),NotSpace<CT>(std::locale())));
  2348. return *this;
  2349. }
  2351. MYTYPE&  TrimLeft(CT tTrim)
  2352. {
  2353. erase(0, find_first_not_of(tTrim));
  2354. return *this;
  2355. }
  2357. MYTYPE&  TrimLeft(PCMYSTR szTrimChars)
  2358. {
  2359. erase(0, find_first_not_of(szTrimChars));
  2360. return *this;
  2361. }
  2363. MYTYPE& TrimRight()
  2364. {
  2365. std::locale loc;
  2366. MYRITER it = std::find_if(rbegin(), rend(), NotSpace<CT>(loc));
  2367. if ( rend() != it )
  2368. erase(rend() - it);
  2370. erase(it != rend() ? find_last_of(*it) + 1 : 0);
  2371. return *this;
  2372. }
  2374. MYTYPE&  TrimRight(CT tTrim)
  2375. {
  2376. MYSIZE nIdx = find_last_not_of(tTrim);
  2377. erase(MYBASE::npos == nIdx ? 0 : ++nIdx);
  2378. return *this;
  2379. }
  2381. MYTYPE&  TrimRight(PCMYSTR szTrimChars)
  2382. {
  2383. MYSIZE nIdx = find_last_not_of(szTrimChars);
  2384. erase(MYBASE::npos == nIdx ? 0 : ++nIdx);
  2385. return *this;
  2386. }
  2388. void FreeExtra()
  2389. {
  2390. MYTYPE mt;
  2391. swap(mt);
  2392. if ( !mt.empty() )
  2393. assign(mt.c_str(), mt.size());
  2394. }
  2396. // I have intentionally not implemented the following CString
  2397. // functions.   You cannot make them work without taking advantage
  2398. // of implementation specific behavior.  However if you absolutely
  2399. // MUST have them, uncomment out these lines for "sort-of-like"
  2400. // their behavior.  You're on your own.
  2402. // CT* LockBuffer() { return GetBuf(); }// won't really lock
  2403. // void UnlockBuffer(); { } // why have UnlockBuffer w/o LockBuffer?
  2405. // Array-indexing operators.  Required because we defined an implicit cast
  2406. // to operator const CT* (Thanks to Julian Selman for pointing this out)
  2407. CT& operator[](int nIdx)
  2408. {
  2409. return MYBASE::operator[](static_cast<MYSIZE>(nIdx));
  2410. }
  2412. const CT& operator[](int nIdx) const
  2413. {
  2414. return MYBASE::operator[](static_cast<MYSIZE>(nIdx));
  2415. }
  2417. CT& operator[](unsigned int nIdx)
  2418. {
  2419. return MYBASE::operator[](static_cast<MYSIZE>(nIdx));
  2420. }
  2422. const CT& operator[](unsigned int nIdx) const
  2423. {
  2424. return MYBASE::operator[](static_cast<MYSIZE>(nIdx));
  2425. }
  2427. operator const CT*() const
  2428. {
  2429. return c_str();
  2430. }
  2432. // IStream related functions.  Useful in IPersistStream implementations
  2434. #ifdef SS_INC_COMDEF
  2436. // struct SSSHDR - useful for non Std C++ persistence schemes.
  2437. typedef struct SSSHDR
  2438. {
  2439. BYTE byCtrl;
  2440. ULONG nChars;
  2441. } SSSHDR; // as in "Standard String Stream Header"
  2443. #define SSSO_UNICODE 0x01 // the string is a wide string
  2444. #define SSSO_COMPRESS 0x02 // the string is compressed
  2446. // -------------------------------------------------------------------------
  2447. // FUNCTION: StreamSize
  2448. // REMARKS:
  2449. // Returns how many bytes it will take to StreamSave() this CStdString
  2450. // object to an IStream.
  2451. // -------------------------------------------------------------------------
  2452. ULONG StreamSize() const
  2453. {
  2454. // Control header plus string
  2455. ASSERT(size()*sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));
  2456. return (size() * sizeof(CT)) + sizeof(SSSHDR);
  2457. }
  2459. // -------------------------------------------------------------------------
  2460. // FUNCTION: StreamSave
  2461. // REMARKS:
  2462. // Saves this CStdString object to a COM IStream.
  2463. // -------------------------------------------------------------------------
  2464. HRESULT StreamSave(IStream* pStream) const
  2465. {
  2466. ASSERT(size()*sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));
  2467. HRESULT hr = E_FAIL;
  2468. ASSERT(pStream != 0);
  2469. SSSHDR hdr;
  2470. hdr.byCtrl = sizeof(CT) == 2 ? SSSO_UNICODE : 0;
  2471. hdr.nChars = size();
  2474. if ( FAILED(hr=pStream->Write(&hdr, sizeof(SSSHDR), 0)) )
  2475. TRACE(_T("StreamSave: Cannot write control header, ERR=0x%Xn"),hr);
  2476. else if ( empty() )
  2477. ; // nothing to write
  2478. else if ( FAILED(hr=pStream->Write(c_str(), size()*sizeof(CT), 0)) )
  2479. TRACE(_T("StreamSave: Cannot write string to stream 0x%Xn"), hr);
  2481. return hr;
  2482. }
  2485. // -------------------------------------------------------------------------
  2486. // FUNCTION: StreamLoad
  2487. // REMARKS:
  2488. // This method loads the object from an IStream.
  2489. // -------------------------------------------------------------------------
  2490. HRESULT StreamLoad(IStream* pStream)
  2491. {
  2492. ASSERT(pStream != 0);
  2493. SSSHDR hdr;
  2494. HRESULT hr = E_FAIL;
  2496. if ( FAILED(hr=pStream->Read(&hdr, sizeof(SSSHDR), 0)) )
  2497. {
  2498. TRACE(_T("StreamLoad: Cant read control header, ERR=0x%Xn"), hr);
  2499. }
  2500. else if ( hdr.nChars > 0 )
  2501. {
  2502. ULONG nRead = 0;
  2503. PMYSTR pMyBuf = BufferSet(hdr.nChars);
  2505. // If our character size matches the character size of the string
  2506. // we're trying to read, then we can read it directly into our
  2507. // buffer. Otherwise, we have to read into an intermediate buffer
  2508. // and convert.
  2510. if ( (hdr.byCtrl & SSSO_UNICODE) != 0 )
  2511. {
  2512. ULONG nBytes = hdr.nChars * sizeof(wchar_t);
  2513. if ( sizeof(CT) == sizeof(wchar_t) )
  2514. {
  2515. if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) )
  2516. TRACE(_T("StreamLoad: Cannot read string: 0x%Xn"), hr);
  2517. }
  2518. else
  2519. {
  2520. PWSTR pBufW = reinterpret_cast<PWSTR>(_alloca((nBytes)+1));
  2521. if ( FAILED(hr=pStream->Read(pBufW, nBytes, &nRead)) )
  2522. TRACE(_T("StreamLoad: Cannot read string: 0x%Xn"), hr);
  2523. else
  2524. sscpy(pMyBuf, pBufW, hdr.nChars);
  2525. }
  2526. }
  2527. else
  2528. {
  2529. ULONG nBytes = hdr.nChars * sizeof(char);
  2530. if ( sizeof(CT) == sizeof(char) )
  2531. {
  2532. if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) )
  2533. TRACE(_T("StreamLoad: Cannot read string: 0x%Xn"), hr);
  2534. }
  2535. else
  2536. {
  2537. PSTR pBufA = reinterpret_cast<PSTR>(_alloca(nBytes));
  2538. if ( FAILED(hr=pStream->Read(pBufA, hdr.nChars, &nRead)) )
  2539. TRACE(_T("StreamLoad: Cannot read string: 0x%Xn"), hr);
  2540. else
  2541. sscpy(pMyBuf, pBufA, hdr.nChars);
  2542. }
  2543. }
  2544. }
  2545. else
  2546. {
  2547. this->erase();
  2548. }
  2549. return hr;
  2550. }
  2551. #endif // #ifdef SS_INC_COMDEF
  2553. #ifndef SS_ANSI
  2555. // SetResourceHandle/GetResourceHandle.  In MFC builds, these map directly
  2556. // to AfxSetResourceHandle and AfxGetResourceHandle.  In non-MFC builds they
  2557. // point to a single static HINST so that those who call the member
  2558. // functions that take resource IDs can provide an alternate HINST of a DLL
  2559. // to search.  This is not exactly the list of HMODULES that MFC provides
  2560. // but it's better than nothing.
  2562. #ifdef _MFC_VER
  2563. static void SetResourceHandle(HMODULE hNew)
  2564. {
  2565. AfxSetResourceHandle(hNew);
  2566. }
  2567. static HMODULE GetResourceHandle()
  2568. {
  2569. return AfxGetResourceHandle();
  2570. }
  2571. #else
  2572. static void SetResourceHandle(HMODULE hNew)
  2573. {
  2574. SSResourceHandle() = hNew;
  2575. }
  2576. static HMODULE GetResourceHandle()
  2577. {
  2578. return SSResourceHandle();
  2579. }
  2580. #endif
  2582. #endif
  2583. };
  2587. // -----------------------------------------------------------------------------
  2588. // CStdStr friend addition functions defined as inline
  2589. // -----------------------------------------------------------------------------
  2590. template<typename CT>
  2591. inline
  2592. CStdStr<CT> operator+(const  CStdStr<CT>& str1, const  CStdStr<CT>& str2)
  2593. {
  2594. CStdStr<CT> strRet(SSREF(str1));
  2595. strRet.append(str2);
  2596. return strRet;
  2597. }
  2599. template<typename CT>
  2600. inline
  2601. CStdStr<CT> operator+(const  CStdStr<CT>& str, CT t)
  2602. {
  2603. // this particular overload is needed for disabling reference counting
  2604. // though it's only an issue from line 1 to line 2
  2606. CStdStr<CT> strRet(SSREF(str)); // 1
  2607. strRet.append(1, t); // 2
  2608. return strRet;
  2609. }
  2611. template<typename CT>
  2612. inline
  2613. CStdStr<CT> operator+(const  CStdStr<CT>& str, PCSTR pA)
  2614. {
  2615. return CStdStr<CT>(str) + CStdStr<CT>(pA);
  2616. }
  2618. template<typename CT>
  2619. inline
  2620. CStdStr<CT> operator+(PCSTR pA, const  CStdStr<CT>& str)
  2621. {
  2622. CStdStr<CT> strRet(pA);
  2623. strRet.append(str);
  2624. return strRet;
  2625. }
  2627. template<typename CT>
  2628. inline
  2629. CStdStr<CT> operator+(const CStdStr<CT>& str, PCWSTR pW)
  2630. { 
  2631. return CStdStr<CT>(SSREF(str)) + CStdStr<CT>(pW);
  2632. }
  2634. template<typename CT>
  2635. inline
  2636. CStdStr<CT> operator+(PCWSTR pW, const CStdStr<CT>& str)
  2637. {
  2638. CStdStr<CT> strRet(pW);
  2639. strRet.append(str);
  2640. return strRet;
  2641. }
  2643. #ifdef SS_INC_COMDEF
  2644. template<typename CT>
  2645. inline
  2646. CStdStr<CT> operator+(const _bstr_t& bstr, const CStdStr<CT>& str)
  2647. {
  2648. return static_cast<const CT*>(bstr) + str;
  2649. }
  2651. template<typename CT>
  2652. inline
  2653. CStdStr<CT> operator+(const CStdStr<CT>& str, const _bstr_t& bstr)
  2654. {
  2655. return str + static_cast<const CT*>(bstr);
  2656. }
  2657. #endif
  2662. // -----------------------------------------------------------------------------
  2663. // These versions of operator+ provided by Scott Hathaway in order to allow
  2664. // CStdString to build on Sun Unix systems.
  2665. // -----------------------------------------------------------------------------
  2667. #if defined(__SUNPRO_CC_COMPAT) || defined(__SUNPRO_CC)
  2669. // Made non-template versions due to "undefined" errors on Sun Forte compiler
  2670. // when linking with friend template functions
  2671. inline
  2672. CStdStr<wchar_t> operator+(const CStdStr<wchar_t>& str1,
  2673.    const CStdStr<wchar_t>& str2)
  2674. {
  2675. CStdStr<wchar_t> strRet(SSREF(str1));
  2676. strRet.append(str2);
  2677. return strRet;
  2678. }
  2680. inline
  2681. CStdStr<wchar_t> operator+(const CStdStr<wchar_t>& str, wchar_t t)
  2682. {
  2683. // this particular overload is needed for disabling reference counting
  2684. // though it's only an issue from line 1 to line 2
  2686. CStdStr<wchar_t> strRet(SSREF(str)); // 1
  2687. strRet.append(1, t); // 2
  2688. return strRet;
  2689. }
  2691. inline
  2692. CStdStr<wchar_t> operator+(const CStdStr<wchar_t>& str, PCWSTR pW)
  2693. {
  2694. return CStdStr<wchar_t>(str) + CStdStr<wchar_t>(pW);
  2695. }
  2697. inline
  2698. CStdStr<wchar_t> operator+(PCWSTR pA, const  CStdStr<wchar_t>& str)
  2699. {
  2700. CStdStr<wchar_t> strRet(pA);
  2701. strRet.append(str);
  2702. return strRet;
  2703. }
  2705. inline
  2706. CStdStr<wchar_t> operator+(const CStdStr<wchar_t>& str, PCSTR pW)
  2707. { 
  2708. return CStdStr<wchar_t>(SSREF(str)) + CStdStr<wchar_t>(pW);
  2709. }
  2711. inline
  2712. CStdStr<wchar_t> operator+(PCSTR pW, const CStdStr<wchar_t>& str)
  2713. {
  2714. CStdStr<wchar_t> strRet(pW);
  2715. strRet.append(str);
  2716. return strRet;
  2717. }
  2719. inline
  2720. CStdStr<char> operator+(const  CStdStr<char>& str1, const  CStdStr<char>& str2)
  2721. {
  2722. CStdStr<char> strRet(SSREF(str1));
  2723. strRet.append(str2);
  2724. return strRet;
  2725. }
  2727. inline
  2728. CStdStr<char> operator+(const  CStdStr<char>& str, char t)
  2729. {
  2730. // this particular overload is needed for disabling reference counting
  2731. // though it's only an issue from line 1 to line 2
  2733. CStdStr<char> strRet(SSREF(str)); // 1
  2734. strRet.append(1, t); // 2
  2735. return strRet;
  2736. }
  2738. inline
  2739. CStdStr<char> operator+(const  CStdStr<char>& str, PCSTR pA)
  2740. {
  2741. return CStdStr<char>(str) + CStdStr<char>(pA);
  2742. }
  2744. inline
  2745. CStdStr<char> operator+(PCSTR pA, const  CStdStr<char>& str)
  2746. {
  2747. CStdStr<char> strRet(pA);
  2748. strRet.append(str);
  2749. return strRet;
  2750. }
  2752. inline
  2753. CStdStr<char> operator+(const CStdStr<char>& str, PCWSTR pW)
  2754. { 
  2755. return CStdStr<char>(SSREF(str)) + CStdStr<char>(pW);
  2756. }
  2758. inline
  2759. CStdStr<char> operator+(PCWSTR pW, const CStdStr<char>& str)
  2760. {
  2761. CStdStr<char> strRet(pW);
  2762. strRet.append(str);
  2763. return strRet;
  2764. }
  2767. #endif // defined(__SUNPRO_CC_COMPAT) || defined(__SUNPRO_CC)
  2770. // =============================================================================
  2771. // END OF CStdStr INLINE FUNCTION DEFINITIONS
  2772. // =============================================================================
  2774. // Now typedef our class names based upon this humongous template
  2776. typedef CStdStr<char> CStdStringA; // a better std::string
  2777. typedef CStdStr<wchar_t> CStdStringW; // a better std::wstring
  2778. typedef CStdStr<OLECHAR> CStdStringO; // almost always CStdStringW
  2780. #ifndef SS_ANSI
  2781. // SSResourceHandle: our MFC-like resource handle
  2782. inline HMODULE& SSResourceHandle()
  2783. {
  2784. static HMODULE hModuleSS = GetModuleHandle(0);
  2785. return hModuleSS;
  2786. }
  2787. #endif
  2790. // In MFC builds, define some global serialization operators
  2791. // Special operators that allow us to serialize CStdStrings to CArchives.
  2792. // Note that we use an intermediate CString object in order to ensure that
  2793. // we use the exact same format.
  2795. #ifdef _MFC_VER
  2796. inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringA& strA)
  2797. {
  2798. CString strTemp = strA;
  2799. return ar << strTemp;
  2800. }
  2801. inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringW& strW)
  2802. {
  2803. CString strTemp = strW;
  2804. return ar << strTemp;
  2805. }
  2807. inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringA& strA)
  2808. {
  2809. CString strTemp;
  2810. ar >> strTemp;
  2811. strA = strTemp;
  2812. return ar;
  2813. }
  2814. inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringW& strW)
  2815. {
  2816. CString strTemp;
  2817. ar >> strTemp;
  2818. strW = strTemp;
  2819. return ar;
  2820. }
  2821. #endif // #ifdef _MFC_VER -- (i.e. is this MFC?)
  2825. // -----------------------------------------------------------------------------
  2826. // HOW TO EXPORT CSTDSTRING FROM A DLL
  2827. //
  2828. // If you want to export CStdStringA and CStdStringW from a DLL, then all you
  2829. // need to
  2830. // 1. make sure that all components link to the same DLL version
  2831. // of the CRT (not the static one).
  2832. // 2. Uncomment the 3 lines of code below
  2833. // 3. #define 2 macros per the instructions in MS KnowledgeBase
  2834. // article Q168958.  The macros are:
  2835. //
  2836. // MACRO DEFINTION WHEN EXPORTING DEFINITION WHEN IMPORTING
  2837. // ----- ------------------------ -------------------------
  2838. // SSDLLEXP (nothing, just #define it) extern
  2839. // SSDLLSPEC __declspec(dllexport) __declspec(dllimport)
  2840. //
  2841. // Note that these macros must be available to ALL clients who want to 
  2842. // link to the DLL and use the class.  If they 
  2843. // -----------------------------------------------------------------------------
  2844. //#pragma warning(disable:4231) // non-standard extension ("extern template")
  2845. // SSDLLEXP template class SSDLLSPEC CStdStr<char>;
  2846. // SSDLLEXP template class SSDLLSPEC CStdStr<wchar_t>;
  2849. // -----------------------------------------------------------------------------
  2850. // GLOBAL FUNCTION:  WUFormat
  2851. // CStdStringA WUFormat(UINT nId, ...);
  2852. // CStdStringA WUFormat(PCSTR szFormat, ...);
  2853. //
  2854. // REMARKS:
  2855. // This function allows the caller for format and return a CStdStringA
  2856. // object with a single line of code.
  2857. // -----------------------------------------------------------------------------
  2858. #ifdef SS_ANSI
  2859. #else
  2860. inline CStdStringA WUFormatA(UINT nId, ...)
  2861. {
  2862. va_list argList;
  2863. va_start(argList, nId);
  2865. CStdStringA strFmt;
  2866. CStdStringA strOut;
  2867. if ( strFmt.Load(nId) )
  2868. strOut.FormatV(strFmt, argList);
  2870. va_end(argList);
  2871. return strOut;
  2872. }
  2873. inline CStdStringA WUFormatA(PCSTR szFormat, ...)
  2874. {
  2875. va_list argList;
  2876. va_start(argList, szFormat);
  2877. CStdStringA strOut;
  2878. strOut.FormatV(szFormat, argList);
  2879. va_end(argList);
  2880. return strOut;
  2881. }
  2883. inline CStdStringW WUFormatW(UINT nId, ...)
  2884. {
  2885. va_list argList;
  2886. va_start(argList, nId);
  2888. CStdStringW strFmt;
  2889. CStdStringW strOut;
  2890. if ( strFmt.Load(nId) )
  2891. strOut.FormatV(strFmt, argList);
  2893. va_end(argList);
  2894. return strOut;
  2895. }
  2896. inline CStdStringW WUFormatW(PCWSTR szwFormat, ...)
  2897. {
  2898. va_list argList;
  2899. va_start(argList, szwFormat);
  2900. CStdStringW strOut;
  2901. strOut.FormatV(szwFormat, argList);
  2902. va_end(argList);
  2903. return strOut;
  2904. }
  2905. #endif // #ifdef SS_ANSI
  2907. #ifdef SS_ANSI
  2908. #else
  2909. // -------------------------------------------------------------------------
  2910. // FUNCTION: WUSysMessage
  2911. //  CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);
  2912. //  CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);
  2913. //           
  2914. // DESCRIPTION:
  2915. //  This function simplifies the process of obtaining a string equivalent
  2916. //  of a system error code returned from GetLastError().  You simply
  2917. //  supply the value returned by GetLastError() to this function and the
  2918. //  corresponding system string is returned in the form of a CStdStringA.
  2919. //
  2920. // PARAMETERS: 
  2921. //  dwError - a DWORD value representing the error code to be translated
  2922. //  dwLangId - the language id to use.  defaults to english.
  2923. //
  2924. // RETURN VALUE: 
  2925. //  a CStdStringA equivalent of the error code.  Currently, this function
  2926. //  only returns either English of the system default language strings.  
  2927. // -------------------------------------------------------------------------
  2928. #define SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT)
  2929. inline CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID)
  2930. {
  2931. CHAR szBuf[512];
  2933. if ( 0 != ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError,
  2934.    dwLangId, szBuf, 511, NULL) )
  2935. return WUFormatA("%s (0x%X)", szBuf, dwError);
  2936. else
  2937.   return WUFormatA("Unknown error (0x%X)", dwError);
  2938. }
  2939. inline CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID)
  2940. {
  2941. WCHAR szBuf[512];
  2943. if ( 0 != ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError,
  2944.    dwLangId, szBuf, 511, NULL) )
  2945. return WUFormatW(L"%s (0x%X)", szBuf, dwError);
  2946. else
  2947.   return WUFormatW(L"Unknown error (0x%X)", dwError);
  2948. }
  2949. #endif
  2951. // Define TCHAR based friendly names for some of these functions
  2953. #ifdef UNICODE
  2954. #define CStdString CStdStringW
  2955. #define WUSysMessage WUSysMessageW
  2956. #define WUFormat WUFormatW
  2957. #else
  2958. #define CStdString CStdStringA
  2959. #define WUSysMessage WUSysMessageA
  2960. #define WUFormat WUFormatA
  2961. #endif
  2963. // ...and some shorter names for the space-efficient
  2965. #define WUSysMsg WUSysMessage
  2966. #define WUSysMsgA WUSysMessageA
  2967. #define WUSysMsgW WUSysMessageW
  2968. #define WUFmtA WUFormatA
  2969. #define WUFmtW WUFormatW
  2970. #define WUFmt WUFormat
  2971. #define WULastErrMsg() WUSysMessage(::GetLastError())
  2972. #define WULastErrMsgA() WUSysMessageA(::GetLastError())
  2973. #define WULastErrMsgW() WUSysMessageW(::GetLastError())
  2976. // -----------------------------------------------------------------------------
  2977. // FUNCTIONAL COMPARATORS:
  2978. // REMARKS:
  2979. // These structs are derived from the std::binary_function template.  They
  2980. // give us functional classes (which may be used in Standard C++ Library
  2981. // collections and algorithms) that perform case-insensitive comparisons of
  2982. // CStdString objects.  This is useful for maps in which the key may be the
  2983. //  proper string but in the wrong case.
  2984. // -----------------------------------------------------------------------------
  2985. #define StdStringLessNoCaseW SSLNCW // avoid VC compiler warning 4786
  2986. #define StdStringEqualsNoCaseW SSENCW
  2987. #define StdStringLessNoCaseA SSLNCA
  2988. #define StdStringEqualsNoCaseA SSENCA
  2990. #ifdef UNICODE
  2991. #define StdStringLessNoCase SSLNCW
  2992. #define StdStringEqualsNoCase SSENCW
  2993. #else
  2994. #define StdStringLessNoCase SSLNCA
  2995. #define StdStringEqualsNoCase SSENCA
  2996. #endif
  2998. struct StdStringLessNoCaseW
  2999. : std::binary_function<CStdStringW, CStdStringW, bool>
  3000. {
  3001. inline
  3002. bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const
  3003. { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; }
  3004. };
  3005. struct StdStringEqualsNoCaseW
  3006. : std::binary_function<CStdStringW, CStdStringW, bool>
  3007. {
  3008. inline
  3009. bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const
  3010. { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; }
  3011. };
  3012. struct StdStringLessNoCaseA
  3013. : std::binary_function<CStdStringA, CStdStringA, bool>
  3014. {
  3015. inline
  3016. bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const
  3017. { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; }
  3018. };
  3019. struct StdStringEqualsNoCaseA
  3020. : std::binary_function<CStdStringA, CStdStringA, bool>
  3021. {
  3022. inline
  3023. bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const
  3024. { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; }
  3025. };
  3027. // If we had to define our own version of TRACE above, get rid of it now
  3029. #ifdef TRACE_DEFINED_HERE
  3030. #undef TRACE
  3031. #undef TRACE_DEFINED_HERE
  3032. #endif
  3035. #endif // #ifndef STDSTRING_H