String Convert for Windows//

//
// Convert
//
DWORD SSConvert_W2ABytes(LPCWSTR lpW)
{
 return ::WideCharToMultiByte(CP_OEMCP, NULL, lpW, -1, NULL, 0, NULL, FALSE);
}

DWORD SSConvert_A2WBytes(LPCSTR lpA)
{
 return ::MultiByteToWideChar (CP_ACP, 0, lpA, -1, NULL, 0) * sizeof(WCHAR);
}

BOOL SSConvert_W2ACopy(LPCWSTR lpW, LPSTR lpA, DWORD dwABytes)
{
 return (::WideCharToMultiByte(CP_OEMCP, NULL, lpW, -1, lpA, dwABytes / sizeof(CHAR), NULL, FALSE) > 0);
}

BOOL SSConvert_A2WCopy(LPCSTR lpA, LPWSTR lpW, DWORD dwWBytes)
{
 return (::MultiByteToWideChar (CP_ACP, 0, lpA, -1, lpW, dwWBytes / sizeof(WCHAR)) > 0); 
}

DWORD SSConvert_ABytes(LPCSTR lpA)
{
 return (lpA == NULL) ? 0 : (strlen(lpA) + 1);
}

DWORD SSConvert_WBytes(LPCWSTR lpW)
{
 return (lpW == NULL) ? 0 : ((wcslen(lpW) + 1) * sizeof(WCHAR));
}

BOOL SSConvert_A2ACopy(LPCSTR lpS, LPSTR lpD, DWORD dwDBytes)
{
 if(lpS == NULL || lpD == NULL || strlen(lpS) >= dwDBytes / sizeof(CHAR))
  return FALSE;
 
 strcpy(lpD, lpS);
 
 return TRUE;
}

BOOL SSConvert_W2WCopy(LPCWSTR lpS, LPWSTR lpD, DWORD dwDBytes)
{
 if(lpS == NULL || lpD == NULL || wcslen(lpS) >= dwDBytes / sizeof(WCHAR))
  return FALSE;
 
 wcscpy(lpD, lpS);
 
 return TRUE;
}

 

//

// Use

//

//
// string convert begin
//
#define SSConvert_Define DWORD gsz = 0; LPWSTR glpW = NULL; LPSTR glpA = NULL; (gsz); (glpW); (glpA);

#define SSConvert_W2A(lpW) ((gsz = SSConvert_W2ABytes(lpW)) <= 0) ? NULL : /
 ( /
 ((glpA = (LPSTR)alloca(gsz)) == NULL) ? NULL : ( !SSConvert_W2ACopy(lpW, glpA, gsz) ? NULL : glpA ) /
)

#define SSConvert_A2W(lpA) ((gsz = SSConvert_A2WBytes(lpA)) <= 0) ? NULL : /
 ( /
 ((glpW = (LPWSTR)alloca(gsz)) == NULL) ? NULL : ( !SSConvert_A2WCopy(lpA, glpW, gsz) ? NULL : glpW ) /
)

#define SSConvert_A2ACopyNew(lpS) ((gsz = SSConvert_ABytes(lpS)) <= 0) ? NULL : /
 ( /
 ((glpA = (LPSTR)alloca(gsz)) == NULL) ? NULL : ( !SSConvert_A2ACopy(lpS, glpA, gsz) ? NULL : glpA ) /
)

#define SSConvert_W2WCopyNew(lpS) ((gsz = SSConvert_WBytes(lpS)) <= 0) ? NULL : /
 ( /
 ((glpW = (LPWSTR)alloca(gsz)) == NULL) ? NULL : ( !SSConvert_W2WCopy(lpS, glpW, gsz) ? NULL : glpW ) /
)

DWORD SSConvert_W2ABytes(LPCWSTR lpW);

DWORD SSConvert_A2WBytes(LPCSTR lpA);

BOOL SSConvert_W2ACopy(LPCWSTR lpW, LPSTR lpA, DWORD dwABytes);

BOOL SSConvert_A2WCopy(LPCSTR lpA, LPWSTR lpW, DWORD dwWBytes);

DWORD SSConvert_ABytes(LPCSTR lpA);

DWORD SSConvert_WBytes(LPCWSTR lpW);

BOOL SSConvert_A2ACopy(LPCSTR lpS, LPSTR lpD, DWORD dwDBytes);

BOOL SSConvert_W2WCopy(LPCWSTR lpS, LPWSTR lpD, DWORD dwDBytes);

#ifdef UNICODE
#define SS_W2T(lp) lp
#define SS_T2W(lp) SS_W2T(lp)
#define SS_A2T(lp) SSConvert_A2W(lp)
#define SS_T2A(lp) SSConvert_W2A(lp)
#define SS_W2TCopy(lp) SSConvert_W2WCopyNew(lp)
#define SS_T2WCopy(lp) SS_W2TCopy(lp)
#define SS_A2TCopy(lp) SS_A2T(lp)
#define SS_T2ACopy(lp) SS_T2A(lp)
#else
#define SS_W2T(lp) SSConvert_W2A(lp)
#define SS_T2W(lp) SSConvert_A2W(lp)
#define SS_A2T(lp) lp
#define SS_T2A(lp) lp
#define SS_W2TCopy(lp) SS_W2T(lp)
#define SS_T2WCopy(lp) SS_T2W(lp)
#define SS_A2TCopy(lp) SSConvert_A2ACopyNew(lp)
#define SS_T2ACopy(lp) SS_A2TCopy(lp)
#endif

//
// string convert end
//