#pragma once #include #include #include #if defined(TARGET_WINDOWS) && !defined(va_copy) #define va_copy(dst, src) ((dst) = (src)) #endif // ============================================================================= // FILE: StdString.h // AUTHOR: Joe O'Leary (with outside help noted in comments) // // If you find any bugs in this code, please let me know: // // jmoleary@earthlink.net // http://www.joeo.net/stdstring.htm (a bit outdated) // // The latest version of this code should always be available at the // following link: // // http://www.joeo.net/code/StdString.zip (Dec 6, 2003) // // // REMARKS: // This header file declares the CStdStr template. This template derives // the Standard C++ Library basic_string<> template and add to it the // the following conveniences: // - The full MFC CString set of functions (including implicit cast) // - writing to/reading from COM IStream interfaces // - Functional objects for use in STL algorithms // // From this template, we intstantiate two classes: CStdStringA and // CStdStringW. The name "CStdString" is just a #define of one of these, // based upone the UNICODE macro setting // // This header also declares our own version of the MFC/ATL UNICODE-MBCS // conversion macros. Our version looks exactly like the Microsoft's to // facilitate portability. // // NOTE: // If you you use this in an MFC or ATL build, you should include either // afx.h or atlbase.h first, as appropriate. // // PEOPLE WHO HAVE CONTRIBUTED TO THIS CLASS: // // Several people have helped me iron out problems and othewise improve // this class. OK, this is a long list but in my own defense, this code // has undergone two major rewrites. Many of the improvements became // necessary after I rewrote the code as a template. Others helped me // improve the CString facade. // // Anyway, these people are (in chronological order): // // - Pete the Plumber (???) // - Julian Selman // - Chris (of Melbsys) // - Dave Plummer // - John C Sipos // - Chris Sells // - Nigel Nunn // - Fan Xia // - Matthew Williams // - Carl Engman // - Mark Zeren // - Craig Watson // - Rich Zuris // - Karim Ratib // - Chris Conti // - Baptiste Lepilleur // - Greg Pickles // - Jim Cline // - Jeff Kohn // - Todd Heckel // - Ullrich Poll�hne // - Joe Vitaterna // - Joe Woodbury // - Aaron (no last name) // - Joldakowski (???) // - Scott Hathaway // - Eric Nitzche // - Pablo Presedo // - Farrokh Nejadlotfi // - Jason Mills // - Igor Kholodov // - Mike Crusader // - John James // - Wang Haifeng // - Tim Dowty // - Arnt Witteveen // - Glen Maynard // - Paul DeMarco // - Bagira (full name?) // - Ronny Schulz // - Jakko Van Hunen // - Charles Godwin // - Henk Demper // - Greg Marr // - Bill Carducci // - Brian Groose // - MKingman // - Don Beusee // // REVISION HISTORY // // 2005-JAN-10 - Thanks to Don Beusee for pointing out the danger in mapping // length-checked formatting functions to non-length-checked // CRT equivalents. Also thanks to him for motivating me to // optimize my implementation of Replace() // // 2004-APR-22 - A big, big thank you to "MKingman" (whoever you are) for // 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 // errors). These include Henk Demper for figuring out how // to make the Intellisense work on with CStdString on VC6, // something I was never able to do. Greg Marr pointed out // a compiler warning about an unreferenced symbol and a // problem with my version of Load in MFC builds. Bill // Carducci took a lot of time with me to help me figure out // why some implementations of the Standard C++ Library were // returning error codes for apparently successful conversions // between ASCII and UNICODE. Finally thanks to Brian Groose // for helping me fix compiler signed unsigned warnings in // several functions. // // 2003-JUL-10 - Thanks to Charles Godwin for making me realize my 'FmtArg' // fixes had inadvertently broken the DLL-export code (which is // normally commented out. I had to move it up higher. Also // this helped me catch a bug in ssicoll that would prevent // compilation, otherwise. // // 2003-MAR-14 - Thanks to Jakko Van Hunen for pointing out a copy-and-paste // bug in one of the overloads of FmtArg. // // 2003-MAR-10 - Thanks to Ronny Schulz for (twice!) sending me some changes // to help CStdString build on SGI and for pointing out an // error in placement of my preprocessor macros for ssfmtmsg. // // 2002-NOV-26 - Thanks to Bagira for pointing out that my implementation of // SpanExcluding was not properly handling the case in which // the string did NOT contain any of the given characters // // 2002-OCT-21 - Many thanks to Paul DeMarco who was invaluable in helping me // get this code working with Borland's free compiler as well // as the Dev-C++ compiler (available free at SourceForge). // // 2002-SEP-13 - Thanks to Glen Maynard who helped me get rid of some loud // but harmless warnings that were showing up on g++. Glen // also pointed out that some pre-declarations of FmtArg<> // specializations were unnecessary (and no good on G++) // // 2002-JUN-26 - Thanks to Arnt Witteveen for pointing out that I was using // static_cast<> in a place in which I should have been using // reinterpret_cast<> (the ctor for unsigned char strings). // That's what happens when I don't unit-test properly! // Arnt also noticed that CString was silently correcting the // 'nCount' argument to Left() and Right() where CStdString was // not (and crashing if it was bad). That is also now fixed! // // 2002-FEB-25 - Thanks to Tim Dowty for pointing out (and giving me the fix // for) a conversion problem with non-ASCII MBCS characters. // CStdString is now used in my favorite commercial MP3 player! // // 2001-DEC-06 - Thanks to Wang Haifeng for spotting a problem in one of the // assignment operators (for _bstr_t) that would cause compiler // errors when refcounting protection was turned off. // // 2001-NOV-27 - Remove calls to operator!= which involve reverse_iterators // due to a conflict with the rel_ops operator!=. Thanks to // John James for pointing this out. // // 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 // 'std' namespace. But if you don't care about that, it's // there if you want it // - Thanks to Jason Mills for catching a case where CString was // more forgiving in the Delete() function than I was. // // 2001-JUN-06 - I was violating the Standard name lookup rules stated // in [14.6.2(3)]. None of the compilers I've tried so // far apparently caught this but HP-UX aCC 3.30 did. The // fix was to add 'this->' prefixes in many places. // Thanks to Farrokh Nejadlotfi for this! // // 2001-APR-27 - StreamLoad was calculating the number of BYTES in one // case, not characters. Thanks to Pablo Presedo for this. // // 2001-FEB-23 - Replace() had a bug which caused infinite loops if the // source string was empty. Fixed thanks to Eric Nitzsche. // // 2001-FEB-23 - Scott Hathaway was a huge help in providing me with the // ability to build CStdString on Sun Unix systems. He // sent me detailed build reports about what works and what // does not. If CStdString compiles on your Unix box, you // can thank Scott for it. // // 2000-DEC-29 - Joldakowski noticed one overload of Insert failed to do a // range check as CString's does. Now fixed -- thanks! // // 2000-NOV-07 - Aaron pointed out that I was calling static member // functions of char_traits via a temporary. This was not // technically wrong, but it was unnecessary and caused // problems for poor old buggy VC5. Thanks Aaron! // // 2000-JUL-11 - Joe Woodbury noted that the CString::Find docs don't match // what the CString::Find code really ends up doing. I was // trying to match the docs. Now I match the CString code // - Joe also caught me truncating strings for GetBuffer() calls // when the supplied length was less than the current length. // // 2000-MAY-25 - Better support for STLPORT's Standard library distribution // - Got rid of the NSP macro - it interfered with Koenig lookup // - Thanks to Joe Woodbury for catching a TrimLeft() bug that // I introduced in January. Empty strings were not getting // trimmed // // 2000-APR-17 - Thanks to Joe Vitaterna for pointing out that ReverseFind // is supposed to be a const function. // // 2000-MAR-07 - Thanks to Ullrich Poll�hne for catching a range bug in one // of the overloads of assign. // // 2000-FEB-01 - You can now use CStdString on the Mac with CodeWarrior! // Thanks to Todd Heckel for helping out with this. // // 2000-JAN-23 - Thanks to Jim Cline for pointing out how I could make the // Trim() function more efficient. // - Thanks to Jeff Kohn for prompting me to find and fix a typo // in one of the addition operators that takes _bstr_t. // - Got rid of the .CPP file - you only need StdString.h now! // // 1999-DEC-22 - Thanks to Greg Pickles for helping me identify a problem // with my implementation of CStdString::FormatV in which // resulting string might not be properly NULL terminated. // // 1999-DEC-06 - Chris Conti pointed yet another basic_string<> assignment // bug that MS has not fixed. CStdString did nothing to fix // it either but it does now! The bug was: create a string // longer than 31 characters, get a pointer to it (via c_str()) // and then assign that pointer to the original string object. // The resulting string would be empty. Not with CStdString! // // 1999-OCT-06 - BufferSet was erasing the string even when it was merely // supposed to shrink it. Fixed. Thanks to Chris Conti. // - 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 // // 1999-JUL-21 - Made all calls to GetBuf() with no args check length first. // // 1999-JUL-10 - Improved MFC/ATL independence of conversion macros // - Added SS_NO_REFCOUNT macro to allow you to disable any // reference-counting your basic_string<> impl. may do. // - Improved ReleaseBuffer() to be as forgiving as CString. // Thanks for Fan Xia for helping me find this and to // Matthew Williams for pointing it out directly. // // 1999-JUL-06 - Thanks to Nigel Nunn for catching a very sneaky bug in // ToLower/ToUpper. They should call GetBuf() instead of // data() in order to ensure the changed string buffer is not // reference-counted (in those implementations that refcount). // // 1999-JUL-01 - Added a true CString facade. Now you can use CStdString as // a drop-in replacement for CString. If you find this useful, // you can thank Chris Sells for finally convincing me to give // in and implement it. // - 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. // This was harmless bug but a bug nevertheless. Thanks to // Chris (of Melbsys) for pointing it out // - Changed Format() to try a normal stack-based array before // 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(). // // 1999-MAR-13 - Corrected the "NotSpace" functional object to use _istpace() // instead of _isspace() Thanks to Dave Plummer for this. // // 1999-FEB-26 - Removed errant line (left over from testing) that #defined // _MFC_VER. Thanks to John C Sipos for noticing this. // // 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 // // 1998-FEB-?? - Initial submission // // 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. // ============================================================================= // Avoid multiple inclusion #ifndef STDSTRING_H #define STDSTRING_H // When using VC, turn off browser references // Turn off unavoidable compiler warnings #if defined(_MSC_VER) && (_MSC_VER > 1100) #pragma component(browser, off, references, "CStdString") #pragma warning (disable : 4290) // C++ Exception Specification ignored #pragma warning (disable : 4127) // Conditional expression is constant #pragma warning (disable : 4097) // typedef name used as synonym for class name #endif // Borland warnings to turn off #ifdef __BORLANDC__ #pragma option push -w-inl // #pragma warn -inl // Turn off inline function warnings #endif // SS_IS_INTRESOURCE // ----------------- // A copy of IS_INTRESOURCE from VC7. Because old VC6 version of winuser.h // doesn't have this. #define SS_IS_INTRESOURCE(_r) (false) #if !defined (SS_ANSI) && defined(_MSC_VER) #undef SS_IS_INTRESOURCE #if defined(_WIN64) #define SS_IS_INTRESOURCE(_r) (((uint64_t)(_r) >> 16) == 0) #else #define SS_IS_INTRESOURCE(_r) (((unsigned long)(_r) >> 16) == 0) #endif #endif // MACRO: SS_UNSIGNED // ------------------ // This macro causes the addition of a constructor and assignment operator // which take unsigned characters. CString has such functions and in order // to provide maximum CString-compatability, this code needs them as well. // In practice you will likely never need these functions... //#define SS_UNSIGNED #ifdef SS_ALLOW_UNSIGNED_CHARS #define SS_UNSIGNED #endif // MACRO: SS_SAFE_FORMAT // --------------------- // This macro provides limited compatability with a questionable CString // "feature". You can define it in order to avoid a common problem that // people encounter when switching from CString to CStdString. // // To illustrate the problem -- With CString, you can do this: // // CString sName("Joe"); // CString sTmp; // sTmp.Format("My name is %s", sName); // WORKS! // // However if you were to try this with CStdString, your program would // crash. // // CStdString sName("Joe"); // CStdString sTmp; // sTmp.Format("My name is %s", sName); // CRASHES! // // You must explicitly call c_str() or cast the object to the proper type // // sTmp.Format("My name is %s", sName.c_str()); // WORKS! // sTmp.Format("My name is %s", static_cast(sName));// WORKS! // sTmp.Format("My name is %s", (PCSTR)sName); // WORKS! // // This is because it is illegal to pass anything but a POD type as a // variadic argument to a variadic function (i.e. as one of the "..." // arguments). The type const char* is a POD type. The type CStdString // is not. Of course, neither is the type CString, but CString lets you do // it anyway due to the way they laid out the class in binary. I have no // control over this in CStdString since I derive from whatever // implementation of basic_string is available. // // However if you have legacy code (which does this) that you want to take // 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. #define SS_SAFE_FORMAT // use new template style Format() function // MACRO: SS_NO_IMPLICIT_CAST // -------------------------- // Some people don't like the implicit cast to const char* (or rather to // const CT*) that CStdString (and MFC's CString) provide. That was the // whole reason I created this class in the first place, but hey, whatever // bakes your cake. Just #define this macro to get rid of the the implicit // cast. //#define SS_NO_IMPLICIT_CAST // gets rid of operator const CT*() // MACRO: SS_NO_REFCOUNT // --------------------- // turns off reference counting at the assignment level. Only needed // for the version of basic_string<> that comes with Visual C++ versions // 6.0 or earlier, and only then in some heavily multithreaded scenarios. // Uncomment it if you feel you need it. //#define SS_NO_REFCOUNT // MACRO: SS_WIN32 // --------------- // When this flag is set, we are building code for the Win32 platform and // may use Win32 specific functions (such as LoadString). This gives us // a couple of nice extras for the code. // // Obviously, Microsoft's is not the only compiler available for Win32 out // there. So I can't just check to see if _MSC_VER is defined to detect // if I'm building on Win32. So for now, if you use MS Visual C++ or // Borland's compiler, I turn this on. Otherwise you may turn it on // yourself, if you prefer #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WIN32) #define SS_WIN32 #endif // MACRO: SS_ANSI // -------------- // When this macro is defined, the code attempts only to use ANSI/ISO // 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 #ifndef SS_WIN32 #if !defined(SS_NO_ANSI) #define SS_ANSI #endif #endif // MACRO: SS_ALLOCA // ---------------- // Some implementations of the Standard C Library have a non-standard // function known as alloca(). This functions allows one to allocate a // variable amount of memory on the stack. It is needed to implement // the ASCII/MBCS conversion macros. // // I wanted to find some way to determine automatically if alloca() is // available on this platform via compiler flags but that is asking for // trouble. The crude test presented here will likely need fixing on // other platforms. Therefore I'll leave it up to you to fiddle with // this test to determine if it exists. Just make sure SS_ALLOCA is or // is not defined as appropriate and you control this feature. #if defined(_MSC_VER) && !defined(SS_ANSI) #define SS_ALLOCA #endif // MACRO: SS_MBCS // -------------- // Setting this macro means you are using MBCS characters. In MSVC builds, // this macro gets set automatically by detection of the preprocessor flag // _MBCS. For other platforms you may set it manually if you wish. The // only effect it currently has is to cause the allocation of more space // for wchar_t --> char conversions. // Note that MBCS does not mean UNICODE. // // #define SS_MBCS // #ifdef _MBCS #define SS_MBCS #endif // MACRO SS_NO_LOCALE // ------------------ // If your implementation of the Standard C++ Library lacks the header, // you can #define this macro to make your code build properly. Note that this // is some of my newest code and frankly I'm not very sure of it, though it does // pass my unit tests. // #define SS_NO_LOCALE // 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 // equivalent in UNICODE builds, stuff like that (when they MUST be in a proper // UNICODE build). You end up scratching your head and saying, "But that HAS // to compile!". // // So what should you do if you get this error? // // Make sure that both macros (_UNICODE and UNICODE) are defined before this // file is included. You can do that by either // // a) defining both yourself before any files get included // b) including the proper MS headers in the proper order // c) including this file before any other file, uncommenting // the #defines below, and commenting out the #errors // // Personally I recommend solution a) but it's your call. #ifdef _MSC_VER #if defined (_UNICODE) && !defined (UNICODE) #error UNICODE defined but not UNICODE // #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 #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 inline const Type& SSMIN(const Type& arg1, const Type& arg2) { return arg2 < arg1 ? arg2 : arg1; } template inline const Type& SSMAX(const Type& arg1, const Type& arg2) { return arg2 > arg1 ? arg2 : arg1; } // If they have not #included W32Base.h (part of my W32 utility library) then // we need to define some stuff. Otherwise, this is all defined there. #if !defined(W32BASE_H) // 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 // the spirit of SS_ANSI as we are not calling any Win32 functions here. #ifdef SS_WIN32 #include #include #ifndef STRICT #define STRICT #endif // ... but on non-Win32 platforms, we must #define the types we need. #else typedef const char* PCSTR; typedef char* PSTR; typedef const wchar_t* PCWSTR; typedef wchar_t* PWSTR; #ifdef UNICODE typedef wchar_t TCHAR; #else typedef char TCHAR; #endif typedef wchar_t OLECHAR; #endif // #ifndef _WIN32 // Make sure ASSERT and verify are defined using only ANSI stuff #ifndef ASSERT #include #define ASSERT(f) assert((f)) #endif #ifndef VERIFY #ifdef _DEBUG #define VERIFY(x) ASSERT((x)) #else #define VERIFY(x) x #endif #endif #else // ...else SS_ANSI is NOT defined #include #include #ifndef STRICT #define STRICT #endif // Make sure ASSERT and verify are defined #ifndef ASSERT #include #define ASSERT(f) _ASSERTE((f)) #endif #ifndef VERIFY #ifdef _DEBUG #define VERIFY(x) ASSERT((x)) #else #define VERIFY(x) x #endif #endif #endif // #ifdef SS_ANSI #ifndef UNUSED #define UNUSED(x) x #endif #endif // #ifndef W32BASE_H // Standard headers needed #include // basic_string #include // for_each, etc. #include // for StdStringLessNoCase, et al #ifndef SS_NO_LOCALE #include // for various facets #endif // If this is a recent enough version of VC include comdef.h, so we can write // member functions to deal with COM types & compiler support classes e.g. // _bstr_t #if defined (_MSC_VER) && (_MSC_VER >= 1100) #include #define SS_INC_COMDEF // signal that we #included MS comdef.h file #define STDSTRING_INC_COMDEF #define SS_NOTHROW __declspec(nothrow) #else #define SS_NOTHROW #endif #ifndef TRACE #define TRACE_DEFINED_HERE #define TRACE #endif // Microsoft defines PCSTR, PCWSTR, etc, but no PCTSTR. I hate to use the // versions with the "L" in front of them because that's a leftover from Win 16 // days, even though it evaluates to the same thing. Therefore, Define a PCSTR // as an LPCTSTR. #if !defined(PCTSTR) && !defined(PCTSTR_DEFINED) typedef const TCHAR* PCTSTR; #define PCTSTR_DEFINED #endif #if !defined(PCOLESTR) && !defined(PCOLESTR_DEFINED) typedef const OLECHAR* PCOLESTR; #define PCOLESTR_DEFINED #endif #if !defined(POLESTR) && !defined(POLESTR_DEFINED) typedef OLECHAR* POLESTR; #define POLESTR_DEFINED #endif #if !defined(PCUSTR) && !defined(PCUSTR_DEFINED) typedef const unsigned char* PCUSTR; typedef unsigned char* PUSTR; #define PCUSTR_DEFINED #endif // SGI compiler 7.3 doesnt know these types - oh and btw, remember to use // -LANG:std in the CXX Flags #if defined(__sgi) typedef unsigned long DWORD; typedef void * LPCVOID; #endif // SS_USE_FACET macro and why we need it: // // Since I'm a good little Standard C++ programmer, I use locales. Thus, I // need to make use of the use_facet<> template function here. Unfortunately, // this need is complicated by the fact the MS' implementation of the Standard // C++ Library has a non-standard version of use_facet that takes more // arguments than the standard dictates. Since I'm trying to write CStdString // to work with any version of the Standard library, this presents a problem. // // The upshot of this is that I can't do 'use_facet' directly. The MS' docs // tell me that I have to use a macro, _USE() instead. Since _USE obviously // won't be available in other implementations, this means that I have to write // my OWN macro -- SS_USE_FACET -- that evaluates either to _USE or to the // standard, use_facet. // // If you are having trouble with the SS_USE_FACET macro, in your implementation // of the Standard C++ Library, you can define your own version of SS_USE_FACET. #ifndef schMSG #define schSTR(x) #x #define schSTR2(x) schSTR(x) #define schMSG(desc) message(__FILE__ "(" schSTR2(__LINE__) "):" #desc) #endif #ifndef SS_USE_FACET // STLPort #defines a macro (__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) 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 // find it in \stlport\config\stl_msvc.h #if defined(__SGI_STL_PORT) && (__SGI_STL_PORT >= 0x400 ) #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && defined(_MSC_VER) #ifdef SS_ANSI #pragma schMSG(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS defined!!) #endif #endif #define SS_USE_FACET(loc, fac) std::use_facet(loc) #elif defined(_MSC_VER ) #define SS_USE_FACET(loc, fac) std::_USE(loc, fac) // ...and #elif defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) #define SS_USE_FACET(loc, fac) std::use_facet(loc, (fac*)0) #else #define SS_USE_FACET(loc, fac) std::use_facet(loc) #endif #endif // ============================================================================= // UNICODE/MBCS conversion macros. Made to work just like the MFC/ATL ones. // ============================================================================= #include // 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. #include #include #include #include #include #ifndef va_start #include #endif #ifdef SS_NO_LOCALE #if defined(_WIN32) || defined (_WIN32_WCE) inline PWSTR StdCodeCvt(PWSTR pDstW, int nDst, PCSTR pSrcA, int nSrc, UINT acp=CP_ACP) { ASSERT(0 != pSrcA); ASSERT(0 != pDstW); pDstW[0] = '\0'; MultiByteToWideChar(acp, 0, pSrcA, nSrc, pDstW, nDst); return pDstW; } inline PWSTR StdCodeCvt(PWSTR pDstW, int nDst, PCUSTR pSrcA, int nSrc, UINT acp=CP_ACP) { return StdCodeCvt(pDstW, nDst, (PCSTR)pSrcA, nSrc, acp); } inline PSTR StdCodeCvt(PSTR pDstA, int nDst, PCWSTR pSrcW, int nSrc, UINT acp=CP_ACP) { ASSERT(0 != pDstA); ASSERT(0 != pSrcW); pDstA[0] = '\0'; WideCharToMultiByte(acp, 0, pSrcW, nSrc, pDstA, nDst, 0, 0); return pDstA; } inline PUSTR StdCodeCvt(PUSTR pDstA, int nDst, PCWSTR pSrcW, int nSrc, UINT acp=CP_ACP) { return (PUSTR)StdCodeCvt((PSTR)pDstA, nDst, pSrcW, nSrc, acp); } #else #endif #else // StdCodeCvt - made to look like Win32 functions WideCharToMultiByte // and MultiByteToWideChar but uses locales in SS_ANSI // builds. There are a number of overloads. // First argument is the destination buffer. // Second argument is the source buffer //#if defined (SS_ANSI) || !defined (SS_WIN32) // 'SSCodeCvt' - shorthand name for the codecvt facet we use typedef std::codecvt SSCodeCvt; inline PWSTR StdCodeCvt(PWSTR pDstW, int nDst, PCSTR pSrcA, int nSrc, const std::locale& loc=std::locale()) { ASSERT(0 != pSrcA); ASSERT(0 != pDstW); pDstW[0] = '\0'; if ( nSrc > 0 ) { PCSTR pNextSrcA = pSrcA; PWSTR pNextDstW = pDstW; const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt); SSCodeCvt::state_type st= {}; SSCodeCvt::result res = conv.in(st, pSrcA, pSrcA + nSrc, pNextSrcA, pDstW, pDstW + nDst, pNextDstW); #ifdef TARGET_POSIX #define ASSERT2(a) if (!(a)) {fprintf(stderr, "StdString: Assertion Failed on line %d\n", __LINE__);} #else #define ASSERT2 ASSERT #endif ASSERT2(SSCodeCvt::ok == res); ASSERT2(SSCodeCvt::error != res); ASSERT2(pNextDstW >= pDstW); ASSERT2(pNextSrcA >= pSrcA); #undef ASSERT2 // Null terminate the converted string if ( pNextDstW - pDstW > nDst ) *(pDstW + nDst) = '\0'; else *pNextDstW = '\0'; } return pDstW; } inline PWSTR StdCodeCvt(PWSTR pDstW, int nDst, PCUSTR pSrcA, int nSrc, const std::locale& loc=std::locale()) { return StdCodeCvt(pDstW, nDst, (PCSTR)pSrcA, nSrc, loc); } inline PSTR StdCodeCvt(PSTR pDstA, int nDst, PCWSTR pSrcW, int nSrc, const std::locale& loc=std::locale()) { ASSERT(0 != pDstA); ASSERT(0 != pSrcW); pDstA[0] = '\0'; if ( nSrc > 0 ) { PSTR pNextDstA = pDstA; PCWSTR pNextSrcW = pSrcW; const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt); SSCodeCvt::state_type st= {}; SSCodeCvt::result res = conv.out(st, pSrcW, pSrcW + nSrc, pNextSrcW, pDstA, pDstA + nDst, pNextDstA); #ifdef TARGET_POSIX #define ASSERT2(a) if (!(a)) {fprintf(stderr, "StdString: Assertion Failed on line %d\n", __LINE__);} #else #define ASSERT2 ASSERT #endif ASSERT2(SSCodeCvt::error != res); ASSERT2(SSCodeCvt::ok == res); // strict, comment out for sanity ASSERT2(pNextDstA >= pDstA); ASSERT2(pNextSrcW >= pSrcW); #undef ASSERT2 // Null terminate the converted string if ( pNextDstA - pDstA > nDst ) *(pDstA + nDst) = '\0'; else *pNextDstA = '\0'; } return pDstA; } inline PUSTR StdCodeCvt(PUSTR pDstA, int nDst, PCWSTR pSrcW, int nSrc, const std::locale& loc=std::locale()) { return (PUSTR)StdCodeCvt((PSTR)pDstA, nDst, pSrcW, nSrc, loc); } #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 // needed for _alloca // Define our conversion macros to look exactly like Microsoft's to // facilitate using this stuff both with and without MFC/ATL #ifdef _CONVERSION_USES_THREAD_LOCALE #ifndef _DEBUG #define SSCVT int _cvt; _cvt; UINT _acp=GetACP(); \ _acp; PCWSTR _pw; _pw; PCSTR _pa; _pa #else #define SSCVT int _cvt = 0; _cvt; UINT _acp=GetACP();\ _acp; PCWSTR _pw=0; _pw; PCSTR _pa=0; _pa #endif #define SSA2W(pa) (\ ((_pa = pa) == 0) ? 0 : (\ _cvt = (sslen(_pa)),\ StdCodeCvt((PWSTR) _alloca((_cvt+1)*2), (_cvt+1)*2, \ _pa, _cvt, _acp))) #define SSW2A(pw) (\ ((_pw = pw) == 0) ? 0 : (\ _cvt = sslen(_pw), \ StdCodeCvt((LPSTR) _alloca((_cvt+1)*2), (_cvt+1)*2, \ _pw, _cvt, _acp))) #else #ifndef _DEBUG #define SSCVT int _cvt; _cvt; UINT _acp=CP_ACP; _acp;\ PCWSTR _pw; _pw; PCSTR _pa; _pa #else #define SSCVT int _cvt = 0; _cvt; UINT _acp=CP_ACP; \ _acp; PCWSTR _pw=0; _pw; PCSTR _pa=0; _pa #endif #define SSA2W(pa) (\ ((_pa = pa) == 0) ? 0 : (\ _cvt = (sslen(_pa)),\ StdCodeCvt((PWSTR) _alloca((_cvt+1)*2), (_cvt+1)*2, \ _pa, _cvt))) #define SSW2A(pw) (\ ((_pw = pw) == 0) ? 0 : (\ _cvt = (sslen(_pw)),\ StdCodeCvt((LPSTR) _alloca((_cvt+1)*2), (_cvt+1)*2, \ _pw, _cvt))) #endif #define SSA2CW(pa) ((PCWSTR)SSA2W((pa))) #define SSW2CA(pw) ((PCSTR)SSW2A((pw))) #ifdef UNICODE #define SST2A SSW2A #define SSA2T SSA2W #define SST2CA SSW2CA #define SSA2CT SSA2CW // (Did you get a compiler error here about not being able to convert // PTSTR into PWSTR? Then your _UNICODE and UNICODE flags are messed // up. Best bet: #define BOTH macros before including any MS headers.) inline PWSTR SST2W(PTSTR p) { return p; } inline PTSTR SSW2T(PWSTR p) { return p; } inline PCWSTR SST2CW(PCTSTR p) { return p; } inline PCTSTR SSW2CT(PCWSTR p) { return p; } #else #define SST2W SSA2W #define SSW2T SSW2A #define SST2CW SSA2CW #define SSW2CT SSW2CA inline PSTR SST2A(PTSTR p) { return p; } inline PTSTR SSA2T(PSTR p) { return p; } inline PCSTR SST2CA(PCTSTR p) { return p; } inline PCTSTR SSA2CT(PCSTR p) { return p; } #endif // #ifdef UNICODE #if defined(UNICODE) // in these cases the default (TCHAR) is the same as OLECHAR inline PCOLESTR SST2COLE(PCTSTR p) { return p; } inline PCTSTR SSOLE2CT(PCOLESTR p) { return p; } inline POLESTR SST2OLE(PTSTR p) { return p; } inline PTSTR SSOLE2T(POLESTR p) { return p; } #elif defined(OLE2ANSI) // in these cases the default (TCHAR) is the same as OLECHAR inline PCOLESTR SST2COLE(PCTSTR p) { return p; } inline PCTSTR SSOLE2CT(PCOLESTR p) { return p; } inline POLESTR SST2OLE(PTSTR p) { return p; } inline PTSTR SSOLE2T(POLESTR p) { return p; } #else //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)) #define SSOLE2T(po) SSW2A((po)) #endif #ifdef OLE2ANSI #define SSW2OLE SSW2A #define SSOLE2W SSA2W #define SSW2COLE SSW2CA #define SSOLE2CW SSA2CW inline POLESTR SSA2OLE(PSTR p) { return p; } inline PSTR SSOLE2A(POLESTR p) { return p; } inline PCOLESTR SSA2COLE(PCSTR p) { return p; } inline PCSTR SSOLE2CA(PCOLESTR p){ return p; } #else #define SSA2OLE SSA2W #define SSOLE2A SSW2A #define SSA2COLE SSA2CW #define SSOLE2CA SSW2CA inline POLESTR SSW2OLE(PWSTR p) { return p; } inline PWSTR SSOLE2W(POLESTR p) { return p; } inline PCOLESTR SSW2COLE(PCWSTR p) { return p; } inline PCWSTR SSOLE2CW(PCOLESTR p){ return p; } #endif // Above we've defined macros that look like MS' but all have // an 'SS' prefix. Now we need the real macros. We'll either // get them from the macros above or from MFC/ATL. #if defined (USES_CONVERSION) #define _NO_STDCONVERSION // just to be consistent #else #ifdef _MFC_VER #include #define _NO_STDCONVERSION // just to be consistent #else #define USES_CONVERSION SSCVT #define A2CW SSA2CW #define W2CA SSW2CA #define T2A SST2A #define A2T SSA2T #define T2W SST2W #define W2T SSW2T #define T2CA SST2CA #define A2CT SSA2CT #define T2CW SST2CW #define W2CT SSW2CT #define ocslen sslen #define ocscpy sscpy #define T2COLE SST2COLE #define OLE2CT SSOLE2CT #define T2OLE SST2COLE #define OLE2T SSOLE2CT #define A2OLE SSA2OLE #define OLE2A SSOLE2A #define W2OLE SSW2OLE #define OLE2W SSOLE2W #define A2COLE SSA2COLE #define OLE2CA SSOLE2CA #define W2COLE SSW2COLE #define OLE2CW SSOLE2CW #endif // #ifdef _MFC_VER #endif // #ifndef USES_CONVERSION #endif // #ifndef SS_NO_CONVERSION // Define ostring - generic name for std::basic_string #if !defined(ostring) && !defined(OSTRING_DEFINED) typedef std::basic_string ostring; #define OSTRING_DEFINED #endif // StdCodeCvt when there's no conversion to be done template inline T* StdCodeCvt(T* pDst, int nDst, const T* pSrc, int nSrc) { int nChars = SSMIN(nSrc, nDst); if ( nChars > 0 ) { pDst[0] = '\0'; std::basic_string::traits_type::copy(pDst, pSrc, nChars); // std::char_traits::copy(pDst, pSrc, nChars); pDst[nChars] = '\0'; } return pDst; } inline PSTR StdCodeCvt(PSTR pDst, int nDst, PCUSTR pSrc, int nSrc) { return StdCodeCvt(pDst, nDst, (PCSTR)pSrc, nSrc); } inline PUSTR StdCodeCvt(PUSTR pDst, int nDst, PCSTR pSrc, int nSrc) { return (PUSTR)StdCodeCvt((PSTR)pDst, nDst, pSrc, nSrc); } // Define tstring -- generic name for std::basic_string #if !defined(tstring) && !defined(TSTRING_DEFINED) typedef std::basic_string tstring; #define TSTRING_DEFINED #endif // a very shorthand way of applying the fix for KB problem Q172398 // (basic_string assignment bug) #if defined ( _MSC_VER ) && ( _MSC_VER < 1200 ) #define Q172398(x) (x).erase() #else #define Q172398(x) #endif // ============================================================================= // INLINE FUNCTIONS ON WHICH CSTDSTRING RELIES // // Usually for generic text mapping, we rely on preprocessor macro definitions // to map to string functions. However the CStdStr<> template cannot use // macro-based generic text mappings because its character types do not get // resolved until template processing which comes AFTER macro processing. In // other words, the preprocessor macro UNICODE is of little help to us in the // CStdStr template // // 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. // ============================================================================= #ifdef SS_NO_LOCALE // -------------------------------------------------------------------------- // Win32 GetStringTypeEx wrappers // -------------------------------------------------------------------------- inline bool wsGetStringType(LCID lc, DWORD dwT, PCSTR pS, int nSize, WORD* pWd) { return FALSE != GetStringTypeExA(lc, dwT, pS, nSize, pWd); } inline bool wsGetStringType(LCID lc, DWORD dwT, PCWSTR pS, int nSize, WORD* pWd) { return FALSE != GetStringTypeExW(lc, dwT, pS, nSize, pWd); } template inline bool ssisspace (CT t) { WORD toYourMother; return wsGetStringType(GetThreadLocale(), CT_CTYPE1, &t, 1, &toYourMother) && 0 != (C1_BLANK & toYourMother); } #endif // If they defined SS_NO_REFCOUNT, then we must convert all assignments #if defined (_MSC_VER) && (_MSC_VER < 1300) #ifdef SS_NO_REFCOUNT #define SSREF(x) (x).c_str() #else #define SSREF(x) (x) #endif #else #define SSREF(x) (x) #endif // ----------------------------------------------------------------------------- // sslen: strlen/wcslen wrappers // ----------------------------------------------------------------------------- template inline int sslen(const CT* pT) { return 0 == pT ? 0 : (int)std::basic_string::traits_type::length(pT); // return 0 == pT ? 0 : std::char_traits::length(pT); } inline SS_NOTHROW int sslen(const std::string& s) { return static_cast(s.length()); } inline SS_NOTHROW int sslen(const std::wstring& s) { return static_cast(s.length()); } // ----------------------------------------------------------------------------- // sstolower/sstoupper -- convert characters to upper/lower case // ----------------------------------------------------------------------------- #ifdef SS_NO_LOCALE inline char sstoupper(char ch) { return (char)::toupper(ch); } inline wchar_t sstoupper(wchar_t ch){ return (wchar_t)::towupper(ch); } inline char sstolower(char ch) { return (char)::tolower(ch); } inline wchar_t sstolower(wchar_t ch){ return (wchar_t)::tolower(ch); } #else template inline CT sstolower(const CT& t, const std::locale& loc = std::locale()) { return std::tolower(t, loc); } template inline CT sstoupper(const CT& t, const std::locale& loc = std::locale()) { return std::toupper(t, loc); } #endif // ----------------------------------------------------------------------------- // ssasn: assignment functions -- assign "sSrc" to "sDst" // ----------------------------------------------------------------------------- typedef std::string::size_type SS_SIZETYPE; // just for shorthand, really typedef std::string::pointer SS_PTRTYPE; typedef std::wstring::size_type SW_SIZETYPE; typedef std::wstring::pointer SW_PTRTYPE; template inline void ssasn(std::basic_string& sDst, const std::basic_string& sSrc) { if ( sDst.c_str() != sSrc.c_str() ) { sDst.erase(); sDst.assign(SSREF(sSrc)); } } template inline void ssasn(std::basic_string& sDst, const T *pA) { // Watch out for NULLs, as always. if ( 0 == pA ) { sDst.erase(); } // If pA actually points to part of sDst, we must NOT erase(), but // rather take a substring else if ( pA >= sDst.c_str() && pA <= sDst.c_str() + sDst.size() ) { sDst =sDst.substr(static_cast::size_type>(pA-sDst.c_str())); } // Otherwise (most cases) apply the assignment bug fix, if applicable // and do the assignment else { Q172398(sDst); sDst.assign(pA); } } inline void ssasn(std::string& sDst, const std::wstring& sSrc) { if ( sSrc.empty() ) { sDst.erase(); } else { int nDst = static_cast(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 // In MBCS builds, we don't know how long the destination string will be. nDst = static_cast(static_cast(nDst) * 1.3); sDst.resize(nDst+1); PCSTR szCvt = StdCodeCvt(const_cast(sDst.data()), nDst, sSrc.c_str(), static_cast(sSrc.size())); sDst.resize(sslen(szCvt)); #else sDst.resize(nDst+1); StdCodeCvt(const_cast(sDst.data()), nDst, sSrc.c_str(), static_cast(sSrc.size())); sDst.resize(sSrc.size()); #endif } } inline void ssasn(std::string& sDst, PCWSTR pW) { int nSrc = sslen(pW); if ( nSrc > 0 ) { int nSrc = sslen(pW); int nDst = nSrc; // 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(static_cast(nDst) * 1.3); // In MBCS builds, we don't know how long the destination string will be. sDst.resize(nDst + 1); PCSTR szCvt = StdCodeCvt(const_cast(sDst.data()), nDst, pW, nSrc); sDst.resize(sslen(szCvt)); #else sDst.resize(nDst + 1); StdCodeCvt(const_cast(sDst.data()), nDst, pW, nSrc); sDst.resize(nDst); #endif } else { sDst.erase(); } } inline void ssasn(std::string& sDst, const int nNull) { //UNUSED(nNull); ASSERT(nNull==0); sDst.assign(""); } #undef StrSizeType inline void ssasn(std::wstring& sDst, const std::string& sSrc) { if ( sSrc.empty() ) { sDst.erase(); } else { int nSrc = static_cast(sSrc.size()); int nDst = nSrc; sDst.resize(nSrc+1); PCWSTR szCvt = StdCodeCvt(const_cast(sDst.data()), nDst, sSrc.c_str(), nSrc); sDst.resize(sslen(szCvt)); } } inline void ssasn(std::wstring& sDst, PCSTR pA) { int nSrc = sslen(pA); if ( 0 == nSrc ) { sDst.erase(); } else { int nDst = nSrc; sDst.resize(nDst+1); PCWSTR szCvt = StdCodeCvt(const_cast(sDst.data()), nDst, pA, nSrc); sDst.resize(sslen(szCvt)); } } inline void ssasn(std::wstring& sDst, const int nNull) { //UNUSED(nNull); ASSERT(nNull==0); sDst.assign(L""); } // ----------------------------------------------------------------------------- // ssadd: string object concatenation -- add second argument to first // ----------------------------------------------------------------------------- inline void ssadd(std::string& sDst, const std::wstring& sSrc) { int nSrc = static_cast(sSrc.size()); if ( nSrc > 0 ) { int nDst = static_cast(sDst.size()); int nAdd = nSrc; // 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 nAdd = static_cast(static_cast(nAdd) * 1.3); sDst.resize(nDst+nAdd+1); PCSTR szCvt = StdCodeCvt(const_cast(sDst.data()+nDst), nAdd, sSrc.c_str(), nSrc); sDst.resize(nDst + sslen(szCvt)); #else sDst.resize(nDst+nAdd+1); StdCodeCvt(const_cast(sDst.data()+nDst), nAdd, sSrc.c_str(), nSrc); sDst.resize(nDst + nAdd); #endif } } template inline void ssadd(typename std::basic_string& sDst, const typename std::basic_string& sSrc) { sDst += sSrc; } inline void ssadd(std::string& sDst, PCWSTR pW) { int nSrc = sslen(pW); if ( nSrc > 0 ) { int nDst = static_cast(sDst.size()); int nAdd = nSrc; #ifdef SS_MBCS nAdd = static_cast(static_cast(nAdd) * 1.3); sDst.resize(nDst + nAdd + 1); PCSTR szCvt = StdCodeCvt(const_cast(sDst.data()+nDst), nAdd, pW, nSrc); sDst.resize(nDst + sslen(szCvt)); #else sDst.resize(nDst + nAdd + 1); StdCodeCvt(const_cast(sDst.data()+nDst), nAdd, pW, nSrc); sDst.resize(nDst + nSrc); #endif } } template inline void ssadd(typename std::basic_string& sDst, const T *pA) { if ( pA ) { // If the string being added is our internal string or a part of our // internal string, then we must NOT do any reallocation without // first copying that string to another object (since we're using a // direct pointer) if ( pA >= sDst.c_str() && pA <= sDst.c_str()+sDst.length()) { if ( sDst.capacity() <= sDst.size()+sslen(pA) ) sDst.append(std::basic_string(pA)); else sDst.append(pA); } else { sDst.append(pA); } } } inline void ssadd(std::wstring& sDst, const std::string& sSrc) { if ( !sSrc.empty() ) { int nSrc = static_cast(sSrc.size()); int nDst = static_cast(sDst.size()); sDst.resize(nDst + nSrc + 1); #ifdef SS_MBCS PCWSTR szCvt = StdCodeCvt(const_cast(sDst.data()+nDst), nSrc, sSrc.c_str(), nSrc+1); sDst.resize(nDst + sslen(szCvt)); #else StdCodeCvt(const_cast(sDst.data()+nDst), nSrc, sSrc.c_str(), nSrc+1); sDst.resize(nDst + nSrc); #endif } } inline void ssadd(std::wstring& sDst, PCSTR pA) { int nSrc = sslen(pA); if ( nSrc > 0 ) { int nDst = static_cast(sDst.size()); sDst.resize(nDst + nSrc + 1); #ifdef SS_MBCS PCWSTR szCvt = StdCodeCvt(const_cast(sDst.data()+nDst), nSrc, pA, nSrc+1); sDst.resize(nDst + sslen(szCvt)); #else StdCodeCvt(const_cast(sDst.data()+nDst), nSrc, pA, nSrc+1); sDst.resize(nDst + nSrc); #endif } } // ----------------------------------------------------------------------------- // sscmp: comparison (case sensitive, not affected by locale) // ----------------------------------------------------------------------------- template inline int sscmp(const CT* pA1, const CT* pA2) { CT f; CT l; do { f = *(pA1++); l = *(pA2++); } while ( (f) && (f == l) ); return (int)(f - l); } // ----------------------------------------------------------------------------- // ssicmp: comparison (case INsensitive, not affected by locale) // ----------------------------------------------------------------------------- template inline int ssicmp(const CT* pA1, const CT* pA2) { // Using the "C" locale = "not affected by locale" std::locale loc = std::locale::classic(); const std::ctype& ct = SS_USE_FACET(loc, std::ctype); CT f; CT l; do { f = ct.tolower(*(pA1++)); l = ct.tolower(*(pA2++)); } while ( (f) && (f == l) ); return (int)(f - l); } // ----------------------------------------------------------------------------- // ssupr/sslwr: Uppercase/Lowercase conversion functions // ----------------------------------------------------------------------------- template inline void sslwr(CT* pT, size_t nLen, const std::locale& loc=std::locale()) { SS_USE_FACET(loc, std::ctype).tolower(pT, pT+nLen); } template inline void ssupr(CT* pT, size_t nLen, const std::locale& loc=std::locale()) { SS_USE_FACET(loc, std::ctype).toupper(pT, pT+nLen); } // ----------------------------------------------------------------------------- // vsprintf/vswprintf or _vsnprintf/_vsnwprintf equivalents. In standard // 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__) using std::vsprintf; using std::vswprintf; #endif // GNU is supposed to have vsnprintf and vsnwprintf. But only the newer // distributions do. #if defined(__GNUC__) inline int ssvsprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl) { return vsnprintf(pA, nCount, pFmtA, vl); } inline int ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { return vswprintf(pW, nCount, pFmtW, vl); } // Microsofties can use #elif defined(_MSC_VER) && !defined(SS_ANSI) inline int ssvsprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl) { return _vsnprintf(pA, nCount, pFmtA, vl); } inline int ssvsprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { return _vsnwprintf(pW, nCount, pFmtW, vl); } #elif defined (SS_DANGEROUS_FORMAT) // ignore buffer size parameter if needed? inline int ssvsprintf(PSTR pA, size_t /*nCount*/, PCSTR pFmtA, va_list vl) { return vsprintf(pA, pFmtA, vl); } 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 // have the version that takes 4 arguments. // // I'm sure that these checks don't catch every platform correctly so if // you get compiler errors on one of the lines immediately below, it's // probably because your implemntation takes a different number of // arguments. You can comment out the offending line (and use the // alternate version) or you can figure out what compiler flag to check // and add that preprocessor check in. Regardless, if you get an error // on these lines, I'd sure like to hear from you about it. // // Thanks to Ronny Schulz for the SGI-specific checks here. // #if !defined(__MWERKS__) && !defined(__SUNPRO_CC_COMPAT) && !defined(__SUNPRO_CC) #if !defined(_MSC_VER) \ && !defined (__BORLANDC__) \ && !defined(__GNUC__) \ && !defined(__sgi) return vswprintf(pW, nCount, pFmtW, vl); // suddenly with the current SGI 7.3 compiler there is no such function as // vswprintf and the substitute needs explicit casts to compile #elif defined(__sgi) nCount; return vsprintf( (char *)pW, (char *)pFmtW, vl); #else nCount; return vswprintf(pW, pFmtW, vl); #endif } #endif // GOT COMPILER PROBLEMS HERE? // --------------------------- // 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 // 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 // this code build, you're going to have to to use some non-length-checked // formatting functions that every CRT has: vsprintf and vswprintf. // // 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 // In order to use them, just #define SS_DANGEROUS_FORMAT at the top of // this file. // // Even THEN you might not be all the way home due to some non-conforming // distributions. More on this in the comments below. inline int ssnprintf(PSTR pA, size_t nCount, PCSTR pFmtA, va_list vl) { #ifdef _MSC_VER return _vsnprintf(pA, nCount, pFmtA, vl); #else return vsnprintf(pA, nCount, pFmtA, vl); #endif } inline int ssnprintf(PWSTR pW, size_t nCount, PCWSTR pFmtW, va_list vl) { #ifdef _MSC_VER return _vsnwprintf(pW, nCount, pFmtW, vl); #else return vswprintf(pW, nCount, pFmtW, vl); #endif } // ----------------------------------------------------------------------------- // ssload: Type safe, overloaded ::LoadString wrappers // There is no equivalent of these in non-Win32-specific builds. However, I'm // thinking that with the message facet, there might eventually be one // ----------------------------------------------------------------------------- #if defined (SS_WIN32) && !defined(SS_ANSI) inline int ssload(HMODULE hInst, UINT uId, PSTR pBuf, int nMax) { return ::LoadStringA(hInst, uId, pBuf, nMax); } inline int ssload(HMODULE hInst, UINT uId, PWSTR pBuf, int nMax) { return ::LoadStringW(hInst, uId, pBuf, nMax); } #if defined ( _MSC_VER ) && ( _MSC_VER >= 1500 ) inline int ssload(HMODULE hInst, UINT uId, uint16_t *pBuf, int nMax) { return 0; } inline int ssload(HMODULE hInst, UINT uId, uint32_t *pBuf, int nMax) { return 0; } #endif #endif // ----------------------------------------------------------------------------- // sscoll/ssicoll: Collation wrappers // Note -- with MSVC I have reversed the arguments order here because the // functions appear to return the opposite of what they should // ----------------------------------------------------------------------------- #ifndef SS_NO_LOCALE template inline int sscoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2) { const std::collate& coll = SS_USE_FACET(std::locale(), std::collate); return coll.compare(sz2, sz2+nLen2, sz1, sz1+nLen1); } template inline int ssicoll(const CT* sz1, int nLen1, const CT* sz2, int nLen2) { const std::locale loc; const std::collate& coll = SS_USE_FACET(loc, std::collate); // Some implementations seem to have trouble using the collate<> // 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::string_type s1(sz1); // std::collate::string_type s2(sz2); const std::basic_string sEmpty; std::basic_string s1(sz1 ? sz1 : sEmpty.c_str()); std::basic_string s2(sz2 ? sz2 : sEmpty.c_str()); sslwr(const_cast(s1.c_str()), nLen1, loc); sslwr(const_cast(s2.c_str()), nLen2, loc); return coll.compare(s2.c_str(), s2.c_str()+nLen2, s1.c_str(), s1.c_str()+nLen1); } #endif // ----------------------------------------------------------------------------- // ssfmtmsg: FormatMessage equivalents. Needed because I added a CString facade // Again -- no equivalent of these on non-Win32 builds but their might one day // be one if the message facet gets implemented // ----------------------------------------------------------------------------- #if defined (SS_WIN32) && !defined(SS_ANSI) inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId, DWORD dwLangId, PSTR pBuf, DWORD nSize, va_list* vlArgs) { return FormatMessageA(dwFlags, pSrc, dwMsgId, dwLangId, pBuf, nSize,vlArgs); } inline DWORD ssfmtmsg(DWORD dwFlags, LPCVOID pSrc, DWORD dwMsgId, DWORD dwLangId, PWSTR pBuf, DWORD nSize, va_list* vlArgs) { return FormatMessageW(dwFlags, pSrc, dwMsgId, dwLangId, pBuf, nSize,vlArgs); } #else #endif // FUNCTION: sscpy. Copies up to 'nMax' characters from pSrc to pDst. // ----------------------------------------------------------------------------- // FUNCTION: sscpy // inline int sscpy(PSTR pDst, PCSTR pSrc, int nMax=-1); // inline int sscpy(PUSTR pDst, PCSTR pSrc, int nMax=-1) // inline int sscpy(PSTR pDst, PCWSTR pSrc, int nMax=-1); // inline int sscpy(PWSTR pDst, PCWSTR pSrc, int nMax=-1); // inline int sscpy(PWSTR pDst, PCSTR pSrc, int nMax=-1); // // DESCRIPTION: // This function is very much (but not exactly) like strcpy. These // overloads simplify copying one C-style string into another by allowing // the caller to specify two different types of strings if necessary. // // The strings must NOT overlap // // "Character" is expressed in terms of the destination string, not // the source. If no 'nMax' argument is supplied, then the number of // characters copied will be sslen(pSrc). A NULL terminator will // also be added so pDst must actually be big enough to hold nMax+1 // 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 // nMax - the maximum number of characters to be copied into szDest. Note // that this is expressed in whatever a "character" means to pDst. // If pDst is a wchar_t type string than this will be the maximum // number of wchar_ts that my be copied. The pDst string must be // large enough to hold least nMaxChars+1 characters. // If the caller supplies no argument for nMax this is a signal to // the routine to copy all the characters in pSrc, regardless of // how long it is. // // RETURN VALUE: none // ----------------------------------------------------------------------------- template 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. int nSrc = sslen(pSrc); const CT1* szCvt = StdCodeCvt(pDst, nMax, pSrc, nSrc); // If we're copying the same size characters, then all the "code convert" // just did was basically memcpy so the #of characters copied is the same // as the number requested. I should probably specialize this function // template to achieve this purpose as it is silly to do a runtime check // of a fact known at compile time. I'll get around to it. return sslen(szCvt); } template inline int sscpycvt(T* pDst, const T* pSrc, int nMax) { int nCount = nMax; for (; nCount > 0 && *pSrc; ++pSrc, ++pDst, --nCount) std::basic_string::traits_type::assign(*pDst, *pSrc); *pDst = 0; return nMax - nCount; } inline int sscpycvt(PWSTR pDst, PCSTR 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. const PWSTR szCvt = StdCodeCvt(pDst, nMax, pSrc, nMax); return sslen(szCvt); } template inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax, int nLen) { return sscpycvt(pDst, pSrc, SSMIN(nMax, nLen)); } template inline int sscpy(CT1* pDst, const CT2* pSrc, int nMax) { return sscpycvt(pDst, pSrc, SSMIN(nMax, sslen(pSrc))); } template inline int sscpy(CT1* pDst, const CT2* pSrc) { return sscpycvt(pDst, pSrc, sslen(pSrc)); } template inline int sscpy(CT1* pDst, const std::basic_string& sSrc, int nMax) { return sscpycvt(pDst, sSrc.c_str(), SSMIN(nMax, (int)sSrc.length())); } template inline int sscpy(CT1* pDst, const std::basic_string& sSrc) { return sscpycvt(pDst, sSrc.c_str(), (int)sSrc.length()); } #ifdef SS_INC_COMDEF template inline int sscpy(CT1* pDst, const _bstr_t& bs, int nMax) { return sscpycvt(pDst, static_cast(bs), SSMIN(nMax, static_cast(bs.length()))); } template inline int sscpy(CT1* pDst, const _bstr_t& bs) { return sscpy(pDst, bs, static_cast(bs.length())); } #endif // ----------------------------------------------------------------------------- // Functional objects for changing case. They also let you pass locales // ----------------------------------------------------------------------------- #ifdef SS_NO_LOCALE template struct SSToUpper : public std::unary_function { inline CT operator()(const CT& t) const { return sstoupper(t); } }; template struct SSToLower : public std::unary_function { inline CT operator()(const CT& t) const { return sstolower(t); } }; #else template struct SSToUpper : public std::binary_function { inline CT operator()(const CT& t, const std::locale& loc) const { return sstoupper(t, loc); } }; template struct SSToLower : public std::binary_function { inline CT operator()(const CT& t, const std::locale& loc) const { return sstolower(t, loc); } }; #endif // This struct is used for TrimRight() and TrimLeft() function implementations. //template //struct NotSpace : public std::unary_function //{ // const std::locale& loc; // inline NotSpace(const std::locale& locArg) : loc(locArg) {} // inline bool operator() (CT t) { return !std::isspace(t, loc); } //}; template struct NotSpace : public std::unary_function { // DINKUMWARE BUG: // Note -- using std::isspace in a COM DLL gives us access violations // because it causes the dynamic addition of a function to be called // when the library shuts down. Unfortunately the list is maintained // in DLL memory but the function is in static memory. So the COM DLL // goes away along with the function that was supposed to be called, // and then later when the DLL CRT shuts down it unloads the list and // tries to call the long-gone function. // This is DinkumWare's implementation problem. If you encounter this // problem, you may replace the calls here with good old isspace() and // iswspace() from the CRT unless they specify SS_ANSI #ifdef SS_NO_LOCALE bool operator() (CT t) const { return !ssisspace(t); } #else const std::locale loc; NotSpace(const std::locale& locArg=std::locale()) : loc(locArg) {} bool operator() (CT t) const { return !std::isspace(t, loc); } #endif }; // Now we can define the template (finally!) // ============================================================================= // TEMPLATE: CStdStr // template class CStdStr : public std::basic_string // // REMARKS: // This template derives from basic_string and adds some MFC CString- // like functionality // // Basically, this is my attempt to make Standard C++ library strings as // 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 // template ARG& FmtArg(ARG& arg) { return arg; } // PCSTR FmtArg(const std::string& arg) { return arg.c_str(); } // PCWSTR FmtArg(const std::wstring& arg) { return arg.c_str(); } template struct FmtArg { explicit FmtArg(const ARG& arg) : a_(arg) {} const ARG& operator()() const { return a_; } const ARG& a_; private: FmtArg& operator=(const FmtArg&) { return *this; } }; template class CStdStr : public std::basic_string { // 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 // my base class //typedef typename std::basic_string MYBASE; // my base class typedef CStdStr MYTYPE; // myself typedef typename MYBASE::const_pointer PCMYSTR; // PCSTR or PCWSTR typedef typename MYBASE::pointer PMYSTR; // PSTR or PWSTR typedef typename MYBASE::iterator MYITER; // my iterator type typedef typename MYBASE::const_iterator MYCITER; // you get the idea... typedef typename MYBASE::reverse_iterator MYRITER; typedef typename MYBASE::size_type MYSIZE; typedef typename MYBASE::value_type MYVAL; typedef typename MYBASE::allocator_type MYALLOC; public: // shorthand conversion from PCTSTR to string resource ID #define SSRES(pctstr) LOWORD(reinterpret_cast(pctstr)) bool TryLoad(const void* pT) { bool bLoaded = false; #if defined(SS_WIN32) && !defined(SS_ANSI) if ( ( pT != NULL ) && SS_IS_INTRESOURCE(pT) ) { UINT nId = LOWORD(reinterpret_cast(pT)); if ( !LoadString(nId) ) { TRACE(_T("Can't load string %u\n"), SSRES(pT)); } bLoaded = true; } #endif return bLoaded; } // CStdStr inline constructors CStdStr() { } CStdStr(const MYTYPE& str) : MYBASE(SSREF(str)) { } CStdStr(const std::string& str) { ssasn(*this, SSREF(str)); } CStdStr(const std::wstring& str) { ssasn(*this, SSREF(str)); } CStdStr(PCMYSTR pT, MYSIZE n) : MYBASE(pT, n) { } CStdStr(PCSTR pA) { #ifdef SS_ANSI *this = pA; #else if ( !TryLoad(pA) ) *this = pA; #endif } CStdStr(PCWSTR pW) { #ifdef SS_ANSI *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()) : MYBASE(nSize, ch, al) { } #ifdef SS_INC_COMDEF CStdStr(const _bstr_t& bstr) { if ( bstr.length() > 0 ) this->append(static_cast(bstr), bstr.length()); } #endif // CStdStr inline assignment operators -- the ssasn function now takes care // of fixing the MSVC assignment bug (see knowledge base article Q172398). MYTYPE& operator=(const MYTYPE& str) { ssasn(*this, str); return *this; } MYTYPE& operator=(const std::string& str) { ssasn(*this, str); return *this; } MYTYPE& operator=(const std::wstring& str) { ssasn(*this, str); return *this; } MYTYPE& operator=(PCSTR pA) { ssasn(*this, pA); return *this; } MYTYPE& operator=(PCWSTR pW) { ssasn(*this, pW); return *this; } // Overloads also needed to fix the MSVC assignment bug (KB: Q172398) // *** Thanks to Pete The Plumber for catching this one *** // 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) { Q172398(*this); sscpy(GetBuffer(str.size()+1), SSREF(str)); 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 // or the NULL terminator, whichever comes first. Since we // are about to call a less forgiving overload (in which // 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 // or the NULL terminator, whichever comes first. Since we // are about to call a less forgiving overload (in which // 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(this)->assign(strTemp); } else { Q172398(*this); static_cast(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); static_cast(this)->assign(pC, nChars); return *this; } MYTYPE& assign(MYSIZE nChars, MYVAL val) { Q172398(*this); static_cast(this)->assign(nChars, val); return *this; } MYTYPE& assign(const CT* pT) { return this->assign(pT, MYBASE::traits_type::length(pT)); } 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 if ( iterFirst < this->begin() || iterFirst > this->begin() + this->size() ) { this->erase() } #endif this->replace(this->begin(), this->end(), iterFirst, iterLast); return *this; } #endif // ------------------------------------------------------------------------- // CStdStr inline concatenation. // ------------------------------------------------------------------------- MYTYPE& operator+=(const MYTYPE& str) { ssadd(*this, str); return *this; } MYTYPE& operator+=(const std::string& str) { ssadd(*this, str); return *this; } MYTYPE& operator+=(const std::wstring& str) { ssadd(*this, str); return *this; } MYTYPE& operator+=(PCSTR pA) { ssadd(*this, pA); return *this; } MYTYPE& operator+=(PCWSTR pW) { ssadd(*this, pW); return *this; } MYTYPE& operator+=(CT t) { this->append(1, t); return *this; } // ------------------------------------------------------------------------- // 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(this->size()) < nMinLen ) this->resize(static_cast(nMinLen)); return this->empty() ? const_cast(this->data()) : &(this->at(0)); } CT* SetBuf(int nLen) { nLen = ( nLen > 0 ? nLen : 0 ); if ( this->capacity() < 1 && nLen == 0 ) this->resize(1); this->resize(static_cast(nLen)); return const_cast(this->data()); } void RelBuf(int nNewLen=-1) { this->resize(static_cast(nNewLen > -1 ? nNewLen : sslen(this->c_str()))); } void BufferRel() { RelBuf(); } // backwards compatability CT* Buffer() { return GetBuf(); } // backwards compatability CT* BufferSet(int nLen) { return SetBuf(nLen);}// backwards compatability bool Equals(const CT* pT, bool bUseCase=false) const { return 0 == (bUseCase ? this->compare(pT) : ssicmp(this->c_str(), pT)); } // ------------------------------------------------------------------------- // 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 // ------------------------------------------------------------------------- #ifndef SS_ANSI bool Load(UINT nId, HMODULE hModule=NULL) { bool bLoaded = false; // set to true of we succeed. #ifdef _MFC_VER // When in Rome (or MFC land)... // If they gave a resource handle, use it. Note - this is archaic // and not really what I would recommend. But then again, in MFC // 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 CString strRes; bLoaded = FALSE != strRes.LoadString(nId); // ...and if we set the resource handle, restore it. if ( NULL != hModuleOld ) AfxSetResourceHandle(hModule); if ( bLoaded ) *this = strRes; #else // otherwise make our own hackneyed version of CString's Load // Get the resource name and module handle if ( NULL == hModule ) hModule = GetResourceHandle(); PCTSTR szName = MAKEINTRESOURCE((nId>>4)+1); // lifted DWORD dwSize = 0; // No sense continuing if we can't find the resource HRSRC hrsrc = ::FindResource(hModule, szName, RT_STRING); if ( NULL == hrsrc ) { TRACE(_T("Cannot find resource %d: 0x%X"), nId, ::GetLastError()); } else if ( 0 == (dwSize = ::SizeofResource(hModule, hrsrc) / sizeof(CT))) { TRACE(_T("Cant get size of resource %d 0x%X\n"),nId,GetLastError()); } else { bLoaded = 0 != ssload(hModule, nId, GetBuf(dwSize), dwSize); ReleaseBuffer(); } #endif // #ifdef _MFC_VER if ( !bLoaded ) TRACE(_T("String not loaded 0x%X\n"), ::GetLastError()); return bLoaded; } #endif // #ifdef SS_ANSI // ------------------------------------------------------------------------- // CString Facade Functions: // // 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 { ostring os; ssasn(os, *this); return ::SysAllocString(os.c_str()); } #endif #ifndef SS_NO_LOCALE int Collate(PCMYSTR szThat) const { return sscoll(this->c_str(), this->length(), szThat, sslen(szThat)); } int CollateNoCase(PCMYSTR szThat) const { return ssicoll(this->c_str(), this->length(), szThat, sslen(szThat)); } #endif int FindOneOf(PCMYSTR szCharSet) const { MYSIZE nIdx = this->find_first_of(szCharSet); return static_cast(MYBASE::npos == nIdx ? -1 : nIdx); } #ifndef SS_ANSI void FormatMessage(PCMYSTR szFormat, ...) throw(std::exception) { va_list argList; va_start(argList, szFormat); PMYSTR szTemp; if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, szFormat, 0, 0, reinterpret_cast(&szTemp), 0, &argList) == 0 || szTemp == 0 ) { throw std::runtime_error("out of memory"); } *this = szTemp; LocalFree(szTemp); va_end(argList); } void FormatMessage(UINT nFormatId, ...) throw(std::exception) { MYTYPE sFormat; VERIFY(sFormat.LoadString(nFormatId)); va_list argList; va_start(argList, nFormatId); PMYSTR szTemp; if ( ssfmtmsg(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, sFormat, 0, 0, reinterpret_cast(&szTemp), 0, &argList) == 0 || szTemp == 0) { throw std::runtime_error("out of memory"); } *this = szTemp; LocalFree(szTemp); va_end(argList); } #endif // GetAllocLength -- an MSVC7 function but it costs us nothing to add it. int GetAllocLength() { return static_cast(this->capacity()); } // ------------------------------------------------------------------------- // GetXXXX -- Direct access to character buffer // ------------------------------------------------------------------------- CT* GetBuffer(int nMinLen=-1) { return GetBuf(nMinLen); } CT* GetBufferSetLength(int nLen) { return BufferSet(nLen); } #ifndef SS_ANSI bool LoadString(UINT nId) { return this->Load(nId); } #endif void MakeReverse() { std::reverse(this->begin(), this->end()); } void ReleaseBuffer(int nNewLen=-1) { RelBuf(nNewLen); } #ifndef SS_ANSI BSTR SetSysString(BSTR* pbstr) const { ostring os; ssasn(os, *this); if ( !::SysReAllocStringLen(pbstr, os.c_str(), os.length()) ) throw std::runtime_error("out of memory"); ASSERT(*pbstr != 0); return *pbstr; } #endif MYTYPE SpanExcluding(PCMYSTR szCharSet) const { MYSIZE pos = this->find_first_of(szCharSet); return pos == MYBASE::npos ? *this : Left(pos); } MYTYPE SpanIncluding(PCMYSTR szCharSet) const { MYSIZE pos = this->find_first_not_of(szCharSet); 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 // 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 // that CStdStringW gets instantiated even in non-Unicode builds. void AnsiToOem() { if ( sizeof(CT) == sizeof(char) && !empty() ) { ::CharToOem(reinterpret_cast(this->c_str()), reinterpret_cast(GetBuf())); } else { ASSERT(false); } } void OemToAnsi() { if ( sizeof(CT) == sizeof(char) && !empty() ) { ::OemToChar(reinterpret_cast(this->c_str()), reinterpret_cast(GetBuf())); } else { ASSERT(false); } } #endif void FreeExtra() { MYTYPE mt; this->swap(mt); if ( !mt.empty() ) this->assign(mt.c_str(), mt.size()); } // I have intentionally not implemented the following CString // functions. You cannot make them work without taking advantage // of implementation specific behavior. However if you absolutely // MUST have them, uncomment out these lines for "sort-of-like" // 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(this)->operator[](static_cast(nIdx)); } const CT& operator[](int nIdx) const { return static_cast(this)->operator[](static_cast(nIdx)); } CT& operator[](unsigned int nIdx) { return static_cast(this)->operator[](static_cast(nIdx)); } const CT& operator[](unsigned int nIdx) const { return static_cast(this)->operator[](static_cast(nIdx)); } CT& operator[](unsigned long nIdx) { return static_cast(this)->operator[](static_cast(nIdx)); } const CT& operator[](unsigned long nIdx) const { return static_cast(this)->operator[](static_cast(nIdx)); } #ifndef SS_NO_IMPLICIT_CAST operator const CT*() const { return this->c_str(); } #endif // IStream related functions. Useful in IPersistStream implementations #ifdef SS_INC_COMDEF // struct SSSHDR - useful for non Std C++ persistence schemes. typedef struct SSSHDR { BYTE byCtrl; ULONG nChars; } 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 // REMARKS: // Returns how many bytes it will take to StreamSave() this CStdString // object to an IStream. // ------------------------------------------------------------------------- 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 } 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: // This method loads the object from an IStream. // ------------------------------------------------------------------------- HRESULT StreamLoad(IStream* pStream) { ASSERT(pStream != 0); 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); } else if ( hdr.nChars > 0 ) { ULONG nRead = 0; PMYSTR pMyBuf = BufferSet(hdr.nChars); // If our character size matches the character size of the string // we're trying to read, then we can read it directly into our // buffer. Otherwise, we have to read into an intermediate buffer // and convert. if ( (hdr.byCtrl & SSSO_UNICODE) != 0 ) { ULONG nBytes = hdr.nChars * sizeof(wchar_t); if ( sizeof(CT) == sizeof(wchar_t) ) { if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); } else { PWSTR pBufW = reinterpret_cast(_alloca((nBytes)+1)); if ( FAILED(hr=pStream->Read(pBufW, nBytes, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); else sscpy(pMyBuf, pBufW, hdr.nChars); } } else { ULONG nBytes = hdr.nChars * sizeof(char); if ( sizeof(CT) == sizeof(char) ) { if ( FAILED(hr=pStream->Read(pMyBuf, nBytes, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); } else { PSTR pBufA = reinterpret_cast(_alloca(nBytes)); if ( FAILED(hr=pStream->Read(pBufA, hdr.nChars, &nRead)) ) TRACE(_T("StreamLoad: Cannot read string: 0x%X\n"), hr); else sscpy(pMyBuf, pBufA, hdr.nChars); } } } else { this->erase(); } return hr; } #endif // #ifdef SS_INC_COMDEF #ifndef SS_ANSI // SetResourceHandle/GetResourceHandle. In MFC builds, these map directly // to AfxSetResourceHandle and AfxGetResourceHandle. In non-MFC builds they // 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 // to search. This is not exactly the list of HMODULES that MFC provides // but it's better than nothing. #ifdef _MFC_VER static void SetResourceHandle(HMODULE hNew) { AfxSetResourceHandle(hNew); } static HMODULE GetResourceHandle() { return AfxGetResourceHandle(); } #else static void SetResourceHandle(HMODULE hNew) { SSResourceHandle() = hNew; } static HMODULE GetResourceHandle() { return SSResourceHandle(); } #endif #endif }; // ----------------------------------------------------------------------------- // MSVC USERS: HOW TO EXPORT CSTDSTRING FROM A DLL // // If you are using MS Visual C++ and you want to export CStdStringA and // CStdStringW from a DLL, then all you need to // // 1. make sure that all components link to the same DLL version // of the CRT (not the static one). // 2. Uncomment the 3 lines of code below // 3. #define 2 macros per the instructions in MS KnowledgeBase // article Q168958. The macros are: // // MACRO DEFINTION WHEN EXPORTING DEFINITION WHEN IMPORTING // ----- ------------------------ ------------------------- // 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. // // Really, it is not necessary to export CStdString functions from a DLL. I // never do. In my projects, I do generally link to the DLL version of the // Standard C++ Library, but I do NOT attempt to export CStdString functions. // I simply include the header where it is needed and allow for the code // redundancy. // // That redundancy is a lot less than you think. This class does most of its // work via the Standard C++ Library, particularly the base_class basic_string<> // member functions. Most of the functions here are small enough to be inlined // anyway. Besides, you'll find that in actual practice you use less than 1/2 // of the code here, even in big projects and different modules will use as // little as 10% of it. That means a lot less functions actually get linked // your binaries. If you export this code from a DLL, it ALL gets linked in. // // I've compared the size of the binaries from exporting vs NOT exporting. Take // my word for it -- exporting this code is not worth the hassle. // // ----------------------------------------------------------------------------- //#pragma warning(disable:4231) // non-standard extension ("extern template") // SSDLLEXP template class SSDLLSPEC CStdStr; // SSDLLEXP template class SSDLLSPEC CStdStr; // ============================================================================= // END OF CStdStr INLINE FUNCTION DEFINITIONS // ============================================================================= // Now typedef our class names based upon this humongous template typedef CStdStr CStdStringA; // a better std::string typedef CStdStr CStdStringW; // a better std::wstring typedef CStdStr CStdString16; // a 16bit char string typedef CStdStr CStdString32; // a 32bit char string typedef CStdStr CStdStringO; // almost always CStdStringW // ----------------------------------------------------------------------------- // CStdStr addition functions defined as inline // ----------------------------------------------------------------------------- inline CStdStringA operator+(const CStdStringA& s1, const CStdStringA& s2) { CStdStringA sRet(SSREF(s1)); sRet.append(s2); return sRet; } inline CStdStringA operator+(const CStdStringA& s1, CStdStringA::value_type t) { CStdStringA sRet(SSREF(s1)); sRet.append(1, t); return sRet; } inline CStdStringA operator+(const CStdStringA& s1, PCSTR pA) { CStdStringA sRet(SSREF(s1)); sRet.append(pA); return sRet; } inline CStdStringA operator+(PCSTR pA, const CStdStringA& sA) { CStdStringA sRet; CStdStringA::size_type nObjSize = sA.size(); CStdStringA::size_type nLitSize = static_cast(sslen(pA)); sRet.reserve(nLitSize + nObjSize); sRet.assign(pA); sRet.append(sA); return sRet; } inline CStdStringA operator+(const CStdStringA& s1, const CStdStringW& s2) { return s1 + CStdStringA(s2); } inline CStdStringW operator+(const CStdStringW& s1, const CStdStringW& s2) { CStdStringW sRet(SSREF(s1)); sRet.append(s2); return sRet; } inline CStdStringA operator+(const CStdStringA& s1, PCWSTR pW) { return s1 + CStdStringA(pW); } #ifdef UNICODE inline CStdStringW operator+(PCWSTR pW, const CStdStringA& sA) { return CStdStringW(pW) + CStdStringW(SSREF(sA)); } inline CStdStringW operator+(PCSTR pA, const CStdStringW& sW) { return CStdStringW(pA) + sW; } #else inline CStdStringA operator+(PCWSTR pW, const CStdStringA& sA) { return CStdStringA(pW) + sA; } inline CStdStringA operator+(PCSTR pA, const CStdStringW& sW) { return pA + CStdStringA(sW); } #endif // ...Now the wide string versions. inline CStdStringW operator+(const CStdStringW& s1, CStdStringW::value_type t) { CStdStringW sRet(SSREF(s1)); sRet.append(1, t); return sRet; } inline CStdStringW operator+(const CStdStringW& s1, PCWSTR pW) { CStdStringW sRet(SSREF(s1)); sRet.append(pW); return sRet; } inline CStdStringW operator+(PCWSTR pW, const CStdStringW& sW) { CStdStringW sRet; CStdStringW::size_type nObjSize = sW.size(); CStdStringA::size_type nLitSize = static_cast(sslen(pW)); sRet.reserve(nLitSize + nObjSize); sRet.assign(pW); sRet.append(sW); return sRet; } inline CStdStringW operator+(const CStdStringW& s1, const CStdStringA& s2) { return s1 + CStdStringW(s2); } inline CStdStringW operator+(const CStdStringW& s1, PCSTR pA) { return s1 + CStdStringW(pA); } // New-style format function is a template #ifdef SS_SAFE_FORMAT template<> struct FmtArg { explicit FmtArg(const CStdStringA& arg) : a_(arg) {} PCSTR operator()() const { return a_.c_str(); } const CStdStringA& a_; private: FmtArg& operator=(const FmtArg&) { return *this; } }; template<> struct FmtArg { explicit FmtArg(const CStdStringW& arg) : a_(arg) {} PCWSTR operator()() const { return a_.c_str(); } const CStdStringW& a_; private: FmtArg& operator=(const FmtArg&) { return *this; } }; template<> struct FmtArg { explicit FmtArg(const std::string& arg) : a_(arg) {} PCSTR operator()() const { return a_.c_str(); } const std::string& a_; private: FmtArg& operator=(const FmtArg&) { return *this; } }; template<> struct FmtArg { explicit FmtArg(const std::wstring& arg) : a_(arg) {} PCWSTR operator()() const { return a_.c_str(); } const std::wstring& a_; private: FmtArg& operator=(const FmtArg&) {return *this;} }; #endif // #ifdef SS_SAFEFORMAT #ifndef SS_ANSI // SSResourceHandle: our MFC-like resource handle inline HMODULE& SSResourceHandle() { static HMODULE hModuleSS = GetModuleHandle(0); return hModuleSS; } #endif // In MFC builds, define some global serialization operators // Special operators that allow us to serialize CStdStrings to CArchives. // Note that we use an intermediate CString object in order to ensure that // we use the exact same format. #ifdef _MFC_VER inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringA& strA) { CString strTemp = strA; return ar << strTemp; } inline CArchive& AFXAPI operator<<(CArchive& ar, const CStdStringW& strW) { CString strTemp = strW; return ar << strTemp; } inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringA& strA) { CString strTemp; ar >> strTemp; strA = strTemp; return ar; } inline CArchive& AFXAPI operator>>(CArchive& ar, CStdStringW& strW) { CString strTemp; ar >> strTemp; strW = strTemp; return ar; } #endif // #ifdef _MFC_VER -- (i.e. is this MFC?) // Define TCHAR based friendly names for some of these functions #ifdef UNICODE //#define CStdString CStdStringW typedef CStdStringW CStdString; #else //#define CStdString CStdStringA typedef CStdStringA CStdString; #endif // ...and some shorter names for the space-efficient // ----------------------------------------------------------------------------- // FUNCTIONAL COMPARATORS: // REMARKS: // These structs are derived from the std::binary_function template. They // give us functional classes (which may be used in Standard C++ Library // collections and algorithms) that perform case-insensitive comparisons of // CStdString objects. This is useful for maps in which the key may be the // proper string but in the wrong case. // ----------------------------------------------------------------------------- #define StdStringLessNoCaseW SSLNCW // avoid VC compiler warning 4786 #define StdStringEqualsNoCaseW SSENCW #define StdStringLessNoCaseA SSLNCA #define StdStringEqualsNoCaseA SSENCA #ifdef UNICODE #define StdStringLessNoCase SSLNCW #define StdStringEqualsNoCase SSENCW #else #define StdStringLessNoCase SSLNCA #define StdStringEqualsNoCase SSENCA #endif struct StdStringLessNoCaseW : std::binary_function { inline bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; } }; struct StdStringEqualsNoCaseW : std::binary_function { inline bool operator()(const CStdStringW& sLeft, const CStdStringW& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; } }; struct StdStringLessNoCaseA : std::binary_function { inline bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) < 0; } }; struct StdStringEqualsNoCaseA : std::binary_function { inline bool operator()(const CStdStringA& sLeft, const CStdStringA& sRight) const { return ssicmp(sLeft.c_str(), sRight.c_str()) == 0; } }; // If we had to define our own version of TRACE above, get rid of it now #ifdef TRACE_DEFINED_HERE #undef TRACE #undef TRACE_DEFINED_HERE #endif // These std::swap specializations come courtesy of Mike Crusader. //namespace std //{ // inline void swap(CStdStringA& s1, CStdStringA& s2) throw() // { // s1.swap(s2); // } // template<> // inline void swap(CStdStringW& s1, CStdStringW& s2) throw() // { // s1.swap(s2); // } //} // Turn back on any Borland warnings we turned off. #ifdef __BORLANDC__ #pragma option pop // Turn back on inline function warnings // #pragma warn +inl // Turn back on inline function warnings #endif #endif // #ifndef STDSTRING_H