From fdc69927d9ee3946a40e4e5bc12b2f8696da3a16 Mon Sep 17 00:00:00 2001 From: Glenn Maynard Date: Fri, 3 Jan 2003 05:30:21 +0000 Subject: [PATCH] remove a bunch of unused stuff. --- stepmania/src/StdString.h | 600 ++++++-------------------------------- 1 file changed, 82 insertions(+), 518 deletions(-) diff --git a/stepmania/src/StdString.h b/stepmania/src/StdString.h index ac4595eeb8..08106492c8 100644 --- a/stepmania/src/StdString.h +++ b/stepmania/src/StdString.h @@ -205,7 +205,6 @@ // 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() @@ -260,85 +259,24 @@ #ifndef STDSTRING_H #define STDSTRING_H -//#define SS_NOLOCALE // prevents use/inclusion of header - // In non-Visual C++ and/or non-Win32 builds, we can't use some cool stuff. #if !defined(_MSC_VER) || !defined(_WIN32) #define SS_ANSI #endif -// Avoid legacy code screw up: if _UNICODE is defined, UNICODE must be as well +// If they want us to use only standard C++ stuff (no Win32 stuff) -#if defined (_UNICODE) && !defined (UNICODE) - #define UNICODE -#endif -#if defined (UNICODE) && !defined (_UNICODE) - #define _UNICODE -#endif +#ifdef SS_ANSI -// ----------------------------------------------------------------------------- -// 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 -// ----------------------------------------------------------------------------- + // On non-Win32 platforms, there is no TCHAR.H so define what we need -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; -} + #ifndef _WIN32 -// 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 non-Win32 platforms, there is no TCHAR.H so define what we need - - #ifndef _WIN32 - - typedef const char* PCSTR; - typedef char* PSTR; - #ifdef UNICODE - typedef wchar_t TCHAR; - #else - typedef char TCHAR; - #endif - #else - - #include - #include - #ifndef STRICT - #define STRICT - #endif - - #endif // #ifndef _WIN32 - - - // Make sure ASSERT and verify are defined in an ANSI fashion - - #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 // #ifdef SS_ANSI + typedef const char* PCSTR; + typedef char* PSTR; + typedef char TCHAR; + #else #include #include @@ -346,27 +284,32 @@ inline const Type& SSMAX(const Type& arg1, const Type& arg2) #define STRICT #endif - // Make sure ASSERT and verify are defined + #endif // #ifndef _WIN32 - #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 + // Make sure ASSERT is defined in an ANSI fashion - #ifndef UNUSED - #define UNUSED(x) x + #ifndef ASSERT + #include + #define ASSERT(f) assert((f)) #endif -#endif // #ifndef W32BASE_H +#else // #ifdef SS_ANSI + + #include + #include + #ifndef STRICT + #define STRICT + #endif + + // Make sure ASSERT is defined + + #ifndef ASSERT + #include + #define ASSERT(f) _ASSERTE((f)) + #endif + +#endif // #ifdef SS_ANSI // Standard headers needed @@ -374,10 +317,6 @@ inline const Type& SSMAX(const Type& arg1, const Type& arg2) #include // for_each, etc. #include // for StdStringLessNoCase, et al -#ifndef SS_NOLOCALE - #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 @@ -388,73 +327,6 @@ inline const Type& SSMAX(const Type& arg1, const Type& arg2) #define SS_NOTHROW #endif -#ifndef TRACE - #define TRACE_DEFINED_HERE - #define TRACE -#endif - -// Microsoft defines PCSTR, 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(PCUSTR) && !defined(PCUSTR_DEFINED) - typedef const unsigned char* PCUSTR; - typedef unsigned char* PUSTR; - #define PCUSTR_DEFINED -#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 - #ifndef SS_ANSI #include #endif @@ -469,18 +341,11 @@ inline const Type& SSMAX(const Type& arg1, const Type& arg2) #include #include - #include - #include #include #include #ifndef va_start #include #endif - - // Standard C++ Library implementations that do not provide the required - // locale header (and thus the codecvt facet) can use good old mbstowcs and - // wcstombs instead by #defining SS_NOLOCALE - #endif // #ifndef SS_ANSI // StdCodeCvt when there's no conversion to be done @@ -497,21 +362,10 @@ inline PSTR StdCodeCvt(PSTR pDst, PCSTR pSrc, int nChars) return pDst; } -inline PSTR StdCodeCvt(PSTR pDst, PCUSTR pSrc, int nChars) +inline PSTR StdCodeCvt(PSTR pDst, const unsigned char *pSrc, int nChars) { return StdCodeCvt(pDst, (PCSTR)pSrc, nChars); } -inline PUSTR StdCodeCvt(PUSTR pDst, PCSTR pSrc, int nChars) -{ - return (PUSTR)StdCodeCvt((PSTR)pDst, pSrc, nChars); -} - -// 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) @@ -552,7 +406,6 @@ inline PUSTR StdCodeCvt(PUSTR pDst, PCSTR pSrc, int nChars) template inline int sslen(const CT* pT) { return 0 == pT ? 0 : 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) { @@ -562,23 +415,8 @@ inline SS_NOTHROW int sslen(const std::string& s) // ----------------------------------------------------------------------------- // sstolower/sstoupper -- convert characters to upper/lower case // ----------------------------------------------------------------------------- -#if !defined(SS_ANSI) || defined(SS_NOLOCALE) - 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& lo =std::locale()) - { - return std::tolower(t, loc); - } - template - inline CT sstoupper(const CT& t, const std::locale& lo =std::locale()) - { - return std::toupper(t, loc); - } -#endif +inline char sstoupper(char ch) { return (char)::toupper(ch); } +inline char sstolower(char ch) { return (char)::tolower(ch); } // ----------------------------------------------------------------------------- // ssasn: assignment functions -- assign "sSrc" to "sDst" @@ -622,9 +460,8 @@ inline void ssasn(std::string& sDst, PCSTR pA) } inline void ssasn(std::string& sDst, const int nNull) { - UNUSED(nNull); ASSERT(nNull==0); - sDst.assign(""); + sDst.erase(); } #undef StrSizeType @@ -666,48 +503,29 @@ inline void ssadd(std::string& sDst, PCSTR pA) // ssicmp: comparison (case insensitive ) // ----------------------------------------------------------------------------- #ifdef SS_ANSI - #ifdef SS_NOLOCALE - template - inline int ssicmp(const CT* pA1, const CT* pA2) + template + inline int ssicmp(const CT* pA1, const CT* pA2) + { + CT f; + CT l; + + do { - CT f; - CT l; + f = sstolower(*(pA1++)); + l = sstolower(*(pA2++)); + } while ( (f) && (f == l) ); - do - { - f = sstolower(*(pA1++)); - l = sstolower(*(pA2++)); - } while ( (f) && (f == l) ); - - return (int)(f - l); - } - #else - template - inline int ssicmp(const CT* pA1, const CT* pA2) - { - std::locale loc; - 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); - } - #endif + return (int)(f - l); + } #else #ifdef _MBCS inline long sscmp(PCSTR pA1, PCSTR pA2) { - return _mbscmp((PCUSTR)pA1, (PCUSTR)pA2); + return _mbscmp((const unsigned char *)pA1, (const unsigned char *)pA2); } inline long ssicmp(PCSTR pA1, PCSTR pA2) { - return _mbsicmp((PCUSTR)pA1, (PCUSTR)pA2); + return _mbsicmp((const unsigned char *)pA1, (const unsigned char *)pA2); } #else inline long sscmp(PCSTR pA1, PCSTR pA2) @@ -725,40 +543,27 @@ inline void ssadd(std::string& sDst, PCSTR pA) // ssupr/sslwr: Uppercase/Lowercase conversion functions // ----------------------------------------------------------------------------- #ifdef SS_ANSI - #ifdef SS_NOLOCALE - template - inline void sslwr(CT* pT, size_t nLen) - { - for ( CT* p = pT; static_cast(p - pT) < nLen; ++p) - *p = (CT)sstolower(*p); - } - template - inline void ssupr(CT* pT, size_t nLen) - { - for ( CT* p = pT; static_cast(p - pT) < nLen; ++p) - *p = (CT)sstoupper(*p); - } - #else - template - inline void sslwr(CT* pT, size_t nLen) - { - SS_USE_FACET(std::locale(), std::ctype).tolower(pT, pT+nLen); - } - template - inline void ssupr(CT* pT, size_t nLen) - { - SS_USE_FACET(std::locale(), std::ctype).toupper(pT, pT+nLen); - } - #endif + template + inline void sslwr(CT* pT, size_t nLen) + { + for ( CT* p = pT; static_cast(p - pT) < nLen; ++p) + *p = (CT)sstolower(*p); + } + template + inline void ssupr(CT* pT, size_t nLen) + { + for ( CT* p = pT; static_cast(p - pT) < nLen; ++p) + *p = (CT)sstoupper(*p); + } #else // #else we must be on Win32 #ifdef _MBCS inline void ssupr(PSTR pA, size_t /*nLen*/) { - _mbsupr((PUSTR)pA); + _mbsupr((unsigned char *)pA); } inline void sslwr(PSTR pA, size_t /*nLen*/) { - _mbslwr((PUSTR)pA); + _mbslwr((unsigned char *)pA); } #else inline void ssupr(PSTR pA, size_t /*nLen*/) @@ -789,130 +594,27 @@ inline void ssadd(std::string& sDst, PCSTR pA) #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 -// ----------------------------------------------------------------------------- -#ifdef SS_ANSI -#else - inline int ssload(HMODULE hInst, UINT uId, PSTR pBuf, int nMax) - { - return ::LoadStringA(hInst, uId, pBuf, nMax); - } -#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) -// -// 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 nChars) -{ - StdCodeCvt(pDst, pSrc, nChars); - pDst[SSMAX(nChars, 0)] = '\0'; - return nChars; -} - -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()); -} - // ----------------------------------------------------------------------------- // Functional objects for changing case. They also let you pass locales // ----------------------------------------------------------------------------- #ifdef SS_ANSI - #ifdef SS_NOLOCALE - template - struct SSToUpper : public std::unary_function + template + struct SSToUpper : public std::binary_function + { + inline CT operator()(const CT& t, const std::locale& loc) const { - inline CT operator()(const CT& t) const - { - return sstoupper(t); - } - }; - template - struct SSToLower : public std::unary_function + return sstoupper(t, loc); + } + }; + template + struct SSToLower : public std::binary_function + { + inline CT operator()(const CT& t, const std::locale& loc) const { - 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 + return sstolower(t, loc); + } + }; #endif @@ -971,13 +673,6 @@ public: { } -#ifdef SS_ALLOW_UNSIGNED_CHARS - CStdStr(PCUSTR pU) - { - *this = reinterpret_cast(pU); - } -#endif - CStdStr(PCSTR pA) { *this = pA; @@ -1015,14 +710,6 @@ public: return *this; } -#ifdef SS_ALLOW_UNSIGNED_CHARS - MYTYPE& operator=(PCUSTR pU) - { - ssasn(*this, reinterpret_cast(pU)): - return *this; - } -#endif - MYTYPE& operator=(CT t) { Q172398(*this); @@ -1049,7 +736,7 @@ public: // 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); + nChars = min(nChars, str.length() - nStart); // Watch out for assignment to self @@ -1080,7 +767,7 @@ public: // 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); + nChars = min(nChars, str.length() - nStart); // Watch out for assignment to self @@ -1109,7 +796,6 @@ public: this->erase(); } #endif - Q172398(*this); MYBASE::assign(pC, nChars); return *this; } @@ -1222,12 +908,6 @@ public: - 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 @@ -1364,7 +1044,7 @@ public: // Ensure proper NULL termination. - nActual = nUsed == -1 ? nChars-1 : SSMIN(nUsed, nChars-1); + nActual = nUsed == -1 ? nChars-1 : min(nUsed, nChars-1); pBuf[nActual+1]= '\0'; @@ -1389,22 +1069,6 @@ public: return ssicmp(this->c_str(), szThat); } - int Delete(int nIdx, int nCount=1) - { - if ( nIdx < 0 ) - nIdx = 0; - - if ( nIdx < GetLength() ) - this->erase(static_cast(nIdx), static_cast(nCount)); - - return GetLength(); - } - - void Empty() - { - this->erase(); - } - int Find(CT ch) const { MYSIZE nIdx = this->find_first_of(ch); @@ -1437,21 +1101,9 @@ public: return static_cast(MYBASE::npos == nIdx ? -1 : nIdx); } - int FindOneOf(PCMYSTR szCharSet) const - { - MYSIZE nIdx = this->find_first_of(szCharSet); - return static_cast(MYBASE::npos == nIdx ? -1 : nIdx); - } - - // ------------------------------------------------------------------------- // GetXXXX -- Direct access to character buffer // ------------------------------------------------------------------------- - CT GetAt(int nIdx) const - { - return this->at(static_cast(nIdx)); - } - CT* GetBuffer(int nMinLen=-1) { return GetBuf(nMinLen); @@ -1484,16 +1136,11 @@ public: return GetLength(); } - bool IsEmpty() const - { - return this->empty(); - } - MYTYPE Left(int nCount) const { // Range check the count. - nCount = SSMAX(0, SSMIN(nCount, static_cast(this->size()))); + nCount = max(0, min(nCount, static_cast(this->size()))); return this->substr(0, static_cast(nCount)); } @@ -1512,34 +1159,6 @@ public: ToUpper(); } - MYTYPE Mid(int nFirst ) const - { - return Mid(nFirst, size()-nFirst); - } - - 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 < 0 ) - nFirst = 0; - if ( nCount < 0 ) - nCount = 0; - - if ( unsigned(nFirst + nCount) > size() ) - nCount = size() - nFirst; - - if ( unsigned(nFirst) > size() ) - return MYTYPE(); - - ASSERT(nFirst >= 0); - ASSERT(unsigned(nFirst + nCount) <= size()); - - return this->substr(static_cast(nFirst), - static_cast(nCount)); - } - void ReleaseBuffer(int nNewLen=-1) { RelBuf(nNewLen); @@ -1602,16 +1221,10 @@ public: { // Range check the count. - nCount = SSMAX(0, SSMIN(nCount, static_cast(this->size()))); + nCount = max(0, min(nCount, static_cast(this->size()))); return this->substr(this->size()-static_cast(nCount)); } - void SetAt(int nIndex, CT ch) - { - ASSERT(this->size() > static_cast(nIndex)); - this->at(static_cast(nIndex)) = ch; - } - // 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) @@ -1693,42 +1306,6 @@ CStdStr operator+(PCSTR pA, const CStdStr& str) #if defined(__SUNPRO_CC_COMPAT) || defined(__SUNPRO_CC) -// Made non-template versions due to "undefined" errors on Sun Forte compiler -// when linking with friend template functions -inline -CStdStr operator+(const CStdStr& str1, - const CStdStr& str2) -{ - CStdStr strRet(str1); - strRet.append(str2); - return strRet; -} - -inline -CStdStr operator+(const CStdStr& str, wchar_t t) -{ - // this particular overload is needed for disabling reference counting - // though it's only an issue from line 1 to line 2 - - CStdStr strRet(str); // 1 - strRet.append(1, t); // 2 - return strRet; -} - -inline -CStdStr operator+(const CStdStr& str, PCSTR pW) -{ - return CStdStr(str) + CStdStr(pW); -} - -inline -CStdStr operator+(PCSTR pW, const CStdStr& str) -{ - CStdStr strRet(pW); - strRet.append(str); - return strRet; -} - inline CStdStr operator+(const CStdStr& str1, const CStdStr& str2) { @@ -1854,13 +1431,8 @@ typedef CStdStr CStdStringA; // a better std::string #define StdStringLessNoCaseA SSLNCA #define StdStringEqualsNoCaseA SSENCA -#ifdef UNICODE - #define StdStringLessNoCase SSLNCW - #define StdStringEqualsNoCase SSENCW -#else - #define StdStringLessNoCase SSLNCA - #define StdStringEqualsNoCase SSENCA -#endif +#define StdStringLessNoCase SSLNCA +#define StdStringEqualsNoCase SSENCA struct StdStringLessNoCaseA : std::binary_function @@ -1877,14 +1449,6 @@ struct StdStringEqualsNoCaseA { 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