stdstring.h

FastDb是高效的内存数据库系统

   #ifdef SS_ANSI
    #pragma schMSG(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS defined!!)
   #endif
  #endif
  #define SS_USE_FACET(loc, fac) std::use_facet<fac >(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<fac >(loc)
 #endif
#endif

// =============================================================================
// UNICODE/MBCS conversion macros.  Made to work just like the MFC/ATL ones.
// =============================================================================

// First define the conversion helper functions.  We define these regardless of
// any preprocessor macro settings since their names won't collide.

#ifdef SS_ANSI // Are we doing things the standard, non-Win32 way?...


// Not sure if we need all these headers.   I believe ANSI says we do.

#include <stdio.h>
 #include <stdarg.h>
 #include <wchar.h>
 #include <wctype.h>
 #ifndef va_start
  #include <varargs.h>
 #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

#ifdef SS_NOLOCALE

inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars)
{
  ASSERT(0 != pA);
  ASSERT(0 != pW);
  pW[0] = '\0';
  int nCvt = mbstowcs(pW, pA, nChars);
  ASSERT(nCvt >=0);
  return pW;
}

inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars)
{
  return StdCodeCvt(pW, (PCSTR)pA, nChars);
}

inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars)
{
  ASSERT(0 != pA);
  ASSERT(0 != pW);
  pA[0] = '\0';
  int nCvt = wcstombs(pA, pW, nChars);
  ASSERT(nCvt >=0);
  return pA;
}

inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars)
{
  return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars);
}

#else

typedef std::codecvt<wchar_t, char, mbstate_t> SSCodeCvt;

// StdCodeCvt - made to look like Win32 functions WideCharToMultiByte
//    and MultiByteToWideChar but uses locales in SS_ANSI
//    builds
inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars,
                        const std::locale& loc=std::locale())
{
  ASSERT(0 != pA);
  ASSERT(0 != pW);
  pW[0] = '\0';
  PCSTR pBadA    = 0;
  PWSTR pBadW    = 0;
  SSCodeCvt::result res = SSCodeCvt::ok;
  const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt);
  SSCodeCvt::state_type st= { 0 };
  res      = conv.in(st,
                     pA, pA + nChars, pBadA,
                     pW, pW + nChars, pBadW);
  ASSERT(SSCodeCvt::ok == res);
  return pW;
}

inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars,
                        const std::locale& loc=std::locale())
{
  return StdCodeCvt(pW, (PCSTR)pA, nChars, loc);
}

inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars,
                       const std::locale& loc=std::locale())
{
  ASSERT(0 != pA);
  ASSERT(0 != pW);
  pA[0] = '\0';
  PSTR pBadA    = 0;
  PCWSTR pBadW   = 0;
  SSCodeCvt::result res = SSCodeCvt::ok;
  const SSCodeCvt& conv = SS_USE_FACET(loc, SSCodeCvt);
  SSCodeCvt::state_type st= { 0 };
  res      = conv.out(st,
                      pW, pW + nChars, pBadW,
                      pA, pA + nChars, pBadA);
  ASSERT(SSCodeCvt::ok == res);
  return pA;
}

inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars,
                        const std::locale& loc=std::locale())
{
  return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, loc);
}

#endif

#else   // ...or are we doing things assuming win32 and Visual C++?

#include <malloc.h> // needed for _alloca

inline PWSTR StdCodeCvt(PWSTR pW, PCSTR pA, int nChars, UINT acp=CP_ACP)
{
  ASSERT(0 != pA);
  ASSERT(0 != pW);
  pW[0] = '\0';
  MultiByteToWideChar(acp, 0, pA, -1, pW, nChars);
  return pW;
}

inline PWSTR StdCodeCvt(PWSTR pW, PCUSTR pA, int nChars, UINT acp=CP_ACP)
{
  return StdCodeCvt(pW, (PCSTR)pA, nChars, acp);
}

inline PSTR StdCodeCvt(PSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP)
{
  ASSERT(0 != pA);
  ASSERT(0 != pW);
  pA[0] = '\0';
  WideCharToMultiByte(acp, 0, pW, -1, pA, nChars, 0, 0);
  return pA;
}

inline PUSTR StdCodeCvt(PUSTR pA, PCWSTR pW, int nChars, UINT acp=CP_ACP)
{
  return (PUSTR)StdCodeCvt((PSTR)pA, pW, nChars, acp);
}

// 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
 #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
 #endif

#ifdef _CONVERSION_USES_THREAD_LOCALE
  #define SSA2W(pa) (\
   ((_pa = pa) == 0) ? 0 : (\
    _cvt = (strlen(_pa)+1),\
    StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt, _acp)))
  #define SSW2A(pw) (\
   ((_pw = pw) == 0) ? 0 : (\
    _cvt = (wcslen(_pw)+1)*2,\
    StdW2AHelper((LPSTR) _alloca(_cvt), _pw, _cvt, _acp)))
 #else
  #define SSA2W(pa) (\
   ((_pa = pa) == 0) ? 0 : (\
    _cvt = (strlen(_pa)+1),\
    StdCodeCvt((PWSTR) _alloca(_cvt*2), _pa, _cvt)))
  #define SSW2A(pw) (\
   ((_pw = pw) == 0) ? 0 : (\
    _cvt = (wcslen(_pw)+1)*2,\
    StdCodeCvt((LPSTR) _alloca(_cvt), _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
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
// SS_NO_CONVERSION is #defined, we'll forgo them

#ifndef SS_NO_CONVERSION

#if defined (USES_CONVERSION)

#define _NO_STDCONVERSION // just to be consistent

#else

#ifdef _MFC_VER

#include <afxconv.h>
    #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<OLECHAR>

#if !defined(ostring) && !defined(OSTRING_DEFINED)
typedef std::basic_string<OLECHAR> ostring;
#define OSTRING_DEFINED
 #endif

#endif // #ifndef SS_ANSI

// StdCodeCvt when there's no conversion to be done
inline PSTR StdCodeCvt(PSTR pDst, PCSTR pSrc, int nChars)
{
  if ( nChars > 0 )
  {
    pDst[0]    = '\0';
    std::basic_string<char>::traits_type::copy(pDst, pSrc, nChars);
    //  std::char_traits<char>::copy(pDst, pSrc, nChars);

    if ( nChars > 0 )
      pDst[nChars] = '\0';
  }

  return pDst;
}

inline PSTR StdCodeCvt(PSTR pDst, PCUSTR 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);
}

inline PWSTR StdCodeCvt(PWSTR pDst, PCWSTR pSrc, int nChars)
{
  if ( nChars > 0 )
  {
    pDst[0]    = '\0';
    std::basic_string<wchar_t>::traits_type::copy(pDst, pSrc, nChars);
    //  std::char_traits<wchar_t>::copy(pDst, pSrc, nChars);

    if ( nChars > 0 )
      pDst[nChars] = '\0';
  }

  return pDst;
}


// Define tstring -- generic name for std::basic_string<TCHAR>

#if !defined(tstring) && !defined(TSTRING_DEFINED)
typedef std::basic_string<TCHAR> tstring;
#define TSTRING_DEFINED
#endif

// a very shorthand way of applying the fix for KB problem Q172398
// (basic_string assignment bug)