/[rdesktop]/sourceforge.net/trunk/seamlessrdp/ClientDLL/stdstring.h

This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!

Diff of /sourceforge.net/trunk/seamlessrdp/ClientDLL/stdstring.h

Parent Directory | Revision Log | View Patch Patch

-revision 936 by astrand,
Thu Jun 30 14:46:14 2005 UTC
+revision 937 by astrand,
Fri Jul  1 06:50:52 2005 UTC
 Line 103
  //                                      finally spotting a silly little error in StdCodeCvt that
  //                                      has been causing me (and users of CStdString) problems for
  //                                      years in some relatively rare conversions.  I had reversed
  //                                      two length arguments.
  //
  //    2003-NOV-24 - Thanks to a bunch of people for helping me clean up many
  //                                      compiler warnings (and yes, even a couple of actual compiler
 Line 167
  //
  //    2001-OCT-29 - Added a minor range checking fix for the Mid function to
  //                                      make it as forgiving as CString's version is.  Thanks to
  //                                      Igor Kholodov for noticing this.
  //                                - Added a specialization of std::swap for CStdString.  Thanks
  //                                      to Mike Crusader for suggesting this!  It's commented out
  //                                      because you're not supposed to inject your own code into the
 Line 245
  //                                - Some of the Q172398 fixes were not checking for assignment-
  //                                      to-self.  Fixed.  Thanks to Baptiste Lepilleur.
  //
  //        1999-AUG-20 - Improved Load() function to be more efficient by using
  //                                      SizeOfResource().  Thanks to Rich Zuris for this.
  //                                - Corrected resource ID constructor, again thanks to Rich.
  //                                - Fixed a bug that occurred with UNICODE characters above
  //                                      the first 255 ANSI ones.  Thanks to Craig Watson.
  //                                - Added missing overloads of TrimLeft() and TrimRight().
  //                                      Thanks to Karim Ratib for pointing them out
  //
 Line 274
  //                                - Changed operators << and >> (for MFC CArchive) to serialize
  //                                      EXACTLY as CString's do.  So now you can send a CString out
  //                                      to a CArchive and later read it in as a CStdString.   I have
  //                                      no idea why you would want to do this but you can.
  //
  //        1999-JUN-21 - Changed the CStdString class into the CStdStr template.
  //                                - Fixed FormatV() to correctly decrement the loop counter.
 Line 284
  //                                      using to _alloca().
  //                                - Updated the text conversion macros to properly use code
  //                                      pages and to fit in better in MFC/ATL builds.  In other
  //                                      words, I copied Microsoft's conversion stuff again.
  //                                - Added equivalents of CString::GetBuffer, GetBufferSetLength
  //                                - new sscpy() replacement of CStdString::CopyString()
  //                                - a Trim() function that combines TrimRight() and TrimLeft().
 Line 298
  //        1999-FEB-03 - Fixed a bug in a rarely-used overload of operator+() that
  //                                      caused infinite recursion and stack overflow
  //                                - Added member functions to simplify the process of
  //                                      persisting CStdStrings to/from DCOM IStream interfaces
  //                                - Added functional objects (e.g. StdStringLessNoCase) that
  //                                      allow CStdStrings to be used as keys STL map objects with
  //                                      case-insensitive comparison
  //                                - Added array indexing operators (i.e. operator[]).  I
  //                                      originally assumed that these were unnecessary and would be
  //                                      inherited from basic_string.  However, without them, Visual
  //                                      C++ complains about ambiguous overloads when you try to use
  //                                      them.  Thanks to Julian Selman to pointing this out.
  //
  //        1998-FEB-?? - Added overloads of assign() function to completely account
  //                                      for Q172398 bug.  Thanks to "Pete the Plumber" for this
 Line 316
  // COPYRIGHT:
  //              2002 Joseph M. O'Leary.  This code is 100% free.  Use it anywhere you
  //      want.  Rewrite it, restructure it, whatever.  If you can write software
  //      that makes money off of it, good for you.  I kinda like capitalism.
  //      Please don't blame me if it causes your $30 billion dollar satellite
  //      explode in orbit.  If you redistribute it in any form, I'd appreciate it
  //      if you would leave this notice here.
 Line 411
  //      out of the MFC world and you don't want to rewrite all your calls to
  //      Format(), then you can define this flag and it will no longer crash.
  //
  //      Note however that this ONLY works for Format(), not sprintf, fprintf,
  //      etc.  If you pass a CStdString object to one of those functions, your
  //      program will crash.  Not much I can do to get around this, short of
  //      writing substitutes for those functions as well.
 Line 461
  //      standard library functions to do it's work.  It will NOT attempt to use
  //      any Win32 of Visual C++ specific functions -- even if they are
  //      available.  You may define this flag yourself to prevent any Win32
  //      of VC++ specific functions from being called.
  // If we're not on Win32, we MUST use an ANSI build
 Line 508
  // Compiler Error regarding _UNICODE and UNICODE
  // -----------------------------------------------
  // Microsoft header files are screwy.  Sometimes they depend on a preprocessor
  // flag named "_UNICODE".  Other times they check "UNICODE" (note the lack of
  // leading underscore in the second version".  In several places, they silently
  // "synchronize" these two flags this by defining one of the other was defined.
  // In older version of this header, I used to try to do the same thing.
  //
  // However experience has taught me that this is a bad idea.  You get weird
  // compiler errors that seem to indicate things like LPWSTR and LPTSTR not being
 Line 535
  #ifdef _MSC_VER
  #if defined (_UNICODE) && !defined (UNICODE)
  #error UNICODE defined  but not UNICODE
-         //      #define UNICODE  // no longer silently fix this
+ //      #define UNICODE  // no longer silently fix this
  #endif
  #if defined (UNICODE) && !defined (_UNICODE)
  #error Warning, UNICODE defined  but not _UNICODE
-         //      #define _UNICODE  // no longer silently fix this
+ //      #define _UNICODE  // no longer silently fix this
  #endif
  #endif
  // -----------------------------------------------------------------------------
  // MIN and MAX.  The Standard C++ template versions go by so many names (at
  // at least in the MS implementation) that you never know what's available
  // -----------------------------------------------------------------------------
  template < class Type >
-     inline const Type & SSMIN(const Type & arg1, const Type & arg2)
+ inline const Type & SSMIN(const Type & arg1, const Type & arg2)
  {
      return arg2 < arg1 ? arg2 : arg1;
  }
  template < class Type >
-     inline const Type & SSMAX(const Type & arg1, const Type & arg2)
+ inline const Type & SSMAX(const Type & arg1, const Type & arg2)
  {
      return arg2 > arg1 ? arg2 : arg1;
  }
 Line 564 
 template < class Type >
  #if !defined(W32BASE_H)
-         // If they want us to use only standard C++ stuff (no Win32 stuff)
+ // If they want us to use only standard C++ stuff (no Win32 stuff)
  #ifdef SS_ANSI
-                 // On Win32 we have TCHAR.H so just include it.  This is NOT violating
+ // On Win32 we have TCHAR.H so just include it.  This is NOT violating
-         // the spirit of SS_ANSI as we are not calling any Win32 functions here.
+ // the spirit of SS_ANSI as we are not calling any Win32 functions here.
  #ifdef SS_WIN32
 Line 579 
 template < class Type >
  #define STRICT
  #endif
-         // ... but on non-Win32 platforms, we must #define the types we need.
+ // ... but on non-Win32 platforms, we must #define the types we need.
  #else
 Line 597 
 typedef wchar_t OLECHAR;
  #endif // #ifndef _WIN32
-                 // Make sure ASSERT and verify are defined using only ANSI stuff
+ // Make sure ASSERT and verify are defined using only ANSI stuff
  #ifndef ASSERT
  #include <assert.h>
 Line 619 
 typedef wchar_t OLECHAR;
  #define STRICT
  #endif
-                 // Make sure ASSERT and verify are defined
+ // Make sure ASSERT and verify are defined
  #ifndef ASSERT
  #include <crtdbg.h>
 Line 727 
 typedef void *LPCVOID;
  #ifndef SS_USE_FACET
-         // STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for
+ // STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) for
-         // all MSVC builds, erroneously in my opinion.  It causes problems for
+ // all MSVC builds, erroneously in my opinion.  It causes problems for
-         // my SS_ANSI builds.  In my code, I always comment out that line.  You'll
+ // my SS_ANSI builds.  In my code, I always comment out that line.  You'll
-         // find it in   \stlport\config\stl_msvc.h
+ // find it in   \stlport\config\stl_msvc.h
  #if defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= 0x400 )
 Line 745 
 typedef void *LPCVOID;
  #define SS_USE_FACET(loc, fac) std::_USE(loc, fac)
-         // ...and
+ // ...and
  #elif defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE)
  #define SS_USE_FACET(loc, fac) std::use_facet(loc, (fac*)0)
 Line 765 
 typedef void *LPCVOID;
  #include <wchar.h>              // Added to Std Library with Amendment #1.
  // First define the conversion helper functions.  We define these regardless of
  // any preprocessor macro settings since their names won't collide.
  // Not sure if we need all these headers.   I believe ANSI says we do.
 Line 803 
 inline PWSTR StdCodeCvt(PWSTR pDstW, int
          SSCodeCvt::result res = SSCodeCvt::ok;
          const SSCodeCvt & conv = SS_USE_FACET(loc, SSCodeCvt);
          SSCodeCvt::state_type st = {
 };
          res = conv.in(st,
                        pSrcA, pSrcA + nSrc, pNextSrcA,
                        pDstW, pDstW + nDst, pNextDstW);
 Line 842 
 inline PSTR StdCodeCvt(PSTR pDstA, int n
          SSCodeCvt::result res = SSCodeCvt::ok;
          const SSCodeCvt & conv = SS_USE_FACET(loc, SSCodeCvt);
          SSCodeCvt::state_type st = {
 };
          res = conv.out(st,
                         pSrcW, pSrcW + nSrc, pNextSrcW,
                         pDstA, pDstA + nDst, pNextDstA);
 Line 869 
 inline PUSTR StdCodeCvt(PUSTR pDstA, int
  /*
  #else   // ...or are we doing things assuming win32 and Visual C++?
          inline PWSTR StdCodeCvt(PWSTR pDstW, int nDst, PCSTR pSrcA, int nSrc, UINT acp=CP_ACP)
          {
                  ASSERT(0 != pSrcA);
 Line 882 
 inline PUSTR StdCodeCvt(PUSTR pDstA, int
          {
                  return StdCodeCvt(pDstW, nDst, (PCSTR)pSrcA, nSrc, acp);
          }
          inline PSTR StdCodeCvt(PSTR pDstA, nDst PCWSTR pSrcW, int nSrc, UINT acp=CP_ACP)
          {
                  ASSERT(0 != pDstA);
 Line 895 
 inline PUSTR StdCodeCvt(PUSTR pDstA, int
          {
                  return (PUSTR)StdCodeCvt((PSTR)pDstA, nDst, pSrcW, nSrc, acp);
          }
  #endif
  */
  // Unicode/MBCS conversion macros are only available on implementations of
  // the "C" library that have the non-standard _alloca function.  As far as I
  // know that's only Microsoft's though I've heard that the function exists
  // elsewhere.
  #if defined(SS_ALLOCA) && !defined SS_NO_CONVERSION
  #include <malloc.h>             // needed for _alloca
-     // Define our conversion macros to look exactly like Microsoft's to
+ // Define our conversion macros to look exactly like Microsoft's to
-     // facilitate using this stuff both with and without MFC/ATL
+ // facilitate using this stuff both with and without MFC/ATL
  #ifdef _CONVERSION_USES_THREAD_LOCALE
 Line 959 
 inline PUSTR StdCodeCvt(PUSTR pDstA, int
  #define SSA2T   SSA2W
  #define SST2CA  SSW2CA
  #define SSA2CT  SSA2CW
-                 // (Did you get a compiler error here about not being able to convert
+ // (Did you get a compiler error here about not being able to convert
-                 // PTSTR into PWSTR?  Then your _UNICODE and UNICODE flags are messed
+ // PTSTR into PWSTR?  Then your _UNICODE and UNICODE flags are messed
-                 // up.  Best bet: #define BOTH macros before including any MS headers.)
+ // up.  Best bet: #define BOTH macros before including any MS headers.)
  inline PWSTR SST2W(PTSTR p)
  {
      return p;
 Line 1002 
 inline PCTSTR SSA2CT(PCSTR p)
  #endif // #ifdef UNICODE
  #if defined(UNICODE)
-     // in these cases the default (TCHAR) is the same as OLECHAR
+ // in these cases the default (TCHAR) is the same as OLECHAR
  inline PCOLESTR SST2COLE(PCTSTR p)
  {
      return p;
 Line 1020 
 inline PTSTR SSOLE2T(POLESTR p)
      return p;
  }
  #elif defined(OLE2ANSI)
-     // in these cases the default (TCHAR) is the same as OLECHAR
+ // in these cases the default (TCHAR) is the same as OLECHAR
  inline PCOLESTR SST2COLE(PCTSTR p)
  {
      return p;
 Line 1038 
 inline PTSTR SSOLE2T(POLESTR p)
      return p;
  }
  #else
-             //CharNextW doesn't work on Win95 so we use this
+ //CharNextW doesn't work on Win95 so we use this
  #define SST2COLE(pa)    SSA2CW((pa))
  #define SST2OLE(pa)             SSA2W((pa))
  #define SSOLE2CT(po)    SSW2CA((po))
 Line 1089 
 inline PCWSTR SSOLE2CW(PCOLESTR p)
  }
  #endif
-     // Above we've defined macros that look like MS' but all have
+ // Above we've defined macros that look like MS' but all have
-     // an 'SS' prefix.  Now we need the real macros.  We'll either
+ // an 'SS' prefix.  Now we need the real macros.  We'll either
-     // get them from the macros above or from MFC/ATL.
+ // get them from the macros above or from MFC/ATL.
  #if defined (USES_CONVERSION)
 Line 1151 
 inline PSTR StdCodeCvt(PSTR pDst, int nD
      if (nChars > 0) {
          pDst[0] = '\0';
          std::basic_string < char >::traits_type::copy(pDst, pSrc, nChars);
- //              std::char_traits<char>::copy(pDst, pSrc, nChars);
+         //              std::char_traits<char>::copy(pDst, pSrc, nChars);
          pDst[nChars] = '\0';
      }
 Line 1173 
 inline PWSTR StdCodeCvt(PWSTR pDst, int
      if (nChars > 0) {
          pDst[0] = '\0';
          std::basic_string < wchar_t >::traits_type::copy(pDst, pSrc, nChars);
- //              std::char_traits<wchar_t>::copy(pDst, pSrc, nChars);
+         //              std::char_traits<wchar_t>::copy(pDst, pSrc, nChars);
          pDst[nChars] = '\0';
      }
 Line 1210 
 typedef std::basic_string < TCHAR > tstr
  // Therefore, to keep the CStdStr declaration simple, we have these inline
  // functions.  The template calls them often.  Since they are inline (and NOT
  // exported when this is built as a DLL), they will probably be resolved away
  // to nothing.
  //
  // Without these functions, the CStdStr<> template would probably have to broken
  // out into two, almost identical classes.  Either that or it would be a huge,
  // convoluted mess, with tons of "if" statements all over the place checking the
  // size of template parameter CT.
  //
  // In several cases, you will see two versions of each function.  One version is
  // the more portable, standard way of doing things, while the other is the
  // non-standard, but often significantly faster Visual C++ way.
 Line 1233 
 typedef std::basic_string < TCHAR > tstr
  // -----------------------------------------------------------------------------
  // sslen: strlen/wcslen wrappers
  // -----------------------------------------------------------------------------
- template < typename CT > inline int sslen(const CT * pT)
+ template < typename CT >
+ inline int sslen(const CT * pT)
  {
      return 0 == pT ? 0 : (int) std::basic_string <
-         CT >::traits_type::length(pT);
+            CT >::traits_type::length(pT);
- //      return 0 == pT ? 0 : std::char_traits<CT>::length(pT);
+     //      return 0 == pT ? 0 : std::char_traits<CT>::length(pT);
  }
  inline SS_NOTHROW int sslen(const std::string & s)
  {
-Line 1252 
 inline SS_NOTHROW int sslen(const std::w
+Line 1253 
 inline SS_NOTHROW int sslen(const std::w
  // sstolower/sstoupper -- convert characters to upper/lower case
  // -----------------------------------------------------------------------------
  template < typename CT >
-     inline CT sstolower(const CT & t, const std::locale & loc = std::locale())
+ inline CT sstolower(const CT & t, const std::locale & loc = std::locale())
  {
      return std::tolower < CT > (t, loc);
  }
  template < typename CT >
-     inline CT sstoupper(const CT & t, const std::locale & loc = std::locale())
+ inline CT sstoupper(const CT & t, const std::locale & loc = std::locale())
  {
      return std::toupper < CT > (t, loc);
  }
-Line 1305 
 inline void ssasn(std::string & sDst, co
+Line 1306 
 inline void ssasn(std::string & sDst, co
  {
      if (sSrc.empty()) {
          sDst.erase();
-     }
+     } else {
-     else {
          int nDst = static_cast < int >(sSrc.size());
          // In MBCS builds, pad the buffer to account for the possibility of
          // some 3 byte characters.  Not perfect but should get most cases.
  #ifdef SS_MBCS
          nDst = static_cast < int >(static_cast < double >(nDst) * 1.3);
  #endif
-Line 1324 
 inline void ssasn(std::string & sDst, co
+Line 1325 
 inline void ssasn(std::string & sDst, co
          // In MBCS builds, we don't know how long the destination string will be.
  #ifdef SS_MBCS
          sDst.resize(sslen(szCvt));
  #else
          szCvt;
          sDst.resize(sSrc.size());
  #endif
      }
  }
  inline void ssasn(std::string & sDst, PCWSTR pW)
-Line 1342 
 inline void ssasn(std::string & sDst, PC
+Line 1346 
 inline void ssasn(std::string & sDst, PC
          // some 3 byte characters.  Not perfect but should get most cases.
  #ifdef SS_MBCS
          nDst = static_cast < int >(static_cast < double >(nDst) * 1.3);
  #endif
-Line 1353 
 inline void ssasn(std::string & sDst, PC
+Line 1358 
 inline void ssasn(std::string & sDst, PC
          // In MBCS builds, we don't know how long the destination string will be.
  #ifdef SS_MBCS
          sDst.resize(sslen(szCvt));
  #else
          sDst.resize(nDst);
          szCvt;
  #endif
-     }
-     else {
+     } else {
          sDst.erase();
      }
  }
-Line 1405 
 inline void ssasn(std::wstring & sDst, c
+Line 1412 
 inline void ssasn(std::wstring & sDst, c
  {
      if (sSrc.empty()) {
          sDst.erase();
-     }
+     } else {
-     else {
          int nSrc = static_cast < int >(sSrc.size());
          int nDst = nSrc;
-Line 1424 
 inline void ssasn(std::wstring & sDst, P
+Line 1430 
 inline void ssasn(std::wstring & sDst, P
      if (0 == nSrc) {
          sDst.erase();
-     }
+     } else {
-     else {
          int nDst = nSrc;
          sDst.resize(nDst + 1);
          PCWSTR szCvt =
-Line 1458 
 inline void ssadd(std::string & sDst, co
+Line 1463 
 inline void ssadd(std::string & sDst, co
          // some 3 byte characters.  Not perfect but should get most cases.
  #ifdef SS_MBCS
          nAdd = static_cast < int >(static_cast < double >(nAdd) * 1.3);
  #endif
-Line 1467 
 inline void ssadd(std::string & sDst, co
+Line 1473 
 inline void ssadd(std::string & sDst, co
                         nAdd, sSrc.c_str(), nSrc);
  #ifdef SS_MBCS
          sDst.resize(nDst + sslen(szCvt));
  #else
          sDst.resize(nDst + nAdd);
          szCvt;
  #endif
      }
  }
  inline void ssadd(std::string & sDst, const std::string & sSrc)
-Line 1486 
 inline void ssadd(std::string & sDst, PC
+Line 1495 
 inline void ssadd(std::string & sDst, PC
          int nAdd = nSrc;
  #ifdef SS_MBCS
          nAdd = static_cast < int >(static_cast < double >(nAdd) * 1.3);
  #endif
-Line 1495 
 inline void ssadd(std::string & sDst, PC
+Line 1505 
 inline void ssadd(std::string & sDst, PC
                         nAdd, pW, nSrc);
  #ifdef SS_MBCS
          sDst.resize(nDst + sslen(szCvt));
  #else
          sDst.resize(nDst + nSrc);
          szCvt;
  #endif
      }
  }
  inline void ssadd(std::string & sDst, PCSTR pA)
-Line 1515 
 inline void ssadd(std::string & sDst, PC
+Line 1528 
 inline void ssadd(std::string & sDst, PC
                  sDst.append(std::string(pA));
              else
                  sDst.append(pA);
-         }
+         } else {
-         else {
              sDst.append(pA);
          }
      }
-Line 1537 
 inline void ssadd(std::wstring & sDst, c
+Line 1549 
 inline void ssadd(std::wstring & sDst, c
                         nSrc, sSrc.c_str(), nSrc + 1);
  #ifdef SS_MBCS
          sDst.resize(nDst + sslen(szCvt));
  #else
          sDst.resize(nDst + nSrc);
          szCvt;
  #endif
      }
  }
  inline void ssadd(std::wstring & sDst, PCSTR pA)
-Line 1557 
 inline void ssadd(std::wstring & sDst, P
+Line 1572 
 inline void ssadd(std::wstring & sDst, P
                         nSrc, pA, nSrc + 1);
  #ifdef SS_MBCS
          sDst.resize(nDst + sslen(szCvt));
  #else
          sDst.resize(nDst + nSrc);
          szCvt;
  #endif
      }
  }
  inline void ssadd(std::wstring & sDst, PCWSTR pW)
-Line 1577 
 inline void ssadd(std::wstring & sDst, P
+Line 1595 
 inline void ssadd(std::wstring & sDst, P
                  sDst.append(std::wstring(pW));
              else
                  sDst.append(pW);
-         }
+         } else {
-         else {
              sDst.append(pW);
          }
      }
-Line 1588 
 inline void ssadd(std::wstring & sDst, P
+Line 1605 
 inline void ssadd(std::wstring & sDst, P
  // -----------------------------------------------------------------------------
  // sscmp: comparison (case sensitive, not affected by locale)
  // -----------------------------------------------------------------------------
- template < typename CT > inline int sscmp(const CT * pA1, const CT * pA2)
+ template < typename CT >
+ inline int sscmp(const CT * pA1, const CT * pA2)
  {
      CT f;
      CT l;
-Line 1604 
 template < typename CT > inline int sscm
+Line 1622 
 template < typename CT > inline int sscm
  // -----------------------------------------------------------------------------
  // ssicmp: comparison (case INsensitive, not affected by locale)
  // -----------------------------------------------------------------------------
- template < typename CT > inline int ssicmp(const CT * pA1, const CT * pA2)
+ template < typename CT >
+ inline int ssicmp(const CT * pA1, const CT * pA2)
  {
      // Using the "C" locale = "not affected by locale"
-Line 1626 
 template < typename CT > inline int ssic
+Line 1645 
 template < typename CT > inline int ssic
  // -----------------------------------------------------------------------------
  template < typename CT >
-     inline void sslwr(CT * pT, size_t nLen, const std::locale & loc =
+ inline void sslwr(CT * pT, size_t nLen, const std::locale & loc =
                        std::locale())
  {
      SS_USE_FACET(loc, std::ctype < CT >).tolower(pT, pT + nLen);
  }
  template < typename CT >
-     inline void ssupr(CT * pT, size_t nLen, const std::locale & loc =
+ inline void ssupr(CT * pT, size_t nLen, const std::locale & loc =
                        std::locale())
  {
      SS_USE_FACET(loc, std::ctype < CT >).toupper(pT, pT + nLen);
-Line 1643 
 template < typename CT >
+Line 1662 
 template < typename CT >
  // builds we can't use _vsnprintf/_vsnwsprintf because they're MS extensions.
  //
  // -----------------------------------------------------------------------------
  // Borland's headers put some ANSI "C" functions in the 'std' namespace.
  // Promote them to the global namespace so we can use them here.
  #if defined(__BORLANDC__)
-Line 1651 
 using std::vsprintf;
+Line 1670 
 using std::vsprintf;
  using std::vswprintf;
  #endif
-         // GNU is supposed to have vsnprintf and vsnwprintf.  But only the newer
+ // GNU is supposed to have vsnprintf and vsnwprintf.  But only the newer
-         // distributions do.
+ // distributions do.
  #if defined(__GNUC__)
-Line 1665 
 inline int ssvsprintf(PWSTR pW, size_t n
+Line 1684 
 inline int ssvsprintf(PWSTR pW, size_t n
      return vswprintf(pW, nCount, pFmtW, vl);
  }
-         // Microsofties can use
+ // Microsofties can use
  #elif defined(_MSC_VER) && !defined(SS_ANSI)
  inline int ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl)
-Line 1679 
 inline int ssnprintf(PWSTR pW, size_t nC
+Line 1698 
 inline int ssnprintf(PWSTR pW, size_t nC
  #elif !defined (SS_DANGEROUS_FORMAT)
-         // GOT COMPILER PROBLEMS HERE?
+ // GOT COMPILER PROBLEMS HERE?
-         // ---------------------------
+ // ---------------------------
-         // Does your compiler choke on one or more of the following 2 functions?  It
+ // Does your compiler choke on one or more of the following 2 functions?  It
-         // probably means that you don't have have either vsnprintf or vsnwprintf in
+ // probably means that you don't have have either vsnprintf or vsnwprintf in
-         // your version of the CRT.  This is understandable since neither is an ANSI
+ // your version of the CRT.  This is understandable since neither is an ANSI
-         // "C" function.  However it still leaves you in a dilemma.  In order to make
+ // "C" function.  However it still leaves you in a dilemma.  In order to make
-         // this code build, you're going to have to to use some non-length-checked
+ // this code build, you're going to have to to use some non-length-checked
-         // formatting functions that every CRT has:  vsprintf and vswprintf.
+ // formatting functions that every CRT has:  vsprintf and vswprintf.
-         //
+ //
-         // This is very dangerous.  With the proper erroneous (or malicious) code, it
+ // This is very dangerous.  With the proper erroneous (or malicious) code, it
-         // can lead to buffer overlows and crashing your PC.  Use at your own risk
+ // can lead to buffer overlows and crashing your PC.  Use at your own risk
-         // In order to use them, just #define SS_DANGEROUS_FORMAT at the top of
+ // In order to use them, just #define SS_DANGEROUS_FORMAT at the top of
-         // this file.
+ // this file.
-         //
+ //
-         // Even THEN you might not be all the way home due to some non-conforming
+ // Even THEN you might not be all the way home due to some non-conforming
-         // distributions.  More on this in the comments below.
+ // distributions.  More on this in the comments below.
  inline int ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl)
  {
-Line 1715 
 inline int ssvsprintf(PSTR pA, size_t /*
+Line 1734 
 inline int ssvsprintf(PSTR pA, size_t /*
  inline int ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl)
  {
      // JMO: Some distributions of the "C" have a version of vswprintf that
      // takes 3 arguments (e.g. Microsoft, Borland, GNU).  Others have a
      // version which takes 4 arguments (an extra "count" argument in the
      // second position.  The best stab I can take at this so far is that if
      // you are NOT running with MS, Borland, or GNU, then I'll assume you
-Line 1731 
 inline int ssvsprintf(PWSTR pW, size_t n
+Line 1750 
 inline int ssvsprintf(PWSTR pW, size_t n
      //
      // Thanks to Ronny Schulz for the SGI-specific checks here.
- //      #if !defined(__MWERKS__) && !defined(__SUNPRO_CC_COMPAT) && !defined(__SUNPRO_CC)
+     //      #if !defined(__MWERKS__) && !defined(__SUNPRO_CC_COMPAT) && !defined(__SUNPRO_CC)
  #if    !defined(_MSC_VER) \
          && !defined (__BORLANDC__) \
          && !defined(__GNUC__) \
-Line 1744 
 inline int ssvsprintf(PWSTR pW, size_t n
+Line 1763 
 inline int ssvsprintf(PWSTR pW, size_t n
  #elif defined(__sgi)
-     nCount;
+ nCount;
-     return vsprintf((char *) pW, (char *) pFmtW, vl);
+ return vsprintf((char *) pW, (char *) pFmtW, vl);
  #else
-     nCount;
+ nCount;
-     return vswprintf(pW, pFmtW, vl);
+ return vswprintf(pW, pFmtW, vl);
  #endif
-Line 1783 
 inline int ssload(HMODULE hInst, UINT uI
+Line 1802 
 inline int ssload(HMODULE hInst, UINT uI
  //              functions appear to return the opposite of what they should
  // -----------------------------------------------------------------------------
  template < typename CT >
-     inline int sscoll(const CT * sz1, int nLen1, const CT * sz2, int nLen2)
+ inline int sscoll(const CT * sz1, int nLen1, const CT * sz2, int nLen2)
  {
      const std::collate < CT > &coll =
          SS_USE_FACET(std::locale(), std::collate < CT >);
-Line 1791 
 template < typename CT >
+Line 1810 
 template < typename CT >
      return coll.compare(sz2, sz2 + nLen2, sz1, sz1 + nLen1);
  }
  template < typename CT >
-     inline int ssicoll(const CT * sz1, int nLen1, const CT * sz2, int nLen2)
+ inline int ssicoll(const CT * sz1, int nLen1, const CT * sz2, int nLen2)
  {
      const std::locale loc;
      const std::collate < CT > &coll = SS_USE_FACET(loc, std::collate < CT >);
-Line 1800 
 template < typename CT >
+Line 1819 
 template < typename CT >
      // facet typedefs so we'll just default to basic_string and hope
      // that's what the collate facet uses (which it generally should)
- //      std::collate<CT>::string_type s1(sz1);
+     //      std::collate<CT>::string_type s1(sz1);
- //      std::collate<CT>::string_type s2(sz2);
+     //      std::collate<CT>::string_type s2(sz2);
      const std::basic_string < CT > sEmpty;
      std::basic_string < CT > s1(sz1 ? sz1 : sEmpty.c_str());
      std::basic_string < CT > s2(sz2 ? sz2 : sEmpty.c_str());
-Line 1862 
 inline DWORD ssfmtmsg(DWORD dwFlags, LPC
+Line 1881 
 inline DWORD ssfmtmsg(DWORD dwFlags, LPC
  //              characters.  The return value is the number of characters copied,
  //              not including the NULL terminator.
  //
  // PARAMETERS:
  //              pSrc - the string to be copied FROM.  May be a char based string, an
  //                         MBCS string (in Win32 builds) or a wide string (wchar_t).
  //              pSrc - the string to be copied TO.  Also may be either MBCS or wide
-Line 1878 
 inline DWORD ssfmtmsg(DWORD dwFlags, LPC
+Line 1897 
 inline DWORD ssfmtmsg(DWORD dwFlags, LPC
  // RETURN VALUE: none
  // -----------------------------------------------------------------------------
  template < typename CT1, typename CT2 >
-     inline int sscpycvt(CT1 * pDst, const CT2 * pSrc, int nMax)
+ inline int sscpycvt(CT1 * pDst, const CT2 * pSrc, int nMax)
  {
      // Note -- we assume pDst is big enough to hold pSrc.  If not, we're in
      // big trouble.  No bounds checking.  Caveat emptor.
-Line 1924 
 inline int sscpycvt(PWSTR pDst, PCSTR pS
+Line 1943 
 inline int sscpycvt(PWSTR pDst, PCSTR pS
  }
  template < typename CT1, typename CT2 >
-     inline int sscpy(CT1 * pDst, const CT2 * pSrc, int nMax, int nLen)
+ inline int sscpy(CT1 * pDst, const CT2 * pSrc, int nMax, int nLen)
  {
      return sscpycvt(pDst, pSrc, SSMIN(nMax, nLen));
  }
  template < typename CT1, typename CT2 >
-     inline int sscpy(CT1 * pDst, const CT2 * pSrc, int nMax)
+ inline int sscpy(CT1 * pDst, const CT2 * pSrc, int nMax)
  {
      return sscpycvt(pDst, pSrc, SSMIN(nMax, sslen(pSrc)));
  }
  template < typename CT1, typename CT2 >
-     inline int sscpy(CT1 * pDst, const CT2 * pSrc)
+ inline int sscpy(CT1 * pDst, const CT2 * pSrc)
  {
      return sscpycvt(pDst, pSrc, sslen(pSrc));
  }
  template < typename CT1, typename CT2 >
-     inline int sscpy(CT1 * pDst, const std::basic_string < CT2 > &sSrc,
+ inline int sscpy(CT1 * pDst, const std::basic_string < CT2 > &sSrc,
-                      int nMax)
+                  int nMax)
  {
      return sscpycvt(pDst, sSrc.c_str(), SSMIN(nMax, (int) sSrc.length()));
  }
  template < typename CT1, typename CT2 >
-     inline int sscpy(CT1 * pDst, const std::basic_string < CT2 > &sSrc)
+ inline int sscpy(CT1 * pDst, const std::basic_string < CT2 > &sSrc)
  {
      return sscpycvt(pDst, sSrc.c_str(), (int) sSrc.length());
  }
  #ifdef SS_INC_COMDEF
  template < typename CT1 >
-     inline int sscpy(CT1 * pDst, const _bstr_t & bs, int nMax)
+ inline int sscpy(CT1 * pDst, const _bstr_t & bs, int nMax)
  {
      return sscpycvt(pDst, static_cast < PCOLESTR > (bs),
                      SSMIN(nMax, static_cast < int >(bs.length())));
  }
- template < typename CT1 > inline int sscpy(CT1 * pDst, const _bstr_t & bs)
+ template < typename CT1 >
+ inline int sscpy(CT1 * pDst, const _bstr_t & bs)
  {
      return sscpy(pDst, bs, static_cast < int >(bs.length()));
  }
-Line 1969 
 template < typename CT1 > inline int ssc
+Line 1989 
 template < typename CT1 > inline int ssc
  // -----------------------------------------------------------------------------
  template < typename CT >
-     struct SSToUpper:public std::binary_function < CT, std::locale, CT >
+ struct SSToUpper:public std::binary_function < CT, std::locale, CT >
  {
      inline CT operator() (const CT & t, const std::locale & loc) const
      {
-Line 1977 
 template < typename CT >
+Line 1997 
 template < typename CT >
      }
  };
  template < typename CT >
-     struct SSToLower:public std::binary_function < CT, std::locale, CT >
+ struct SSToLower:public std::binary_function < CT, std::locale, CT >
  {
      inline CT operator() (const CT & t, const std::locale & loc) const
      {
-Line 1994 
 template < typename CT >
+Line 2014 
 template < typename CT >
  //      inline bool operator() (CT t) { return !std::isspace(t, loc); }
  //};
  template < typename CT >
-     struct NotSpace:public std::unary_function < CT, bool >
+ struct NotSpace:public std::unary_function < CT, bool >
  {
      // DINKUMWARE BUG:
      // Note -- using std::isspace in a COM DLL gives us access violations
-Line 2009 
 template < typename CT >
+Line 2029 
 template < typename CT >
      // iswspace() from the CRT unless they specify SS_ANSI
      const std::locale loc;
-   NotSpace(const std::locale & locArg = std::locale()):loc(locArg) {
+     NotSpace(const std::locale & locArg = std::locale()):loc(locArg)
-     }
+     {}
      bool operator() (CT t) const
      {
          return !std::isspace(t, loc);
-Line 2033 
 template < typename CT >
+Line 2053 
 template < typename CT >
  //              easy to use as the MFC CString class.
  //
  //              Note that although this is a template, it makes the assumption that the
  //              template argument (CT, the character type) is either char or wchar_t.
  // =============================================================================
  //#define CStdStr _SS   // avoid compiler warning 4786
-Line 2042 
 template < typename CT >
+Line 2062 
 template < typename CT >
  //    PCSTR  FmtArg(const std::string& arg)  { return arg.c_str(); }
  //    PCWSTR FmtArg(const std::wstring& arg) { return arg.c_str(); }
- template < typename ARG > struct FmtArg
+ template < typename ARG >
+ struct FmtArg
  {
      explicit FmtArg(const ARG & arg):a_(arg)
-     {
+     {}
-     }
      const ARG & operator() () const
      {
          return a_;
      }
      const ARG & a_;
-   private:
+ private:
      FmtArg & operator=(const FmtArg &)
      {
          return *this;
      }
  };
- template < typename CT > class CStdStr:public std::basic_string < CT > {
+ template < typename CT >
-     // Typedefs for shorter names.  Using these names also appears to help
+ class CStdStr:public std::basic_string < CT >
-     // us avoid some ambiguities that otherwise arise on some platforms
+ {
+         // Typedefs for shorter names.  Using these names also appears to help
+         // us avoid some ambiguities that otherwise arise on some platforms
  #define MYBASE std::basic_string<CT>    // my base class
-     //typedef typename std::basic_string<CT>                MYBASE;  // my base class
+         //typedef typename std::basic_string<CT>                MYBASE;  // my base class
-     typedef CStdStr < CT > MYTYPE;      // myself
+         typedef CStdStr < CT > MYTYPE;      // myself
-     typedef typename MYBASE::const_pointer PCMYSTR;     // PCSTR or PCWSTR
+         typedef typename MYBASE::const_pointer PCMYSTR;     // PCSTR or PCWSTR
-     typedef typename MYBASE::pointer PMYSTR;    // PSTR or PWSTR
+         typedef typename MYBASE::pointer PMYSTR;    // PSTR or PWSTR
-     typedef typename MYBASE::iterator MYITER;   // my iterator type
+         typedef typename MYBASE::iterator MYITER;   // my iterator type
-     typedef typename MYBASE::const_iterator MYCITER;    // you get the idea...
+         typedef typename MYBASE::const_iterator MYCITER;    // you get the idea...
-     typedef typename MYBASE::reverse_iterator MYRITER;
+         typedef typename MYBASE::reverse_iterator MYRITER;
-     typedef typename MYBASE::size_type MYSIZE;
+         typedef typename MYBASE::size_type MYSIZE;
-     typedef typename MYBASE::value_type MYVAL;
+         typedef typename MYBASE::value_type MYVAL;
-     typedef typename MYBASE::allocator_type MYALLOC;
+         typedef typename MYBASE::allocator_type MYALLOC;
-   public:
+     public:
-     // shorthand conversion from PCTSTR to string resource ID
+         // shorthand conversion from PCTSTR to string resource ID
  #define SSRES(pctstr)  LOWORD(reinterpret_cast<unsigned long>(pctstr))
-     bool TryLoad(const void *pT)
+         bool TryLoad(const void *pT)
-     {
+         {
-         bool bLoaded = false;
+             bool bLoaded = false;
  #if defined(SS_WIN32) && !defined(SS_ANSI)
-         if ((pT != NULL) && SS_IS_INTRESOURCE(pT)) {
-             UINT nId = LOWORD(reinterpret_cast < unsigned long >(pT));
+             if ((pT != NULL) && SS_IS_INTRESOURCE(pT)) {
-             if (!LoadString(nId)) {
+                 UINT nId = LOWORD(reinterpret_cast < unsigned long >(pT));
-                 TRACE(_T("Can't load string %u\n"), SSRES(pT));
+                 if (!LoadString(nId)) {
+                     TRACE(_T("Can't load string %u\n"), SSRES(pT));
+                 }
+                 bLoaded = true;
              }
-             bLoaded = true;
-         }
  #endif
-         return bLoaded;
+             return bLoaded;
-     }
+         }
-     // CStdStr inline constructors
+         // CStdStr inline constructors
-     CStdStr() {
+         CStdStr()
-     }
+         {}
-   CStdStr(const MYTYPE & str):MYBASE(SSREF(str)) {
+         CStdStr(const MYTYPE & str):MYBASE(SSREF(str))
-     }
+         {}
-     CStdStr(const std::string & str)
+         CStdStr(const std::string & str)
-     {
+         {
-         ssasn(*this, SSREF(str));
+             ssasn(*this, SSREF(str));
-     }
+         }
-     CStdStr(const std::wstring & str)
+         CStdStr(const std::wstring & str)
-     {
+         {
-         ssasn(*this, SSREF(str));
+             ssasn(*this, SSREF(str));
-     }
+         }
-   CStdStr(PCMYSTR pT, MYSIZE n):MYBASE(pT, n) {
+         CStdStr(PCMYSTR pT, MYSIZE n):MYBASE(pT, n)
-     }
+         {}
  #ifdef SS_UNSIGNED
-     CStdStr(PCUSTR pU) {
-         *this = reinterpret_cast < PCSTR > (pU);
+         CStdStr(PCUSTR pU)
-     }
+         {
+             *this = reinterpret_cast < PCSTR > (pU);
+         }
  #endif
-     CStdStr(PCSTR pA) {
+         CStdStr(PCSTR pA)
+         {
  #ifdef SS_ANSI
-         *this = pA;
- #else
-         if (!TryLoad(pA))
              *this = pA;
+ #else
+             if (!TryLoad(pA))
+                 *this = pA;
  #endif
-     }
-     CStdStr(PCWSTR pW) {
+         }
+         CStdStr(PCWSTR pW)
+         {
  #ifdef SS_ANSI
-         *this = pW;
- #else
-         if (!TryLoad(pW))
              *this = pW;
+ #else
+             if (!TryLoad(pW))
+                 *this = pW;
  #endif
-     }
-     CStdStr(MYCITER first, MYCITER last)
+         }
-   :    MYBASE(first, last) {
-     }
-     CStdStr(MYSIZE nSize, MYVAL ch, const MYALLOC & al = MYALLOC())
+         CStdStr(MYCITER first, MYCITER last)
-   :    MYBASE(nSize, ch, al) {
+                 :    MYBASE(first, last)
-     }
+         {}
+         CStdStr(MYSIZE nSize, MYVAL ch, const MYALLOC & al = MYALLOC())
+                 :    MYBASE(nSize, ch, al)
+         {}
  #ifdef SS_INC_COMDEF
-     CStdStr(const _bstr_t & bstr)
-     {
+         CStdStr(const _bstr_t & bstr)
-         if (bstr.length() > 0)
+         {
-             this->append(static_cast < PCMYSTR > (bstr), bstr.length());
+             if (bstr.length() > 0)
-     }
+                 this->append(static_cast < PCMYSTR > (bstr), bstr.length());
+         }
  #endif
-     // CStdStr inline assignment operators -- the ssasn function now takes care
+         // CStdStr inline assignment operators -- the ssasn function now takes care
-     // of fixing  the MSVC assignment bug (see knowledge base article Q172398).
+         // of fixing  the MSVC assignment bug (see knowledge base article Q172398).
-     MYTYPE & operator=(const MYTYPE & str)
+         MYTYPE & operator=(const MYTYPE & str)
-     {
+         {
-         ssasn(*this, str);
+             ssasn(*this, str);
-         return *this;
+             return *this;
-     }
+         }
-     MYTYPE & operator=(const std::string & str) {
+         MYTYPE & operator=(const std::string & str)
-         ssasn(*this, str);
+         {
-         return *this;
+             ssasn(*this, str);
-     }
+             return *this;
+         }
-     MYTYPE & operator=(const std::wstring & str) {
+         MYTYPE & operator=(const std::wstring & str)
-         ssasn(*this, str);
+         {
-         return *this;
+             ssasn(*this, str);
-     }
+             return *this;
+         }
-     MYTYPE & operator=(PCSTR pA) {
+         MYTYPE & operator=(PCSTR pA)
-         ssasn(*this, pA);
+         {
-         return *this;
+             ssasn(*this, pA);
-     }
+             return *this;
+         }
-     MYTYPE & operator=(PCWSTR pW) {
+         MYTYPE & operator=(PCWSTR pW)
-         ssasn(*this, pW);
+         {
-         return *this;
+             ssasn(*this, pW);
-     }
+             return *this;
+         }
  #ifdef SS_UNSIGNED
-     MYTYPE & operator=(PCUSTR pU) {
+         MYTYPE & operator=(PCUSTR pU)
-         ssasn(*this, reinterpret_cast < PCSTR > (pU));
+         {
-         return *this;
+             ssasn(*this, reinterpret_cast < PCSTR > (pU));
-     }
+             return *this;
+         }
  #endif
-     MYTYPE & operator=(CT t) {
+         MYTYPE & operator=(CT t)
-         Q172398(*this);
+         {
-         this->assign(1, t);
+             Q172398(*this);
-         return *this;
+             this->assign(1, t);
-     }
- #ifdef SS_INC_COMDEF
-     MYTYPE & operator=(const _bstr_t & bstr) {
-         if (bstr.length() > 0) {
-             this->assign(static_cast < PCMYSTR > (bstr), bstr.length());
              return *this;
          }
-         else {
-             this->erase();
+ #ifdef SS_INC_COMDEF
-             return *this;
+         MYTYPE & operator=(const _bstr_t & bstr)
+         {
+             if (bstr.length() > 0) {
+                 this->assign(static_cast < PCMYSTR > (bstr), bstr.length());
+                 return *this;
+             } else {
+                 this->erase();
+                 return *this;
+             }
          }
-     }
  #endif
-     // Overloads  also needed to fix the MSVC assignment bug (KB: Q172398)
+         // Overloads  also needed to fix the MSVC assignment bug (KB: Q172398)
-     //  *** Thanks to Pete The Plumber for catching this one ***
+         //  *** Thanks to Pete The Plumber for catching this one ***
-     // They also are compiled if you have explicitly turned off refcounting
+         // They also are compiled if you have explicitly turned off refcounting
  #if ( defined(_MSC_VER) && ( _MSC_VER < 1200 ) ) || defined(SS_NO_REFCOUNT)
-     MYTYPE & assign(const MYTYPE & str) {
+         MYTYPE & assign(const MYTYPE & str)
-         Q172398(*this);
+         {
-         sscpy(GetBuffer(str.size() + 1), SSREF(str));
+             Q172398(*this);
-         this->ReleaseBuffer(str.size());
+             sscpy(GetBuffer(str.size() + 1), SSREF(str));
-         return *this;
+             this->ReleaseBuffer(str.size());
-     }
+             return *this;
+         }
-     MYTYPE & assign(const MYTYPE & str, MYSIZE nStart, MYSIZE nChars) {
-         // This overload of basic_string::assign is supposed to assign up to
-         // <nChars> or the NULL terminator, whichever comes first.  Since we
-         // are about to call a less forgiving overload (in which <nChars>
-         // must be a valid length), we must adjust the length here to a safe
-         // value.  Thanks to Ullrich Poll�hne for catching this bug
-         nChars = SSMIN(nChars, str.length() - nStart);
-         MYTYPE strTemp(str.c_str() + nStart, nChars);
-         Q172398(*this);
-         this->assign(strTemp);
-         return *this;
-     }
-     MYTYPE & assign(const MYBASE & str) {
-         ssasn(*this, str);
-         return *this;
-     }
-     MYTYPE & assign(const MYBASE & str, MYSIZE nStart, MYSIZE nChars) {
-         // This overload of basic_string::assign is supposed to assign up to
-         // <nChars> or the NULL terminator, whichever comes first.  Since we
-         // are about to call a less forgiving overload (in which <nChars>
-         // must be a valid length), we must adjust the length here to a safe
-         // value. Thanks to Ullrich Poll�hne for catching this bug
-         nChars = SSMIN(nChars, str.length() - nStart);
-         // Watch out for assignment to self
+         MYTYPE & assign(const MYTYPE & str, MYSIZE nStart, MYSIZE nChars)
+         {
+             // This overload of basic_string::assign is supposed to assign up to
+             // <nChars> or the NULL terminator, whichever comes first.  Since we
+             // are about to call a less forgiving overload (in which <nChars>
+             // must be a valid length), we must adjust the length here to a safe
+             // value.  Thanks to Ullrich Poll�hne for catching this bug
-         if (this == &str) {
+             nChars = SSMIN(nChars, str.length() - nStart);
              MYTYPE strTemp(str.c_str() + nStart, nChars);
-             static_cast < MYBASE * >(this)->assign(strTemp);
-         }
-         else {
              Q172398(*this);
-             static_cast < MYBASE * >(this)->assign(str.c_str() + nStart,
+             this->assign(strTemp);
-                                                    nChars);
+             return *this;
          }
-         return *this;
-     }
-     MYTYPE & assign(const CT * pC, MYSIZE nChars) {
+         MYTYPE & assign(const MYBASE & str)
-         // Q172398 only fix -- erase before assigning, but not if we're
+         {
-         // assigning from our own buffer
+             ssasn(*this, str);
+             return *this;
+         }
- #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )
+         MYTYPE & assign(const MYBASE & str, MYSIZE nStart, MYSIZE nChars)
-         if (!this->empty() &&
+         {
-             (pC < this->data() || pC > this->data() + this->capacity())) {
+             // This overload of basic_string::assign is supposed to assign up to
-             this->erase();
+             // <nChars> or the NULL terminator, whichever comes first.  Since we
+             // are about to call a less forgiving overload (in which <nChars>
+             // must be a valid length), we must adjust the length here to a safe
+             // value. Thanks to Ullrich Poll�hne for catching this bug
+             nChars = SSMIN(nChars, str.length() - nStart);
+             // Watch out for assignment to self
+             if (this == &str) {
+                 MYTYPE strTemp(str.c_str() + nStart, nChars);
+                 static_cast < MYBASE * >(this)->assign(strTemp);
+             } else {
+                 Q172398(*this);
+                 static_cast < MYBASE * >(this)->assign(str.c_str() + nStart,
+                                                        nChars);
+             }
+             return *this;
          }
+         MYTYPE & assign(const CT * pC, MYSIZE nChars)
+         {
+             // Q172398 only fix -- erase before assigning, but not if we're
+             // assigning from our own buffer
+ #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )
+             if (!this->empty() &&
+                     (pC < this->data() || pC > this->data() + this->capacity())) {
+                 this->erase();
+             }
  #endif
-         Q172398(*this);
+             Q172398(*this);
-         static_cast < MYBASE * >(this)->assign(pC, nChars);
+             static_cast < MYBASE * >(this)->assign(pC, nChars);
-         return *this;
+             return *this;
-     }
+         }
-     MYTYPE & assign(MYSIZE nChars, MYVAL val) {
+         MYTYPE & assign(MYSIZE nChars, MYVAL val)
-         Q172398(*this);
+         {
-         static_cast < MYBASE * >(this)->assign(nChars, val);
+             Q172398(*this);
-         return *this;
+             static_cast < MYBASE * >(this)->assign(nChars, val);
-     }
+             return *this;
+         }
-     MYTYPE & assign(const CT * pT) {
+         MYTYPE & assign(const CT * pT)
-         return this->assign(pT, MYBASE::traits_type::length(pT));
+         {
-     }
+             return this->assign(pT, MYBASE::traits_type::length(pT));
+         }
-     MYTYPE & assign(MYCITER iterFirst, MYCITER iterLast) {
+         MYTYPE & assign(MYCITER iterFirst, MYCITER iterLast)
+         {
  #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 )
-         // Q172398 fix.  don't call erase() if we're assigning from ourself
+             // Q172398 fix.  don't call erase() if we're assigning from ourself
-         if (iterFirst < this->begin() ||
+             if (iterFirst < this->begin() ||
-             iterFirst > this->begin() + this->size()) {
+                     iterFirst > this->begin() + this->size()) {
-             this->erase()
+                 this->erase()
-         }
+             }
  #endif
-         this->replace(this->begin(), this->end(), iterFirst, iterLast);
+             this->replace(this->begin(), this->end(), iterFirst, iterLast);
-         return *this;
+             return *this;
-     }
+         }
  #endif
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // CStdStr inline concatenation.
+         // CStdStr inline concatenation.
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     MYTYPE & operator+=(const MYTYPE & str) {
+         MYTYPE & operator+=(const MYTYPE & str)
-         ssadd(*this, str);
+         {
-         return *this;
+             ssadd(*this, str);
-     }
+             return *this;
+         }
-     MYTYPE & operator+=(const std::string & str) {
+         MYTYPE & operator+=(const std::string & str)
-         ssadd(*this, str);
+         {
-         return *this;
+             ssadd(*this, str);
-     }
+             return *this;
+         }
-     MYTYPE & operator+=(const std::wstring & str) {
+         MYTYPE & operator+=(const std::wstring & str)
-         ssadd(*this, str);
+         {
-         return *this;
+             ssadd(*this, str);
-     }
+             return *this;
+         }
-     MYTYPE & operator+=(PCSTR pA) {
+         MYTYPE & operator+=(PCSTR pA)
-         ssadd(*this, pA);
+         {
-         return *this;
+             ssadd(*this, pA);
-     }
+             return *this;
+         }
-     MYTYPE & operator+=(PCWSTR pW) {
+         MYTYPE & operator+=(PCWSTR pW)
-         ssadd(*this, pW);
+         {
-         return *this;
+             ssadd(*this, pW);
-     }
+             return *this;
+         }
-     MYTYPE & operator+=(CT t) {
+         MYTYPE & operator+=(CT t)
-         this->append(1, t);
+         {
-         return *this;
+             this->append(1, t);
-     }
+             return *this;
+         }
  #ifdef SS_INC_COMDEF            // if we have _bstr_t, define a += for it too.
-     MYTYPE & operator+=(const _bstr_t & bstr) {
+         MYTYPE & operator+=(const _bstr_t & bstr)
-         return this->operator+=(static_cast < PCMYSTR > (bstr));
+         {
-     }
+             return this->operator+=(static_cast < PCMYSTR > (bstr));
+         }
  #endif
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // Case changing functions
+         // Case changing functions
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     MYTYPE & ToUpper(const std::locale & loc = std::locale()) {
-         // Note -- if there are any MBCS character sets in which the lowercase
-         // form a character takes up a different number of bytes than the
-         // uppercase form, this would probably not work...
-         std::transform(this->begin(),
-                        this->end(),
-                        this->begin(), std::bind2nd(SSToUpper < CT > (), loc));
-         // ...but if it were, this would probably work better.  Also, this way
-         // seems to be a bit faster when anything other then the "C" locale is
-         // used...
- //              if ( !empty() )
- //              {
- //                      ssupr(this->GetBuf(), this->size(), loc);
- //                      this->RelBuf();
- //              }
-         return *this;
+         MYTYPE & ToUpper(const std::locale & loc = std::locale())
-     }
+         {
+             // Note -- if there are any MBCS character sets in which the lowercase
+             // form a character takes up a different number of bytes than the
+             // uppercase form, this would probably not work...
+             std::transform(this->begin(),
+                            this->end(),
+                            this->begin(), std::bind2nd(SSToUpper < CT > (), loc));
+             // ...but if it were, this would probably work better.  Also, this way
+             // seems to be a bit faster when anything other then the "C" locale is
+             // used...
+             //              if ( !empty() )
+             //              {
+             //                      ssupr(this->GetBuf(), this->size(), loc);
+             //                      this->RelBuf();
+             //              }
-     MYTYPE & ToLower(const std::locale & loc = std::locale()) {
+             return *this;
-         // Note -- if there are any MBCS character sets in which the lowercase
+         }
-         // form a character takes up a different number of bytes than the
-         // uppercase form, this would probably not work...
-         std::transform(this->begin(),
-                        this->end(),
-                        this->begin(), std::bind2nd(SSToLower < CT > (), loc));
-         // ...but if it were, this would probably work better.  Also, this way
-         // seems to be a bit faster when anything other then the "C" locale is
-         // used...
- //              if ( !empty() )
- //              {
- //                      sslwr(this->GetBuf(), this->size(), loc);
- //                      this->RelBuf();
- //              }
-         return *this;
-     }
+         MYTYPE & ToLower(const std::locale & loc = std::locale())
+         {
+             // Note -- if there are any MBCS character sets in which the lowercase
+             // form a character takes up a different number of bytes than the
+             // uppercase form, this would probably not work...
+             std::transform(this->begin(),
+                            this->end(),
+                            this->begin(), std::bind2nd(SSToLower < CT > (), loc));
+             // ...but if it were, this would probably work better.  Also, this way
+             // seems to be a bit faster when anything other then the "C" locale is
+             // used...
+             //              if ( !empty() )
+             //              {
+             //                      sslwr(this->GetBuf(), this->size(), loc);
+             //                      this->RelBuf();
+             //              }
+             return *this;
+         }
-     MYTYPE & Normalize() {
-         return Trim().ToLower();
-     }
+         MYTYPE & Normalize()
+         {
+             return Trim().ToLower();
+         }
-     // -------------------------------------------------------------------------
-     // CStdStr -- Direct access to character buffer.  In the MS' implementation,
-     // the at() function that we use here also calls _Freeze() providing us some
-     // protection from multithreading problems associated with ref-counting.
-     // In VC 7 and later, of course, the ref-counting stuff is gone.
-     // -------------------------------------------------------------------------
-     CT *GetBuf(int nMinLen = -1) {
-         if (static_cast < int >(this->size()) < nMinLen)
-             this->resize(static_cast < MYSIZE > (nMinLen));
-         return this->empty()? const_cast <
+         // -------------------------------------------------------------------------
-             CT * >(this->data()) : &(this->at(0));
+         // CStdStr -- Direct access to character buffer.  In the MS' implementation,
-     }
+         // the at() function that we use here also calls _Freeze() providing us some
+         // protection from multithreading problems associated with ref-counting.
+         // In VC 7 and later, of course, the ref-counting stuff is gone.
+         // -------------------------------------------------------------------------
-     CT *SetBuf(int nLen)
+         CT *GetBuf(int nMinLen = -1)
-     {
+         {
-         nLen = (nLen > 0 ? nLen : 0);
+             if (static_cast < int >(this->size())
-         if (this->capacity() < 1 && nLen == 0)
+                     < nMinLen)
-             this->resize(1);
+                 this->resize(static_cast < MYSIZE > (nMinLen));
-         this->resize(static_cast < MYSIZE > (nLen));
+             return this->empty()? const_cast <
-         return const_cast < CT * >(this->data());
+                    CT * >(this->data()) : &(this->at(0));
-     }
+         }
-     void RelBuf(int nNewLen = -1) {
-         this->resize(static_cast < MYSIZE > (nNewLen > -1 ? nNewLen :
-                                              sslen(this->c_str())));
-     }
-     void BufferRel()
+         CT *SetBuf(int nLen)
-     {
+         {
-         RelBuf();
+             nLen = (nLen > 0 ? nLen : 0);
-     }                           // backwards compatability
+             if (this->capacity() < 1 && nLen == 0)
-     CT *Buffer()
+                 this->resize(1);
-     {
-         return GetBuf();
-     }                           // backwards compatability
-     CT *BufferSet(int nLen)
-     {
-         return SetBuf(nLen);
-     }                           // backwards compatability
-     bool Equals(const CT * pT, bool bUseCase = false) const
+             this->resize(static_cast < MYSIZE > (nLen));
-     {
+             return const_cast < CT * >(this->data());
-         return 0 ==
+         }
-             (bUseCase ? this->compare(pT) : ssicmp(this->c_str(), pT));
+         void RelBuf(int nNewLen = -1)
-     }
+         {
+             this->resize(static_cast < MYSIZE > (nNewLen > -1 ? nNewLen :
+                                                  sslen(this->c_str())));
+         }
-     // -------------------------------------------------------------------------
+         void BufferRel()
-     // FUNCTION:  CStdStr::Load
+         {
-     // REMARKS:
+             RelBuf();
-     //              Loads string from resource specified by nID
+         }                           // backwards compatability
-     //
+         CT *Buffer()
-     // PARAMETERS:
+         {
-     //              nID - resource Identifier.  Purely a Win32 thing in this case
+             return GetBuf();
-     //
+         }                           // backwards compatability
-     // RETURN VALUE:
+         CT *BufferSet(int nLen)
-     //              true if successful, false otherwise
+         {
-     // -------------------------------------------------------------------------
+             return SetBuf(nLen);
+         }                           // backwards compatability
- #ifndef SS_ANSI
+         bool Equals(const CT * pT, bool bUseCase = false) const
+         {
+             return 0 ==
+                    (bUseCase ? this->compare(pT) : ssicmp(this->c_str(), pT));
+         }
-     bool Load(UINT nId, HMODULE hModule = NULL) {
+         // -------------------------------------------------------------------------
-         bool bLoaded = false;   // set to true of we succeed.
+         // FUNCTION:  CStdStr::Load
+         // REMARKS:
+         //              Loads string from resource specified by nID
+         //
+         // PARAMETERS:
+         //              nID - resource Identifier.  Purely a Win32 thing in this case
+         //
+         // RETURN VALUE:
+         //              true if successful, false otherwise
+         // -------------------------------------------------------------------------
- #ifdef _MFC_VER                 // When in Rome (or MFC land)...
+ #ifndef SS_ANSI
-         // If they gave a resource handle, use it.  Note - this is archaic
+         bool Load(UINT nId, HMODULE hModule = NULL)
-         // and not really what I would recommend.  But then again, in MFC
+         {
-         // land, you ought to be using CString for resources anyway since
+             bool bLoaded = false;   // set to true of we succeed.
-         // it walks the resource chain for you.
-         HMODULE hModuleOld = NULL;
+ #ifdef _MFC_VER                 // When in Rome (or MFC land)...
-         if (NULL != hModule) {
+             // If they gave a resource handle, use it.  Note - this is archaic
-             hModuleOld = AfxGetResourceHandle();
+             // and not really what I would recommend.  But then again, in MFC
-             AfxSetResourceHandle(hModule);
+             // land, you ought to be using CString for resources anyway since
-         }
+             // it walks the resource chain for you.
+             HMODULE hModuleOld = NULL;
+             if (NULL != hModule) {
+                 hModuleOld = AfxGetResourceHandle();
+                 AfxSetResourceHandle(hModule);
+             }
-         // ...load the string
+             // ...load the string
-         CString strRes;
+             CString strRes;
-         bLoaded = FALSE != strRes.LoadString(nId);
+             bLoaded = FALSE != strRes.LoadString(nId);
-         // ...and if we set the resource handle, restore it.
+             // ...and if we set the resource handle, restore it.
-         if (NULL != hModuleOld)
+             if (NULL != hModuleOld)
-             AfxSetResourceHandle(hModule);
+                 AfxSetResourceHandle(hModule);
-         if (bLoaded)
+             if (bLoaded)
-             *this = strRes;
+                 *this = strRes;
  #else // otherwise make our own hackneyed version of CString's Load
-         // Get the resource name and module handle
+             // Get the resource name and module handle
-         if (NULL == hModule)
+             if (NULL == hModule)
-             hModule = GetResourceHandle();
+                 hModule = GetResourceHandle();
-         PCTSTR szName = MAKEINTRESOURCE((nId >> 4) + 1);        // lifted
+             PCTSTR szName = MAKEINTRESOURCE((nId >> 4) + 1);        // lifted
-         DWORD dwSize = 0;
+             DWORD dwSize = 0;
-         // No sense continuing if we can't find the resource
+             // No sense continuing if we can't find the resource
-         HRSRC hrsrc =::FindResource(hModule, szName, RT_STRING);
+             HRSRC hrsrc =::FindResource(hModule, szName, RT_STRING);
-         if (NULL == hrsrc) {
+             if (NULL == hrsrc) {
-             TRACE(_T("Cannot find resource %d: 0x%X"), nId,::GetLastError());
+                 TRACE(_T("Cannot find resource %d: 0x%X"), nId,::GetLastError());
-         }
+             } else if (0 == (dwSize =::SizeofResource(hModule, hrsrc) / sizeof(CT))) {
-         else if (0 == (dwSize =::SizeofResource(hModule, hrsrc) / sizeof(CT))) {
+                 TRACE(_T("Cant get size of resource %d 0x%X\n"), nId,
-             TRACE(_T("Cant get size of resource %d 0x%X\n"), nId,
+                       GetLastError());
-                   GetLastError());
+             } else {
-         }
+                 bLoaded = 0 != ssload(hModule, nId, GetBuf(dwSize), dwSize);
-         else {
+                 ReleaseBuffer();
-             bLoaded = 0 != ssload(hModule, nId, GetBuf(dwSize), dwSize);
+             }
-             ReleaseBuffer();
-         }
  #endif // #ifdef _MFC_VER
-         if (!bLoaded)
+             if (!bLoaded)
-             TRACE(_T("String not loaded 0x%X\n"),::GetLastError());
+                 TRACE(_T("String not loaded 0x%X\n"),::GetLastError());
-         return bLoaded;
+             return bLoaded;
-     }
+         }
  #endif // #ifdef SS_ANSI
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // FUNCTION:  CStdStr::Format
+         // FUNCTION:  CStdStr::Format
-     //              void _cdecl Formst(CStdStringA& PCSTR szFormat, ...)
+         //              void _cdecl Formst(CStdStringA& PCSTR szFormat, ...)
-     //              void _cdecl Format(PCSTR szFormat);
+         //              void _cdecl Format(PCSTR szFormat);
-     //
+         //
-     // DESCRIPTION:
+         // DESCRIPTION:
-     //              This function does sprintf/wsprintf style formatting on CStdStringA
+         //              This function does sprintf/wsprintf style formatting on CStdStringA
-     //              objects.  It looks a lot like MFC's CString::Format.  Some people
+         //              objects.  It looks a lot like MFC's CString::Format.  Some people
-     //              might even call this identical.  Fortunately, these people are now
+         //              might even call this identical.  Fortunately, these people are now
-     //              dead... heh heh.
+         //              dead... heh heh.
-     //
+         //
-     // PARAMETERS:
+         // PARAMETERS:
-     //              nId - ID of string resource holding the format string
+         //              nId - ID of string resource holding the format string
-     //              szFormat - a PCSTR holding the format specifiers
+         //              szFormat - a PCSTR holding the format specifiers
-     //              argList - a va_list holding the arguments for the format specifiers.
+         //              argList - a va_list holding the arguments for the format specifiers.
-     //
+         //
-     // RETURN VALUE:  None.
+         // RETURN VALUE:  None.
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // formatting (using wsprintf style formatting)
+         // formatting (using wsprintf style formatting)
-     // If they want a Format() function that safely handles string objects
+         // If they want a Format() function that safely handles string objects
-     // without casting
+         // without casting
  #ifdef SS_SAFE_FORMAT
-     // Question:  Joe, you wacky coder you, why do you have so many overloads
+         // Question:  Joe, you wacky coder you, why do you have so many overloads
-     //      of the Format() function
+         //      of the Format() function
-     // Answer:  One reason only - CString compatability.  In short, by making
+         // Answer:  One reason only - CString compatability.  In short, by making
-     //      the Format() function a template this way, I can do strong typing
+         //      the Format() function a template this way, I can do strong typing
-     //      and allow people to pass CStdString arguments as fillers for
+         //      and allow people to pass CStdString arguments as fillers for
-     //      "%s" format specifiers without crashing their program!  The downside
+         //      "%s" format specifiers without crashing their program!  The downside
-     //      is that I need to overload on the number of arguments.   If you are
+         //      is that I need to overload on the number of arguments.   If you are
-     //      passing more arguments than I have listed below in any of my
+         //      passing more arguments than I have listed below in any of my
-     //      overloads, just add another one.
+         //      overloads, just add another one.
-     //
+         //
-     //      Yes, yes, this is really ugly.  In essence what I am doing here is
+         //      Yes, yes, this is really ugly.  In essence what I am doing here is
-     //      protecting people from a bad (and incorrect) programming practice
+         //      protecting people from a bad (and incorrect) programming practice
-     //      that they should not be doing anyway.  I am protecting them from
+         //      that they should not be doing anyway.  I am protecting them from
-     //      themselves.  Why am I doing this?  Well, if you had any idea the
+         //      themselves.  Why am I doing this?  Well, if you had any idea the
-     //      number of times I've been emailed by people about this
+         //      number of times I've been emailed by people about this
-     //      "incompatability" in my code, you wouldn't ask.
+         //      "incompatability" in my code, you wouldn't ask.
-     void Fmt(const CT * szFmt, ...)
+         void Fmt(const CT * szFmt, ...)
-     {
+         {
-         va_list argList;
+             va_list argList;
-         va_start(argList, szFmt);
+             va_start(argList, szFmt);
-         FormatV(szFmt, argList);
+             FormatV(szFmt, argList);
-         va_end(argList);
+             va_end(argList);
-     }
+         }
  #ifndef SS_ANSI
-     void Format(UINT nId)
+         void Format(UINT nId)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId))
+             if (strFmt.Load(nId))
-             this->swap(strFmt);
+                 this->swap(strFmt);
-     }
+         }
-     template < class A1 > void Format(UINT nId, const A1 & v)
+         template < class A1 >
-     {
+         void Format(UINT nId, const A1 & v)
-         MYTYPE strFmt;
+         {
-         if (strFmt.Load(nId))
+             MYTYPE strFmt;
-             Fmt(strFmt, FmtArg < A1 > (v) ());
+             if (strFmt.Load(nId))
-     }
+                 Fmt(strFmt, FmtArg < A1 > (v) ());
-     template < class A1, class A2 >
+         }
+         template < class A1, class A2 >
          void Format(UINT nId, const A1 & v1, const A2 & v2)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId))
+             if (strFmt.Load(nId))
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) ());
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) ());
-     }
+         }
-     template < class A1, class A2, class A3 >
+         template < class A1, class A2, class A3 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) ());
+                     FmtArg < A3 > (v3) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4 >
-     template < class A1, class A2, class A3, class A4 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) ());
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5 >
-     template < class A1, class A2, class A3, class A4, class A5 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) ());
+                     FmtArg < A5 > (v5) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6 >
-     template < class A1, class A2, class A3, class A4, class A5, class A6 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) ());
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6,
                      const A7 & v7)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) ());
+                     FmtArg < A7 > (v7) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6,
                      const A7 & v7, const A8 & v8)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) ());
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6,
                      const A7 & v7, const A8 & v8, const A9 & v9)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) ());
+                     FmtArg < A9 > (v9) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6,
                      const A7 & v7, const A8 & v8, const A9 & v9,
                      const A10 & v10)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) ());
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6,
                      const A7 & v7, const A8 & v8, const A9 & v9,
                      const A10 & v10, const A11 & v11)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) ());
+                     FmtArg < A11 > (v11) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
                      const A4 & v4, const A5 & v5, const A6 & v6,
                      const A7 & v7, const A8 & v8, const A9 & v9,
                      const A10 & v10, const A11 & v11, const A12 & v12)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) ());
+                     FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
-Line 2738 
 template < typename CT > class CStdStr:p
+Line 2796 
 template < typename CT > class CStdStr:p
                      const A7 & v7, const A8 & v8, const A9 & v9,
                      const A10 & v10, const A11 & v11, const A12 & v12,
                      const A13 & v13)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                     FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-                 FmtArg < A13 > (v13) ());
+                     FmtArg < A13 > (v13) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
-Line 2758 
 template < typename CT > class CStdStr:p
+Line 2816 
 template < typename CT > class CStdStr:p
                      const A7 & v7, const A8 & v8, const A9 & v9,
                      const A10 & v10, const A11 & v11, const A12 & v12,
                      const A13 & v13, const A14 & v14)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                     FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) ());
+                     FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14, class A15 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
-Line 2778 
 template < typename CT > class CStdStr:p
+Line 2836 
 template < typename CT > class CStdStr:p
                      const A7 & v7, const A8 & v8, const A9 & v9,
                      const A10 & v10, const A11 & v11, const A12 & v12,
                      const A13 & v13, const A14 & v14, const A15 & v15)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                     FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
+                     FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
-                 FmtArg < A15 > (v15) ());
+                     FmtArg < A15 > (v15) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14, class A15, class A16 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
-Line 2800 
 template < typename CT > class CStdStr:p
+Line 2858 
 template < typename CT > class CStdStr:p
                      const A10 & v10, const A11 & v11, const A12 & v12,
                      const A13 & v13, const A14 & v14, const A15 & v15,
                      const A16 & v16)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                     FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
+                     FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
-                 FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) ());
+                     FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) ());
+             }
          }
-     }
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14, class A15, class A16, class A17 >
          void Format(UINT nId, const A1 & v1, const A2 & v2, const A3 & v3,
-Line 2822 
 template < typename CT > class CStdStr:p
+Line 2880 
 template < typename CT > class CStdStr:p
                      const A10 & v10, const A11 & v11, const A12 & v12,
                      const A13 & v13, const A14 & v14, const A15 & v15,
                      const A16 & v16, const A17 & v17)
-     {
+         {
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId)) {
+             if (strFmt.Load(nId)) {
-             Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+                 Fmt(strFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                     FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                     FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                     FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                     FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                     FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
+                     FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
-                 FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) (),
+                     FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) (),
-                 FmtArg < A17 > (v17) ());
+                     FmtArg < A17 > (v17) ());
+             }
          }
-     }
  #endif // #ifndef SS_ANSI
-     // ...now the other overload of Format: the one that takes a string literal
+         // ...now the other overload of Format: the one that takes a string literal
-     void Format(const CT * szFmt)
+         void Format(const CT * szFmt)
-     {
+         {
-         *this = szFmt;
+             *this = szFmt;
-     }
+         }
-     template < class A1 > void Format(const CT * szFmt, const A1 & v)
+         template < class A1 >
-     {
+         void Format(const CT * szFmt, const A1 & v)
-         Fmt(szFmt, FmtArg < A1 > (v) ());
+         {
-     }
+             Fmt(szFmt, FmtArg < A1 > (v) ());
-     template < class A1, class A2 >
+         }
+         template < class A1, class A2 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) ());
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) ());
-     }
+         }
-     template < class A1, class A2, class A3 >
+         template < class A1, class A2, class A3 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) ());
+                 FmtArg < A3 > (v3) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4 >
+         template < class A1, class A2, class A3, class A4 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) ());
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5 >
+         template < class A1, class A2, class A3, class A4, class A5 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) ());
+                 FmtArg < A5 > (v5) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6 >
+         template < class A1, class A2, class A3, class A4, class A5, class A6 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) ());
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6, const A7 & v7)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) ());
+                 FmtArg < A7 > (v7) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6, const A7 & v7, const A8 & v8)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) ());
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6, const A7 & v7, const A8 & v8,
                      const A9 & v9)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) ());
+                 FmtArg < A9 > (v9) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6, const A7 & v7, const A8 & v8,
                      const A9 & v9, const A10 & v10)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) ());
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6, const A7 & v7, const A8 & v8,
                      const A9 & v9, const A10 & v10, const A11 & v11)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) ());
+                 FmtArg < A11 > (v11) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
                      const A3 & v3, const A4 & v4, const A5 & v5,
                      const A6 & v6, const A7 & v7, const A8 & v8,
                      const A9 & v9, const A10 & v10, const A11 & v11,
                      const A12 & v12)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) ());
+                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
-Line 2970 
 template < typename CT > class CStdStr:p
+Line 3029 
 template < typename CT > class CStdStr:p
                      const A6 & v6, const A7 & v7, const A8 & v8,
                      const A9 & v9, const A10 & v10, const A11 & v11,
                      const A12 & v12, const A13 & v13)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-             FmtArg < A13 > (v13) ());
+                 FmtArg < A13 > (v13) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
-Line 2987 
 template < typename CT > class CStdStr:p
+Line 3046 
 template < typename CT > class CStdStr:p
                      const A6 & v6, const A7 & v7, const A8 & v8,
                      const A9 & v9, const A10 & v10, const A11 & v11,
                      const A12 & v12, const A13 & v13, const A14 & v14)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-             FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) ());
+                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14, class A15 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
-Line 3005 
 template < typename CT > class CStdStr:p
+Line 3064 
 template < typename CT > class CStdStr:p
                      const A9 & v9, const A10 & v10, const A11 & v11,
                      const A12 & v12, const A13 & v13, const A14 & v14,
                      const A15 & v15)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-             FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
+                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
-             FmtArg < A15 > (v15) ());
+                 FmtArg < A15 > (v15) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14, class A15, class A16 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
-Line 3024 
 template < typename CT > class CStdStr:p
+Line 3083 
 template < typename CT > class CStdStr:p
                      const A9 & v9, const A10 & v10, const A11 & v11,
                      const A12 & v12, const A13 & v13, const A14 & v14,
                      const A15 & v15, const A16 & v16)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-             FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
+                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
-             FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) ());
+                 FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) ());
-     }
+         }
-     template < class A1, class A2, class A3, class A4, class A5, class A6,
+         template < class A1, class A2, class A3, class A4, class A5, class A6,
          class A7, class A8, class A9, class A10, class A11, class A12,
          class A13, class A14, class A15, class A16, class A17 >
          void Format(const CT * szFmt, const A1 & v1, const A2 & v2,
-Line 3043 
 template < typename CT > class CStdStr:p
+Line 3102 
 template < typename CT > class CStdStr:p
                      const A9 & v9, const A10 & v10, const A11 & v11,
                      const A12 & v12, const A13 & v13, const A14 & v14,
                      const A15 & v15, const A16 & v16, const A17 & v17)
-     {
+         {
-         Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
+             Fmt(szFmt, FmtArg < A1 > (v1) (), FmtArg < A2 > (v2) (),
-             FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
+                 FmtArg < A3 > (v3) (), FmtArg < A4 > (v4) (),
-             FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
+                 FmtArg < A5 > (v5) (), FmtArg < A6 > (v6) (),
-             FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
+                 FmtArg < A7 > (v7) (), FmtArg < A8 > (v8) (),
-             FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
+                 FmtArg < A9 > (v9) (), FmtArg < A10 > (v10) (),
-             FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
+                 FmtArg < A11 > (v11) (), FmtArg < A12 > (v12) (),
-             FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
+                 FmtArg < A13 > (v13) (), FmtArg < A14 > (v14) (),
-             FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) (),
+                 FmtArg < A15 > (v15) (), FmtArg < A16 > (v16) (),
-             FmtArg < A17 > (v17) ());
+                 FmtArg < A17 > (v17) ());
-     }
+         }
  #else // #ifdef SS_SAFE_FORMAT
  #ifndef SS_ANSI
-     void Format(UINT nId, ...)
+         void Format(UINT nId, ...)
-     {
+         {
-         va_list argList;
+             va_list argList;
-         va_start(argList, nId);
+             va_start(argList, nId);
-         MYTYPE strFmt;
+             MYTYPE strFmt;
-         if (strFmt.Load(nId))
+             if (strFmt.Load(nId))
-             FormatV(strFmt, argList);
+                 FormatV(strFmt, argList);
-         va_end(argList);
+             va_end(argList);
-     }
+         }
  #endif // #ifdef SS_ANSI
-     void Format(const CT * szFmt, ...)
+         void Format(const CT * szFmt, ...)
-     {
+         {
-         va_list argList;
+             va_list argList;
-         va_start(argList, szFmt);
+             va_start(argList, szFmt);
-         FormatV(szFmt, argList);
+             FormatV(szFmt, argList);
-         va_end(argList);
+             va_end(argList);
-     }
+         }
  #endif // #ifdef SS_SAFE_FORMAT
-     void AppendFormat(const CT * szFmt, ...)
+         void AppendFormat(const CT * szFmt, ...)
-     {
+         {
-         va_list argList;
+             va_list argList;
-         va_start(argList, szFmt);
+             va_start(argList, szFmt);
-         AppendFormatV(szFmt, argList);
+             AppendFormatV(szFmt, argList);
-         va_end(argList);
+             va_end(argList);
-     }
+         }
  #define MAX_FMT_TRIES           5       // #of times we try
  #define FMT_BLOCK_SIZE          2048    // # of bytes to increment per try
-Line 3098 
 template < typename CT > class CStdStr:p
+Line 3157 
 template < typename CT > class CStdStr:p
  #define BUFSIZE_2ND 512
  #define STD_BUF_SIZE            1024
-     // an efficient way to add formatted characters to the string.  You may only
+         // an efficient way to add formatted characters to the string.  You may only
-     // add up to STD_BUF_SIZE characters at a time, though
+         // add up to STD_BUF_SIZE characters at a time, though
-     void AppendFormatV(const CT * szFmt, va_list argList)
+         void AppendFormatV(const CT * szFmt, va_list argList)
-     {
+         {
-         CT szBuf[STD_BUF_SIZE];
+             CT szBuf[STD_BUF_SIZE];
  #ifdef SS_ANSI
-         int nLen = ssvsprintf(szBuf, STD_BUF_SIZE - 1, szFmt, argList);
+             int nLen = ssvsprintf(szBuf, STD_BUF_SIZE - 1, szFmt, argList);
  #else
-         int nLen = ssnprintf(szBuf, STD_BUF_SIZE - 1, szFmt, argList);
+             int nLen = ssnprintf(szBuf, STD_BUF_SIZE - 1, szFmt, argList);
  #endif
-         if (0 < nLen)
-             this->append(szBuf, nLen);
-     }
-     // -------------------------------------------------------------------------
+             if (0 < nLen)
-     // FUNCTION:  FormatV
+                 this->append(szBuf, nLen);
-     //              void FormatV(PCSTR szFormat, va_list, argList);
+         }
-     //
-     // DESCRIPTION:
-     //              This function formats the string with sprintf style format-specs.
-     //              It makes a general guess at required buffer size and then tries
-     //              successively larger buffers until it finds one big enough or a
-     //              threshold (MAX_FMT_TRIES) is exceeded.
-     //
-     // PARAMETERS:
-     //              szFormat - a PCSTR holding the format of the output
-     //              argList - a Microsoft specific va_list for variable argument lists
-     //
-     // RETURN VALUE:
-     // -------------------------------------------------------------------------
-     void FormatV(const CT * szFormat, va_list argList)
+         // -------------------------------------------------------------------------
-     {
+         // FUNCTION:  FormatV
+         //              void FormatV(PCSTR szFormat, va_list, argList);
+         //
+         // DESCRIPTION:
+         //              This function formats the string with sprintf style format-specs.
+         //              It makes a general guess at required buffer size and then tries
+         //              successively larger buffers until it finds one big enough or a
+         //              threshold (MAX_FMT_TRIES) is exceeded.
+         //
+         // PARAMETERS:
+         //              szFormat - a PCSTR holding the format of the output
+         //              argList - a Microsoft specific va_list for variable argument lists
+         //
+         // RETURN VALUE:
+         // -------------------------------------------------------------------------
+         void FormatV(const CT * szFormat, va_list argList)
+         {
  #ifdef SS_ANSI
-         int nLen = sslen(szFormat) + STD_BUF_SIZE;
+             int nLen = sslen(szFormat) + STD_BUF_SIZE;
-         ssvsprintf(GetBuffer(nLen), nLen - 1, szFormat, argList);
+             ssvsprintf(GetBuffer(nLen), nLen - 1, szFormat, argList);
-         ReleaseBuffer();
+             ReleaseBuffer();
  #else
-         CT *pBuf = NULL;
+             CT *pBuf = NULL;
-         int nChars = 1;
+             int nChars = 1;
-         int nUsed = 0;
+             int nUsed = 0;
-         size_type nActual = 0;
+             size_type nActual = 0;
-         int nTry = 0;
+             int nTry = 0;
-         do {
+             do {
-             // Grow more than linearly (e.g. 512, 1536, 3072, etc)
+                 // Grow more than linearly (e.g. 512, 1536, 3072, etc)
-             nChars += ((nTry + 1) * FMT_BLOCK_SIZE);
+                 nChars += ((nTry + 1) * FMT_BLOCK_SIZE);
-             pBuf = reinterpret_cast < CT * >(_alloca(sizeof(CT) * nChars));
+                 pBuf = reinterpret_cast < CT * >(_alloca(sizeof(CT) * nChars));
-             nUsed = ssnprintf(pBuf, nChars - 1, szFormat, argList);
+                 nUsed = ssnprintf(pBuf, nChars - 1, szFormat, argList);
-             // Ensure proper NULL termination.
+                 // Ensure proper NULL termination.
-             nActual = nUsed == -1 ? nChars - 1 : SSMIN(nUsed, nChars - 1);
+                 nActual = nUsed == -1 ? nChars - 1 : SSMIN(nUsed, nChars - 1);
-             pBuf[nActual] = '\0';
+                 pBuf[nActual] = '\0';
-         } while (nUsed < 0 && nTry++ < MAX_FMT_TRIES);
+             } while (nUsed < 0 && nTry++ < MAX_FMT_TRIES);
-         // assign whatever we managed to format
+             // assign whatever we managed to format
-         this->assign(pBuf, nActual);
+             this->assign(pBuf, nActual);
  #endif
-     }
-     // -------------------------------------------------------------------------
+         }
-     // CString Facade Functions:
-     //
+         // -------------------------------------------------------------------------
-     // The following methods are intended to allow you to use this class as a
+         // CString Facade Functions:
-     // near drop-in replacement for CString.
+         //
-     // -------------------------------------------------------------------------
+         // The following methods are intended to allow you to use this class as a
+         // near drop-in replacement for CString.
+         // -------------------------------------------------------------------------
  #ifdef SS_WIN32
-     BSTR AllocSysString() const
+         BSTR AllocSysString() const
-     {
+         {
-         ostring os;
+             ostring os;
-         ssasn(os, *this);
+             ssasn(os, *this);
-         return::SysAllocString(os.c_str());
+             return::SysAllocString(os.c_str());
-     }
+         }
  #endif
-     int Collate(PCMYSTR szThat) const
+         int Collate(PCMYSTR szThat) const
-     {
+         {
-         return sscoll(this->c_str(), this->length(), szThat, sslen(szThat));
+             return sscoll(this->c_str(), this->length(), szThat, sslen(szThat));
-     }
+         }
-     int CollateNoCase(PCMYSTR szThat) const
+         int CollateNoCase(PCMYSTR szThat) const
-     {
+         {
-         return ssicoll(this->c_str(), this->length(), szThat, sslen(szThat));
+             return ssicoll(this->c_str(), this->length(), szThat, sslen(szThat));
-     }
+         }
-     int Compare(PCMYSTR szThat) const
+         int Compare(PCMYSTR szThat) const
-     {
+         {
-         return this->compare(szThat);
+             return this->compare(szThat);
-     }
+         }
-     int CompareNoCase(PCMYSTR szThat) const
+         int CompareNoCase(PCMYSTR szThat) const
-     {
+         {
-         return ssicmp(this->c_str(), szThat);
+             return ssicmp(this->c_str(), szThat);
-     }
+         }
-     int Delete(int nIdx, int nCount = 1) {
+         int Delete(int nIdx, int nCount = 1)
-         if (nIdx < 0)
+         {
-             nIdx = 0;
+             if (nIdx < 0)
+                 nIdx = 0;
-         if (nIdx < this->GetLength())
-             this->erase(static_cast < MYSIZE > (nIdx),
-                         static_cast < MYSIZE > (nCount));
-         return GetLength();
+             if (nIdx < this->GetLength())
-     }
+                 this->erase(static_cast < MYSIZE > (nIdx),
+                             static_cast < MYSIZE > (nCount));
-     void Empty()
+             return GetLength();
-     {
+         }
-         this->erase();
-     }
-     int Find(CT ch) const
+         void Empty()
-     {
+         {
-         MYSIZE nIdx = this->find_first_of(ch);
+             this->erase();
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+         }
-     }
-     int Find(PCMYSTR szSub) const
+         int Find(CT ch) const
-     {
+         {
-         MYSIZE nIdx = this->find(szSub);
+             MYSIZE nIdx = this->find_first_of(ch);
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
-     }
+         }
-     int Find(CT ch, int nStart) const
+         int Find(PCMYSTR szSub) const
-     {
+         {
-         // CString::Find docs say add 1 to nStart when it's not zero
+             MYSIZE nIdx = this->find(szSub);
-         // CString::Find code doesn't do that however.  We'll stick
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
-         // with what the code does
+         }
-         MYSIZE nIdx =
-             this->find_first_of(ch, static_cast < MYSIZE > (nStart));
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
-     }
-     int Find(PCMYSTR szSub, int nStart) const
+         int Find(CT ch, int nStart) const
-     {
+         {
-         // CString::Find docs say add 1 to nStart when it's not zero
+             // CString::Find docs say add 1 to nStart when it's not zero
-         // CString::Find code doesn't do that however.  We'll stick
+             // CString::Find code doesn't do that however.  We'll stick
-         // with what the code does
+             // with what the code does
-         MYSIZE nIdx = this->find(szSub, static_cast < MYSIZE > (nStart));
+             MYSIZE nIdx =
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+                 this->find_first_of(ch, static_cast < MYSIZE > (nStart));
-     }
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+         }
-     int FindOneOf(PCMYSTR szCharSet) const
+         int Find(PCMYSTR szSub, int nStart) const
-     {
+         {
-         MYSIZE nIdx = this->find_first_of(szCharSet);
+             // CString::Find docs say add 1 to nStart when it's not zero
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+             // CString::Find code doesn't do that however.  We'll stick
-     }
+             // with what the code does
+             MYSIZE nIdx = this->find(szSub, static_cast < MYSIZE > (nStart));
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+         }
+         int FindOneOf(PCMYSTR szCharSet) const
+         {
+             MYSIZE nIdx = this->find_first_of(szCharSet);
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+         }
  #ifndef SS_ANSI
-     void FormatMessage(PCMYSTR szFormat, ...) throw(std::exception)
+         void FormatMessage(PCMYSTR szFormat, ...) throw(std::exception)
-     {
+         {
-         va_list argList;
+             va_list argList;
-         va_start(argList, szFormat);
+             va_start(argList, szFormat);
-         PMYSTR szTemp;
+             PMYSTR szTemp;
-         if (ssfmtmsg
+             if (ssfmtmsg
-             (FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+                     (FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
-              szFormat, 0, 0, reinterpret_cast < PMYSTR > (&szTemp), 0,
+                      szFormat, 0, 0, reinterpret_cast < PMYSTR > (&szTemp), 0,
-              &argList) == 0 || szTemp == 0) {
+                      &argList) == 0 || szTemp == 0) {
-             throw std::runtime_error("out of memory");
+                 throw std::runtime_error("out of memory");
-         }
+             }
-         *this = szTemp;
+             *this = szTemp;
-         LocalFree(szTemp);
+             LocalFree(szTemp);
-         va_end(argList);
+             va_end(argList);
-     }
+         }
-     void FormatMessage(UINT nFormatId, ...) throw(std::exception)
+         void FormatMessage(UINT nFormatId, ...) throw(std::exception)
-     {
+         {
-         MYTYPE sFormat;
+             MYTYPE sFormat;
-         VERIFY(sFormat.LoadString(nFormatId));
+             VERIFY(sFormat.LoadString(nFormatId));
-         va_list argList;
+             va_list argList;
-         va_start(argList, nFormatId);
+             va_start(argList, nFormatId);
-         PMYSTR szTemp;
+             PMYSTR szTemp;
-         if (ssfmtmsg
+             if (ssfmtmsg
-             (FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+                     (FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER,
-              sFormat, 0, 0, reinterpret_cast < PMYSTR > (&szTemp), 0,
+                      sFormat, 0, 0, reinterpret_cast < PMYSTR > (&szTemp), 0,
-              &argList) == 0 || szTemp == 0) {
+                      &argList) == 0 || szTemp == 0) {
-             throw std::runtime_error("out of memory");
+                 throw std::runtime_error("out of memory");
-         }
+             }
-         *this = szTemp;
+             *this = szTemp;
-         LocalFree(szTemp);
+             LocalFree(szTemp);
-         va_end(argList);
+             va_end(argList);
-     }
+         }
  #endif
-     // GetAllocLength -- an MSVC7 function but it costs us nothing to add it.
+         // GetAllocLength -- an MSVC7 function but it costs us nothing to add it.
-     int GetAllocLength()
+         int GetAllocLength()
-     {
+         {
-         return static_cast < int >(this->capacity());
+             return static_cast < int >(this->capacity());
-     }
+         }
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // GetXXXX -- Direct access to character buffer
+         // GetXXXX -- Direct access to character buffer
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     CT GetAt(int nIdx) const
+         CT GetAt(int nIdx) const
-     {
+         {
-         return this->at(static_cast < MYSIZE > (nIdx));
+             return this->at(static_cast < MYSIZE > (nIdx));
-     }
+         }
-     CT *GetBuffer(int nMinLen = -1) {
+         CT *GetBuffer(int nMinLen = -1)
-         return GetBuf(nMinLen);
+         {
-     }
+             return GetBuf(nMinLen);
+         }
-     CT *GetBufferSetLength(int nLen)
+         CT *GetBufferSetLength(int nLen)
-     {
+         {
-         return BufferSet(nLen);
+             return BufferSet(nLen);
-     }
+         }
-     // GetLength() -- MFC docs say this is the # of BYTES but
+         // GetLength() -- MFC docs say this is the # of BYTES but
-     // in truth it is the number of CHARACTERs (chars or wchar_ts)
+         // in truth it is the number of CHARACTERs (chars or wchar_ts)
-     int GetLength() const
+         int GetLength() const
-     {
+         {
-         return static_cast < int >(this->length());
+             return static_cast < int >(this->length());
-     }
+         }
-     int Insert(int nIdx, CT ch)
+         int Insert(int nIdx, CT ch)
-     {
+         {
-         if (static_cast < MYSIZE > (nIdx) > this->size() - 1)
+             if (static_cast < MYSIZE > (nIdx) >
-             this->append(1, ch);
+                     this->size() - 1)
-         else
+                 this->append(1, ch);
-             this->insert(static_cast < MYSIZE > (nIdx), 1, ch);
+             else
+                 this->insert(static_cast < MYSIZE > (nIdx), 1, ch);
-         return GetLength();
+             return GetLength();
-     }
+         }
-     int Insert(int nIdx, PCMYSTR sz)
+         int Insert(int nIdx, PCMYSTR sz)
-     {
+         {
-         if (static_cast < MYSIZE > (nIdx) >= this->size())
+             if (static_cast < MYSIZE > (nIdx) >
-             this->append(sz, static_cast < MYSIZE > (sslen(sz)));
+                     = this->size())
-         else
+                 this->append(sz, static_cast < MYSIZE > (sslen(sz)));
-             this->insert(static_cast < MYSIZE > (nIdx), sz);
+             else
+                 this->insert(static_cast < MYSIZE > (nIdx), sz);
-         return GetLength();
+             return GetLength();
-     }
+         }
-     bool IsEmpty() const
+         bool IsEmpty() const
-     {
+         {
-         return this->empty();
+             return this->empty();
-     }
+         }
-     MYTYPE Left(int nCount) const
+         MYTYPE Left(int nCount) const
-     {
+         {
-         // Range check the count.
+             // Range check the count.
-         nCount = SSMAX(0, SSMIN(nCount, static_cast < int >(this->size())));
+             nCount = SSMAX(0, SSMIN(nCount, static_cast < int >(this->size())));
-         return this->substr(0, static_cast < MYSIZE > (nCount));
+             return this->substr(0, static_cast < MYSIZE > (nCount));
-     }
+         }
  #ifndef SS_ANSI
-     bool LoadString(UINT nId)
+         bool LoadString(UINT nId)
-     {
+         {
-         return this->Load(nId);
+             return this->Load(nId);
-     }
+         }
  #endif
-     void MakeLower()
+         void MakeLower()
-     {
+         {
-         ToLower();
+             ToLower();
-     }
+         }
-     void MakeReverse()
-     {
-         std::reverse(this->begin(), this->end());
-     }
-     void MakeUpper()
-     {
-         ToUpper();
-     }
-     MYTYPE Mid(int nFirst) const
+         void MakeReverse()
-     {
+         {
-         return Mid(nFirst, this->GetLength() - nFirst);
+             std::reverse(this->begin(), this->end());
-     }
+         }
-     MYTYPE Mid(int nFirst, int nCount) const
+         void MakeUpper()
-     {
+         {
-         // CString does range checking here.  Since we're trying to emulate it,
+             ToUpper();
-         // we must check too.
+         }
-         if (nFirst < 0)
+         MYTYPE Mid(int nFirst) const
-             nFirst = 0;
+         {
-         if (nCount < 0)
+             return Mid(nFirst, this->GetLength() - nFirst);
-             nCount = 0;
+         }
-         int nSize = static_cast < int >(this->size());
+         MYTYPE Mid(int nFirst, int nCount) const
+         {
+             // CString does range checking here.  Since we're trying to emulate it,
+             // we must check too.
-         if (nFirst + nCount > nSize)
+             if (nFirst < 0)
-               nCount = nSize - nFirst;
+                 nFirst = 0;
+             if (nCount < 0)
+                 nCount = 0;
-         if (nFirst > nSize)
+             int nSize = static_cast < int >(this->size());
-               return MYTYPE();
-         ASSERT(nFirst >= 0);
+             if (nFirst + nCount > nSize)
-         ASSERT(nFirst + nCount <= nSize);
+                 nCount = nSize - nFirst;
-         return this->substr(static_cast < MYSIZE > (nFirst),
+             if (nFirst > nSize)
-                             static_cast < MYSIZE > (nCount));
+                 return MYTYPE();
-     }
-     void ReleaseBuffer(int nNewLen = -1) {
+             ASSERT(nFirst >= 0);
-         RelBuf(nNewLen);
+             ASSERT(nFirst + nCount <= nSize);
-     }
-     int Remove(CT ch)
+             return this->substr(static_cast < MYSIZE > (nFirst),
-     {
+                                 static_cast < MYSIZE > (nCount));
-         MYSIZE nIdx = 0;
-         int nRemoved = 0;
-         while ((nIdx = this->find_first_of(ch)) != MYBASE::npos) {
-             this->erase(nIdx, 1);
-             nRemoved++;
          }
-         return nRemoved;
-     }
-     int Replace(CT chOld, CT chNew)
+         void ReleaseBuffer(int nNewLen = -1)
-     {
+         {
-         int nReplaced = 0;
+             RelBuf(nNewLen);
+         }
-         for (MYITER iter = this->begin(); iter != this->end(); iter++) {
+         int Remove(CT ch)
-             if (*iter == chOld) {
+         {
-                 *iter = chNew;
+             MYSIZE nIdx = 0;
-                 nReplaced++;
+             int nRemoved = 0;
+             while ((nIdx = this->find_first_of(ch)) != MYBASE::npos) {
+                 this->erase(nIdx, 1);
+                 nRemoved++;
              }
+             return nRemoved;
          }
-         return nReplaced;
+         int Replace(CT chOld, CT chNew)
-     }
+         {
+             int nReplaced = 0;
-     int Replace(PCMYSTR szOld, PCMYSTR szNew)
+             for (MYITER iter = this->begin(); iter != this->end(); iter++) {
-     {
+                 if (*iter == chOld) {
-         int nReplaced = 0;
+                     *iter = chNew;
-         MYSIZE nIdx = 0;
+                     nReplaced++;
-         MYSIZE nOldLen = sslen(szOld);
-         if (0 != nOldLen) {
-             // If the replacement string is longer than the one it replaces, this
-             // string is going to have to grow in size,  Figure out how much
-             // and grow it all the way now, rather than incrementally
-             MYSIZE nNewLen = sslen(szNew);
-             if (nNewLen > nOldLen) {
-                 int nFound = 0;
-                 while (nIdx < this->length() &&
-                        (nIdx = this->find(szOld, nIdx)) != MYBASE::npos) {
-                     nFound++;
-                     nIdx += nOldLen;
                  }
-                 this->reserve(this->size() + nFound * (nNewLen - nOldLen));
              }
+             return nReplaced;
+         }
-             static const CT ch = CT(0);
+         int Replace(PCMYSTR szOld, PCMYSTR szNew)
-             PCMYSTR szRealNew = szNew == 0 ? &ch : szNew;
+         {
-             nIdx = 0;
+             int nReplaced = 0;
+             MYSIZE nIdx = 0;
-             while (nIdx < this->length() &&
+             MYSIZE nOldLen = sslen(szOld);
-                    (nIdx = this->find(szOld, nIdx)) != MYBASE::npos) {
-                 this->replace(this->begin() + nIdx,
+             if (0 != nOldLen) {
-                               this->begin() + nIdx + nOldLen, szRealNew);
+                 // If the replacement string is longer than the one it replaces, this
+                 // string is going to have to grow in size,  Figure out how much
+                 // and grow it all the way now, rather than incrementally
+                 MYSIZE nNewLen = sslen(szNew);
+                 if (nNewLen > nOldLen) {
+                     int nFound = 0;
+                     while (nIdx < this->length() &&
+                             (nIdx = this->find(szOld, nIdx)) != MYBASE::npos) {
+                         nFound++;
+                         nIdx += nOldLen;
+                     }
+                     this->reserve(this->size() + nFound * (nNewLen - nOldLen));
+                 }
+                 static const CT ch = CT(0);
+                 PCMYSTR szRealNew = szNew == 0 ? &ch : szNew;
+                 nIdx = 0;
-                 nReplaced++;
+                 while (nIdx < this->length() &&
-                 nIdx += nNewLen;
+                         (nIdx = this->find(szOld, nIdx)) != MYBASE::npos) {
+                     this->replace(this->begin() + nIdx,
+                                   this->begin() + nIdx + nOldLen, szRealNew);
+                     nReplaced++;
+                     nIdx += nNewLen;
+                 }
              }
-         }
-         return nReplaced;
+             return nReplaced;
-     }
+         }
-     int ReverseFind(CT ch) const
+         int ReverseFind(CT ch) const
-     {
+         {
-         MYSIZE nIdx = this->find_last_of(ch);
+             MYSIZE nIdx = this->find_last_of(ch);
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
-     }
+         }
-     // ReverseFind overload that's not in CString but might be useful
+         // ReverseFind overload that's not in CString but might be useful
-     int ReverseFind(PCMYSTR szFind, MYSIZE pos = MYBASE::npos) const
+         int ReverseFind(PCMYSTR szFind, MYSIZE pos = MYBASE::npos) const
-     {
+         {
-         MYSIZE nIdx = this->rfind(0 == szFind ? MYTYPE() : szFind, pos);
+             MYSIZE nIdx = this->rfind(0 == szFind ? MYTYPE() : szFind, pos);
-         return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
+             return static_cast < int >(MYBASE::npos == nIdx ? -1 : nIdx);
-     }
+         }
-     MYTYPE Right(int nCount) const
+         MYTYPE Right(int nCount) const
-     {
+         {
-         // Range check the count.
+             // Range check the count.
-         nCount = SSMAX(0, SSMIN(nCount, static_cast < int >(this->size())));
+             nCount = SSMAX(0, SSMIN(nCount, static_cast < int >(this->size())));
-         return this->substr(this->size() - static_cast < MYSIZE > (nCount));
+             return this->substr(this->size() - static_cast < MYSIZE > (nCount));
-     }
+         }
-     void SetAt(int nIndex, CT ch)
+         void SetAt(int nIndex, CT ch)
-     {
+         {
-         ASSERT(this->size() > static_cast < MYSIZE > (nIndex));
+             ASSERT(this->size() > static_cast < MYSIZE > (nIndex));
-         this->at(static_cast < MYSIZE > (nIndex)) = ch;
+             this->at(static_cast < MYSIZE > (nIndex)) = ch;
-     }
+         }
  #ifndef SS_ANSI
-     BSTR SetSysString(BSTR * pbstr) const
+         BSTR SetSysString(BSTR * pbstr) const
-     {
+         {
-         ostring os;
+             ostring os;
-         ssasn(os, *this);
+             ssasn(os, *this);
-         if (!::SysReAllocStringLen(pbstr, os.c_str(), os.length()))
+             if (!::SysReAllocStringLen(pbstr, os.c_str(), os.length()))
-             throw std::runtime_error("out of memory");
+                 throw std::runtime_error("out of memory");
-         ASSERT(*pbstr != 0);
+             ASSERT(*pbstr != 0);
-         return *pbstr;
+             return *pbstr;
-     }
+         }
  #endif
-     MYTYPE SpanExcluding(PCMYSTR szCharSet) const
+         MYTYPE SpanExcluding(PCMYSTR szCharSet) const
-     {
+         {
-         MYSIZE pos = this->find_first_of(szCharSet);
+             MYSIZE pos = this->find_first_of(szCharSet);
-         return pos == MYBASE::npos ? *this : Left(pos);
+             return pos == MYBASE::npos ? *this : Left(pos);
-     }
+         }
-     MYTYPE SpanIncluding(PCMYSTR szCharSet) const
+         MYTYPE SpanIncluding(PCMYSTR szCharSet) const
-     {
+         {
-         MYSIZE pos = this->find_first_not_of(szCharSet);
+             MYSIZE pos = this->find_first_not_of(szCharSet);
-         return pos == MYBASE::npos ? *this : Left(pos);
+             return pos == MYBASE::npos ? *this : Left(pos);
-     }
+         }
  #if defined SS_WIN32 && !defined(UNICODE) && !defined(SS_ANSI)
-     // CString's OemToAnsi and AnsiToOem functions are available only in
+         // CString's OemToAnsi and AnsiToOem functions are available only in
-     // Unicode builds.  However since we're a template we also need a
+         // Unicode builds.  However since we're a template we also need a
-     // runtime check of CT and a reinterpret_cast to account for the fact
+         // runtime check of CT and a reinterpret_cast to account for the fact
-     // that CStdStringW gets instantiated even in non-Unicode builds.
+         // that CStdStringW gets instantiated even in non-Unicode builds.
-     void AnsiToOem()
+         void AnsiToOem()
-     {
+         {
-         if (sizeof(CT) == sizeof(char) && !empty()) {
+             if (sizeof(CT) == sizeof(char) && !empty()) {
-             ::CharToOem(reinterpret_cast < PCSTR > (this->c_str()),
+                 ::CharToOem(reinterpret_cast < PCSTR > (this->c_str()),
-                         reinterpret_cast < PSTR > (GetBuf()));
+                             reinterpret_cast < PSTR > (GetBuf()));
-         }
+             } else {
-         else {
+                 ASSERT(false);
-             ASSERT(false);
+             }
          }
-     }
-     void OemToAnsi()
+         void OemToAnsi()
-     {
+         {
-         if (sizeof(CT) == sizeof(char) && !empty()) {
+             if (sizeof(CT) == sizeof(char) && !empty()) {
-             ::OemToChar(reinterpret_cast < PCSTR > (this->c_str()),
+                 ::OemToChar(reinterpret_cast < PCSTR > (this->c_str()),
-                         reinterpret_cast < PSTR > (GetBuf()));
+                             reinterpret_cast < PSTR > (GetBuf()));
-         }
+             } else {
-         else {
+                 ASSERT(false);
-             ASSERT(false);
+             }
          }
-     }
  #endif
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // Trim and its variants
+         // Trim and its variants
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     MYTYPE & Trim() {
+         MYTYPE & Trim()
-         return TrimLeft().TrimRight();
+         {
-     }
+             return TrimLeft().TrimRight();
+         }
-     MYTYPE & TrimLeft() {
+         MYTYPE & TrimLeft()
-         this->erase(this->begin(),
+         {
-                     std::find_if(this->begin(), this->end(),
+             this->erase(this->begin(),
-                                  NotSpace < CT > ()));
+                         std::find_if(this->begin(), this->end(),
+                                      NotSpace < CT > ()));
-         return *this;
+             return *this;
-     }
+         }
-     MYTYPE & TrimLeft(CT tTrim) {
+         MYTYPE & TrimLeft(CT tTrim)
-         this->erase(0, this->find_first_not_of(tTrim));
+         {
-         return *this;
+             this->erase(0, this->find_first_not_of(tTrim));
-     }
+             return *this;
+         }
-     MYTYPE & TrimLeft(PCMYSTR szTrimChars) {
+         MYTYPE & TrimLeft(PCMYSTR szTrimChars)
-         this->erase(0, this->find_first_not_of(szTrimChars));
+         {
-         return *this;
+             this->erase(0, this->find_first_not_of(szTrimChars));
-     }
+             return *this;
+         }
-     MYTYPE & TrimRight() {
+         MYTYPE & TrimRight()
-         // NOTE:  When comparing reverse_iterators here (MYRITER), I avoid using
+         {
-         // operator!=.  This is because namespace rel_ops also has a template
+             // NOTE:  When comparing reverse_iterators here (MYRITER), I avoid using
-         // operator!= which conflicts with the global operator!= already defined
+             // operator!=.  This is because namespace rel_ops also has a template
-         // for reverse_iterator in the header <utility>.
+             // operator!= which conflicts with the global operator!= already defined
-         // Thanks to John James for alerting me to this.
+             // for reverse_iterator in the header <utility>.
+             // Thanks to John James for alerting me to this.
-         MYRITER it =
-             std::find_if(this->rbegin(), this->rend(), NotSpace < CT > ());
+             MYRITER it =
-         if (!(this->rend() == it))
+                 std::find_if(this->rbegin(), this->rend(), NotSpace < CT > ());
-             this->erase(this->rend() - it);
+             if (!(this->rend() == it))
+                 this->erase(this->rend() - it);
-         this->erase(!(it == this->rend())? this->find_last_of(*it) + 1 : 0);
+             this->erase(!(it == this->rend())? this->find_last_of(*it) + 1 : 0);
-         return *this;
+             return *this;
-     }
+         }
-     MYTYPE & TrimRight(CT tTrim) {
+         MYTYPE & TrimRight(CT tTrim)
-         MYSIZE nIdx = this->find_last_not_of(tTrim);
+         {
-         this->erase(MYBASE::npos == nIdx ? 0 : ++nIdx);
+             MYSIZE nIdx = this->find_last_not_of(tTrim);
-         return *this;
+             this->erase(MYBASE::npos == nIdx ? 0 : ++nIdx);
-     }
+             return *this;
+         }
-     MYTYPE & TrimRight(PCMYSTR szTrimChars) {
+         MYTYPE & TrimRight(PCMYSTR szTrimChars)
-         MYSIZE nIdx = this->find_last_not_of(szTrimChars);
+         {
-         this->erase(MYBASE::npos == nIdx ? 0 : ++nIdx);
+             MYSIZE nIdx = this->find_last_not_of(szTrimChars);
-         return *this;
+             this->erase(MYBASE::npos == nIdx ? 0 : ++nIdx);
-     }
+             return *this;
+         }
-     void FreeExtra()
+         void FreeExtra()
-     {
+         {
-         MYTYPE mt;
+             MYTYPE mt;
-         this->swap(mt);
+             this->swap(mt);
-         if (!mt.empty())
+             if (!mt.empty())
-             this->assign(mt.c_str(), mt.size());
+                 this->assign(mt.c_str(), mt.size());
-     }
+         }
-     // I have intentionally not implemented the following CString
+         // I have intentionally not implemented the following CString
-     // functions.   You cannot make them work without taking advantage
+         // functions.   You cannot make them work without taking advantage
-     // of implementation specific behavior.  However if you absolutely
+         // of implementation specific behavior.  However if you absolutely
-     // MUST have them, uncomment out these lines for "sort-of-like"
+         // MUST have them, uncomment out these lines for "sort-of-like"
-     // their behavior.  You're on your own.
+         // their behavior.  You're on your own.
- //      CT*                             LockBuffer()    { return GetBuf(); }// won't really lock
- //      void                    UnlockBuffer(); { }     // why have UnlockBuffer w/o LockBuffer?
-     // Array-indexing operators.  Required because we defined an implicit cast
-     // to operator const CT* (Thanks to Julian Selman for pointing this out)
-     CT & operator[](int nIdx) {
-         return static_cast < MYBASE * >(this)->operator[](static_cast <
-                                                           MYSIZE > (nIdx));
-     }
-     const CT & operator[] (int nIdx) const
+         //      CT*                             LockBuffer()    { return GetBuf(); }// won't really lock
-     {
+         //      void                    UnlockBuffer(); { }     // why have UnlockBuffer w/o LockBuffer?
-         return static_cast < const MYBASE *>(this)->operator[] (static_cast <
-                                                                 MYSIZE >
-                                                                 (nIdx));
-     }
-     CT & operator[] (unsigned int nIdx)
+         // Array-indexing operators.  Required because we defined an implicit cast
-     {
+         // to operator const CT* (Thanks to Julian Selman for pointing this out)
-         return static_cast < MYBASE * >(this)->operator[](static_cast <
-                                                           MYSIZE > (nIdx));
-     }
-     const CT & operator[] (unsigned int nIdx) const
+         CT & operator[](int nIdx)
-     {
+         {
-         return static_cast < const MYBASE *>(this)->operator[] (static_cast <
+             return static_cast < MYBASE * >(this)->operator[](static_cast <
-                                                                 MYSIZE >
+                     MYSIZE > (nIdx));
-                                                                 (nIdx));
+         }
-     }
+         const CT & operator[] (int nIdx) const
+         {
+             return static_cast < const MYBASE *>(this)->operator[] (static_cast <
+                     MYSIZE >
+                     (nIdx));
+         }
+         CT & operator[] (unsigned int nIdx)
+         {
+             return static_cast < MYBASE * >(this)->operator[](static_cast <
+                     MYSIZE > (nIdx));
+         }
+         const CT & operator[] (unsigned int nIdx) const
+         {
+             return static_cast < const MYBASE *>(this)->operator[] (static_cast <
+                     MYSIZE >
+                     (nIdx));
+         }
  #ifndef SS_NO_IMPLICIT_CAST
-     operator   const CT *() const
+         operator     const CT *() const
-     {
+         {
-         return this->c_str();
+             return this->c_str();
-     }
+         }
  #endif
-     // IStream related functions.  Useful in IPersistStream implementations
+         // IStream related functions.  Useful in IPersistStream implementations
  #ifdef SS_INC_COMDEF
-     // struct SSSHDR - useful for non Std C++ persistence schemes.
+         // struct SSSHDR - useful for non Std C++ persistence schemes.
-     typedef struct SSSHDR
+         typedef struct SSSHDR
-     {
+         {
-         BYTE byCtrl;
+             BYTE byCtrl;
-         ULONG nChars;
+             ULONG nChars;
-     } SSSHDR;                   // as in "Standard String Stream Header"
+         }
+         SSSHDR;                   // as in "Standard String Stream Header"
  #define SSSO_UNICODE    0x01    // the string is a wide string
  #define SSSO_COMPRESS   0x02    // the string is compressed
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     // FUNCTION: StreamSize
+         // FUNCTION: StreamSize
-     // REMARKS:
+         // REMARKS:
-     //              Returns how many bytes it will take to StreamSave() this CStdString
+         //              Returns how many bytes it will take to StreamSave() this CStdString
-     //              object to an IStream.
+         //              object to an IStream.
-     // -------------------------------------------------------------------------
+         // -------------------------------------------------------------------------
-     ULONG StreamSize() const
+         ULONG StreamSize() const
-     {
-         // Control header plus string
-         ASSERT(this->size() * sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));
-         return (this->size() * sizeof(CT)) + sizeof(SSSHDR);
-     }
-     // -------------------------------------------------------------------------
-     // FUNCTION: StreamSave
-     // REMARKS:
-     //              Saves this CStdString object to a COM IStream.
-     // -------------------------------------------------------------------------
-     HRESULT StreamSave(IStream * pStream) const
-     {
-         ASSERT(this->size() * sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));
-         HRESULT hr = E_FAIL;
-         ASSERT(pStream != 0);
-         SSSHDR hdr;
-         hdr.byCtrl = sizeof(CT) == 2 ? SSSO_UNICODE : 0;
-         hdr.nChars = this->size();
-         if (FAILED(hr = pStream->Write(&hdr, sizeof(SSSHDR), 0))) {
-             TRACE(_T("StreamSave: Cannot write control header, ERR=0x%X\n"),
-                   hr);
-         }
-         else if (empty())
          {
-             ;                   // nothing to write
+             // Control header plus string
-         }
+             ASSERT(this->size() * sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));
-         else if (FAILED(hr = pStream->Write(this->c_str(),
+             return (this->size() * sizeof(CT)) + sizeof(SSSHDR);
-                                             this->size() * sizeof(CT), 0))) {
-             TRACE(_T("StreamSave: Cannot write string to stream 0x%X\n"), hr);
          }
-         return hr;
+         // -------------------------------------------------------------------------
-     }
+         // FUNCTION: StreamSave
+         // REMARKS:
+         //              Saves this CStdString object to a COM IStream.
+         // -------------------------------------------------------------------------
+         HRESULT StreamSave(IStream * pStream) const
+         {
+             ASSERT(this->size() * sizeof(CT) < 0xffffffffUL - sizeof(SSSHDR));
+             HRESULT hr = E_FAIL;
+             ASSERT(pStream != 0);
+             SSSHDR hdr;
+             hdr.byCtrl = sizeof(CT) == 2 ? SSSO_UNICODE : 0;
+             hdr.nChars = this->size();
+             if (FAILED(hr = pStream->Write(&hdr, sizeof(SSSHDR), 0))) {
+                 TRACE(_T("StreamSave: Cannot write control header, ERR=0x%X\n"),
+                       hr);
+             } else if (empty()) {
+                 ;                   // nothing to write
+             } else if (FAILED(hr = pStream->Write(this->c_str(),
+                                                   this->size() * sizeof(CT), 0))) {
+                 TRACE(_T("StreamSave: Cannot write string to stream 0x%X\n"), hr);
+             }
+             return hr;
+         }
-     // -------------------------------------------------------------------------
-     // FUNCTION: StreamLoad
+         // -------------------------------------------------------------------------
-     // REMARKS:
+         // FUNCTION: StreamLoad
-     //              This method loads the object from an IStream.
+         // REMARKS:
-     // -------------------------------------------------------------------------
+         //              This method loads the object from an IStream.
-     HRESULT StreamLoad(IStream * pStream)
+         // -------------------------------------------------------------------------
-     {
+         HRESULT StreamLoad(IStream * pStream)
-         ASSERT(pStream != 0);
+         {
-         SSSHDR hdr;
+             ASSERT(pStream != 0);
-         HRESULT hr = E_FAIL;
+             SSSHDR hdr;
+             HRESULT hr = E_FAIL;
-         if (FAILED(hr = pStream->Read(&hdr, sizeof(SSSHDR), 0))) {
-             TRACE(_T("StreamLoad: Cant read control header, ERR=0x%X\n"), hr);
+             if (FAILED(hr = pStream->Read(&hdr, sizeof(SSSHDR), 0))) {
-         }
+                 TRACE(_T("StreamLoad: Cant read control header, ERR=0x%X\n"), hr);
-         else if (hdr.nChars > 0) {
+             } else if (hdr.nChars > 0) {
-             ULONG nRead = 0;
+                 ULONG nRead = 0;
-             PMYSTR pMyBuf = BufferSet(hdr.nChars);
+                 PMYSTR pMyBuf = BufferSet(hdr.nChars);
-             // If our character size matches the character size of the string
+                 // If our character size matches the character size of the string
-             // we're trying to read, then we can read it directly into our
+                 // we're trying to read, then we can read it directly into our
-             // buffer. Otherwise, we have to read into an intermediate buffer
+                 // buffer. Otherwise, we have to read into an intermediate buffer
-             // and convert.
+                 // and convert.
-             if ((hdr.byCtrl & SSSO_UNICODE) != 0) {
+                 if ((hdr.byCtrl & SSSO_UNICODE) != 0) {
-                 ULONG nBytes = hdr.nChars * sizeof(wchar_t);
+                     ULONG nBytes = hdr.nChars * sizeof(wchar_t);
-                 if (sizeof(CT) == sizeof(wchar_t)) {
+                     if (sizeof(CT) == sizeof(wchar_t)) {
-                     if (FAILED(hr = pStream->Read(pMyBuf, nBytes, &nRead)))
+                         if (FAILED(hr = pStream->Read(pMyBuf, nBytes, &nRead)))
-                         TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
+                             TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
-                               hr);
+                                   hr);
-                 }
+                     } else {
-                 else {
+                         PWSTR pBufW =
-                     PWSTR pBufW =
+                             reinterpret_cast < PWSTR > (_alloca((nBytes) + 1));
-                         reinterpret_cast < PWSTR > (_alloca((nBytes) + 1));
+                         if (FAILED(hr = pStream->Read(pBufW, nBytes, &nRead)))
-                     if (FAILED(hr = pStream->Read(pBufW, nBytes, &nRead)))
+                             TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
-                         TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
+                                   hr);
-                               hr);
+                         else
-                     else
+                             sscpy(pMyBuf, pBufW, hdr.nChars);
-                         sscpy(pMyBuf, pBufW, hdr.nChars);
+                     }
-                 }
+                 } else {
-             }
+                     ULONG nBytes = hdr.nChars * sizeof(char);
-             else {
+                     if (sizeof(CT) == sizeof(char)) {
-                 ULONG nBytes = hdr.nChars * sizeof(char);
+                         if (FAILED(hr = pStream->Read(pMyBuf, nBytes, &nRead)))
-                 if (sizeof(CT) == sizeof(char)) {
+                             TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
-                     if (FAILED(hr = pStream->Read(pMyBuf, nBytes, &nRead)))
+                                   hr);
-                         TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
+                     } else {
-                               hr);
+                         PSTR pBufA = reinterpret_cast < PSTR > (_alloca(nBytes));
-                 }
+                         if (FAILED(hr = pStream->Read(pBufA, hdr.nChars, &nRead)))
-                 else {
+                             TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
-                     PSTR pBufA = reinterpret_cast < PSTR > (_alloca(nBytes));
+                                   hr);
-                     if (FAILED(hr = pStream->Read(pBufA, hdr.nChars, &nRead)))
+                         else
-                         TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"),
+                             sscpy(pMyBuf, pBufA, hdr.nChars);
-                               hr);
+                     }
-                     else
-                         sscpy(pMyBuf, pBufA, hdr.nChars);
                  }
+             } else {
+                 this->erase();
              }
+             return hr;
          }
-         else {
-             this->erase();
-         }
-         return hr;
-     }
  #endif // #ifdef SS_INC_COMDEF
  #ifndef SS_ANSI
-     // SetResourceHandle/GetResourceHandle.  In MFC builds, these map directly
+         // SetResourceHandle/GetResourceHandle.  In MFC builds, these map directly
-     // to AfxSetResourceHandle and AfxGetResourceHandle.  In non-MFC builds they
+         // to AfxSetResourceHandle and AfxGetResourceHandle.  In non-MFC builds they
-     // point to a single static HINST so that those who call the member
+         // point to a single static HINST so that those who call the member
-     // functions that take resource IDs can provide an alternate HINST of a DLL
+         // functions that take resource IDs can provide an alternate HINST of a DLL
-     // to search.  This is not exactly the list of HMODULES that MFC provides
+         // to search.  This is not exactly the list of HMODULES that MFC provides
-     // but it's better than nothing.
+         // but it's better than nothing.
  #ifdef _MFC_VER
-     static void SetResourceHandle(HMODULE hNew)
+         static void SetResourceHandle(HMODULE hNew)
-     {
+         {
-         AfxSetResourceHandle(hNew);
+             AfxSetResourceHandle(hNew);
-     }
+         }
-     static HMODULE GetResourceHandle()
+         static HMODULE GetResourceHandle()
-     {
+         {
-         return AfxGetResourceHandle();
+             return AfxGetResourceHandle();
-     }
+         }
  #else
-     static void SetResourceHandle(HMODULE hNew)
+         static void SetResourceHandle(HMODULE hNew)
-     {
+         {
-         SSResourceHandle() = hNew;
+             SSResourceHandle() = hNew;
-     }
+         }
-     static HMODULE GetResourceHandle()
+         static HMODULE GetResourceHandle()
-     {
+         {
-         return SSResourceHandle();
+             return SSResourceHandle();
-     }
+         }
  #endif
  #endif
-Line 3838 
 template < typename CT > class CStdStr:p
+Line 3905 
 template < typename CT > class CStdStr:p
  //              SSDLLEXP        (nothing, just #define it)              extern
  //              SSDLLSPEC       __declspec(dllexport)                   __declspec(dllimport)
  //
  //              Note that these macros must be available to ALL clients who want to
  //              link to the DLL and use the class.  If they
  //
  // A word of advice: Don't bother.
  //
-Line 3990 
 inline CStdStringW operator+(const CStdS
+Line 4057 
 inline CStdStringW operator+(const CStdS
  #ifdef SS_SAFE_FORMAT
- template <> struct FmtArg <CStdStringA >
+ template <>
+ struct FmtArg <CStdStringA >
  {
      explicit FmtArg(const CStdStringA & arg):a_(arg)
-     {
+     {}
-     }
      PCSTR operator() () const
      {
          return a_.c_str();
      }
      const CStdStringA & a_;
-   private:
+ private:
      FmtArg < CStdStringA > &operator=(const FmtArg < CStdStringA > &)
      {
          return *this;
      }
  };
- template <> struct FmtArg <CStdStringW >
+ template <>
+ struct FmtArg <CStdStringW >
  {
      explicit FmtArg(const CStdStringW & arg):a_(arg)
-     {
+     {}
-     }
      PCWSTR operator() () const
      {
          return a_.c_str();
      }
      const CStdStringW & a_;
-   private:
+ private:
      FmtArg < CStdStringW > &operator=(const FmtArg < CStdStringW > &)
      {
          return *this;
      }
  };
- template <> struct FmtArg <std::string >
+ template <>
+ struct FmtArg <std::string >
  {
      explicit FmtArg(const std::string & arg):a_(arg)
-     {
+     {}
-     }
      PCSTR operator() () const
      {
          return a_.c_str();
      }
      const std::string & a_;
-   private:
+ private:
      FmtArg < std::string > &operator=(const FmtArg < std::string > &)
      {
          return *this;
      }
  };
- template <> struct FmtArg <std::wstring >
+ template <>
+ struct FmtArg <std::wstring >
  {
      explicit FmtArg(const std::wstring & arg):a_(arg)
-     {
+     {}
-     }
      PCWSTR operator() () const
      {
          return a_.c_str();
      }
      const std::wstring & a_;
-   private:
+ private:
      FmtArg < std::wstring > &operator=(const FmtArg < std::wstring > &)
      {
          return *this;
-Line 4058 
 template <> struct FmtArg <std::wstring
+Line 4125 
 template <> struct FmtArg <std::wstring
  #endif // #ifdef SS_SAFEFORMAT
  #ifndef SS_ANSI
-         // SSResourceHandle: our MFC-like resource handle
+ // SSResourceHandle: our MFC-like resource handle
  inline HMODULE & SSResourceHandle()
  {
      static HMODULE hModuleSS = GetModuleHandle(0);
-Line 4167 
 inline CStdStringW WUFormatW(UINT nId, .
+Line 4234 
 inline CStdStringW WUFormatW(UINT nId, .
  #if defined(SS_WIN32) && !defined (SS_ANSI)
-         // -------------------------------------------------------------------------
+ // -------------------------------------------------------------------------
-         // FUNCTION: WUSysMessage
+ // FUNCTION: WUSysMessage
-         //       CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);
+ //       CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);
-         //       CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);
+ //       CStdStringW WUSysMessageW(DWORD dwError, DWORD dwLangId=SS_DEFLANGID);
-         //
+ //
-         // DESCRIPTION:
+ // DESCRIPTION:
-         //       This function simplifies the process of obtaining a string equivalent
+ //       This function simplifies the process of obtaining a string equivalent
-         //       of a system error code returned from GetLastError().  You simply
+ //       of a system error code returned from GetLastError().  You simply
-         //       supply the value returned by GetLastError() to this function and the
+ //       supply the value returned by GetLastError() to this function and the
-         //       corresponding system string is returned in the form of a CStdStringA.
+ //       corresponding system string is returned in the form of a CStdStringA.
-         //
+ //
-         // PARAMETERS:
+ // PARAMETERS:
-         //       dwError - a DWORD value representing the error code to be translated
+ //       dwError - a DWORD value representing the error code to be translated
-         //       dwLangId - the language id to use.  defaults to english.
+ //       dwLangId - the language id to use.  defaults to english.
-         //
+ //
-         // RETURN VALUE:
+ // RETURN VALUE:
-         //       a CStdStringA equivalent of the error code.  Currently, this function
+ //       a CStdStringA equivalent of the error code.  Currently, this function
-         //       only returns either English of the system default language strings.
+ //       only returns either English of the system default language strings.
-         // -------------------------------------------------------------------------
+ // -------------------------------------------------------------------------
  #define SS_DEFLANGID MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT)
  inline CStdStringA WUSysMessageA(DWORD dwError, DWORD dwLangId = SS_DEFLANGID)
  {
-Line 4212 
 inline CStdStringW WUSysMessageW(DWORD d
+Line 4279 
 inline CStdStringW WUSysMessageW(DWORD d
  // Define TCHAR based friendly names for some of these functions
  #ifdef UNICODE
-         //#define CStdString                            CStdStringW
+ //#define CStdString                            CStdStringW
  typedef CStdStringW CStdString;
  #define WUSysMessage                    WUSysMessageW
  #define WUFormat                                WUFormatW
  #else
-         //#define CStdString                            CStdStringA
+ //#define CStdString                            CStdStringA
  typedef CStdStringA CStdString;
  #define WUSysMessage                    WUSysMessageA
  #define WUFormat                                WUFormatA
-Line 4259 
 typedef CStdStringA CStdString;
+Line 4326 
 typedef CStdStringA CStdString;
  #endif
  struct StdStringLessNoCaseW:std::binary_function < CStdStringW, CStdStringW,
-     bool >
+             bool >
  {
      inline
-         bool operator() (const CStdStringW & sLeft,
+     bool operator() (const CStdStringW & sLeft,
-                          const CStdStringW & sRight) const
+                      const CStdStringW & sRight) const
      {
          return ssicmp(sLeft.c_str(), sRight.c_str()) < 0;
      }
  };
  struct StdStringEqualsNoCaseW:std::binary_function < CStdStringW, CStdStringW,
-     bool >
+             bool >
  {
      inline
-         bool operator() (const CStdStringW & sLeft,
+     bool operator() (const CStdStringW & sLeft,
-                          const CStdStringW & sRight) const
+                      const CStdStringW & sRight) const
      {
          return ssicmp(sLeft.c_str(), sRight.c_str()) == 0;
      }
  };
  struct StdStringLessNoCaseA:std::binary_function < CStdStringA, CStdStringA,
-     bool >
+             bool >
  {
      inline
-         bool operator() (const CStdStringA & sLeft,
+     bool operator() (const CStdStringA & sLeft,
-                          const CStdStringA & sRight) const
+                      const CStdStringA & sRight) const
      {
          return ssicmp(sLeft.c_str(), sRight.c_str()) < 0;
      }
  };
  struct StdStringEqualsNoCaseA:std::binary_function < CStdStringA, CStdStringA,
-     bool >
+             bool >
  {
      inline
-         bool operator() (const CStdStringA & sLeft,
+     bool operator() (const CStdStringA & sLeft,
-                          const CStdStringA & sRight) const
+                      const CStdStringA & sRight) const
      {
          return ssicmp(sLeft.c_str(), sRight.c_str()) == 0;
      }
-Line 4307 
 struct StdStringEqualsNoCaseA:std::binar
+Line 4374 
 struct StdStringEqualsNoCaseA:std::binar
  #endif
  // These std::swap specializations come courtesy of Mike Crusader.
  //namespace std
  //{

 Legend:



Removed from v.936
 


changed lines


 
Added in v.937
 Legend:



Removed from v.936
 


changed lines


 
Added in v.937
-Removed from v.936
+Added in v.937

	ViewVC Help
Powered by ViewVC 1.1.26