src/Utils/strconv.h

   1 /*************************************************************************************
   2   This file is a part of CrashRpt library.
   3
   4   Copyright (c) 2003, Michael Carruth
   5   All rights reserved.
   6
   7   Redistribution and use in source and binary forms, with or without modification,
   8   are permitted provided that the following conditions are met:
   9
  10    * Redistributions of source code must retain the above copyright notice, this
  11      list of conditions and the following disclaimer.
  12
  13    * Redistributions in binary form must reproduce the above copyright notice,
  14      this list of conditions and the following disclaimer in the documentation
  15      and/or other materials provided with the distribution.
  16
  17    * Neither the name of the author nor the names of its contributors
  18      may be used to endorse or promote products derived from this software without
  19      specific prior written permission.
  20
  21
  22   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
  23   EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  25   SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  27   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28   BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  30   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31 ***************************************************************************************/
  32
  33 // File: strconv.h
  34 // Description: String conversion class
  35 // Author: zexspectrum
  36 // Date: 2009-2010
  37
  38 #ifndef _STRCONV_H
  39 #define _STRCONV_H
  40
  41 #include <vector>
  42
  43 class strconv_t
  44 {
  45 public:
  46   strconv_t(){}
  47   ~strconv_t()
  48   {
  49     unsigned i;
  50     for (i = 0; i < m_ConvertedStrings.size(); ++i)
  51     {
  52       delete [] m_ConvertedStrings[i];
  53     }
  54   }
  55
  56   LPCWSTR a2w(LPCSTR lpsz)
  57   {
  58     if(lpsz==NULL)
  59       return NULL;
  60
  61     int count = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpsz, -1, NULL, 0);
  62     if(count==0)
  63       return NULL;
  64
  65     void* pBuffer = (void*) new wchar_t[count];
  66     int result = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpsz, -1, (LPWSTR)pBuffer, count);
  67     if(result==0)
  68     {
  69       delete [] pBuffer;
  70       return NULL;
  71     }
  72
  73     m_ConvertedStrings.push_back(pBuffer);
  74     return (LPCWSTR)pBuffer;
  75   }
  76
  77   LPCSTR w2a(LPCWSTR lpsz)
  78   {
  79     if(lpsz==NULL)
  80       return NULL;
  81
  82     int count = WideCharToMultiByte(CP_UTF8, 0, lpsz, -1, NULL, 0, NULL, NULL);
  83     if(count==0)
  84       return NULL;
  85
  86     void* pBuffer = (void*) new char[count];
  87     int result = WideCharToMultiByte(CP_ACP, 0, lpsz, -1, (LPSTR)pBuffer, count, NULL, NULL);
  88     if(result==0)
  89     {
  90       delete [] pBuffer;
  91       return NULL;
  92     }
  93
  94     m_ConvertedStrings.push_back(pBuffer);
  95     return (LPCSTR)pBuffer;
  96   }
  97
  98   // Converts UNICODE little endian string to UNICODE big endian
  99   LPCWSTR w2w_be(LPCWSTR lpsz, UINT cch)
 100   {
 101     if(lpsz==NULL)
 102       return NULL;
 103
 104     WCHAR* pBuffer = new WCHAR[cch+1];
 105     for (UINT i = 0; i < cch; ++i)
 106     {
 107       // Swap bytes
 108       pBuffer[i] = (WCHAR)MAKEWORD((lpsz[i]>>8), (lpsz[i]&0xFF));
 109     }
 110
 111     pBuffer[cch] = 0; // Zero terminator
 112
 113     m_ConvertedStrings.push_back((void*)pBuffer);
 114     return (LPCWSTR)pBuffer;
 115   }
 116
 117   LPCSTR a2utf8(LPCSTR lpsz)
 118   {
 119     if(lpsz==NULL)
 120       return NULL;
 121
 122     // 1. Convert input ANSI string to widechar using
 123     // MultiByteToWideChar(CP_ACP, ...) function (CP_ACP
 124     // is current Windows system Ansi code page)
 125
 126     // Calculate required buffer size
 127     int count = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpsz, -1, NULL, 0);
 128     if(count==0)
 129       return NULL;
 130
 131     // Convert ANSI->UNICODE
 132     wchar_t* pBuffer = new wchar_t[count];
 133     int result = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpsz, -1, (LPWSTR)pBuffer, count);
 134     if(result==0)
 135     {
 136       delete [] pBuffer;
 137       return NULL;
 138     }
 139
 140     // 2. Convert output widechar string from previous call to
 141     // UTF-8 using WideCharToMultiByte(CP_UTF8, ...)  function
 142
 143     LPCSTR pszResult = (LPCSTR)w2utf8(pBuffer);
 144     delete [] pBuffer;
 145     return pszResult;
 146   }
 147
 148   LPCSTR w2utf8(LPCWSTR lpsz)
 149   {
 150     if(lpsz==NULL)
 151       return NULL;
 152
 153     // Calculate required buffer size
 154     int count = WideCharToMultiByte(CP_UTF8, 0, lpsz, -1, NULL, 0, NULL, NULL);
 155     if(count==0)
 156     {
 157       return NULL;
 158     }
 159
 160     // Convert UNICODE->UTF8
 161     LPSTR pBuffer = new char[count];
 162     int result = WideCharToMultiByte(CP_UTF8, 0, lpsz, -1, (LPSTR)pBuffer, count, NULL, NULL);
 163     if(result==0)
 164     {
 165       delete [] pBuffer;
 166       return NULL;
 167     }
 168
 169     m_ConvertedStrings.push_back(pBuffer);
 170     return (LPCSTR)pBuffer;
 171   }
 172
 173   LPCWSTR utf82w(LPCSTR lpsz)
 174   {
 175     if(lpsz==NULL)
 176       return NULL;
 177
 178     // Calculate required buffer size
 179     int count = MultiByteToWideChar(CP_UTF8, 0, lpsz, -1, NULL, 0);
 180     if(count==0)
 181     {
 182       return NULL;
 183     }
 184
 185     // Convert UNICODE->UTF8
 186     LPWSTR pBuffer = new wchar_t[count];
 187     int result = MultiByteToWideChar(CP_UTF8, 0, lpsz, -1, (LPWSTR)pBuffer, count);
 188     if(result==0)
 189     {
 190       delete [] pBuffer;
 191       return NULL;
 192     }
 193
 194     m_ConvertedStrings.push_back(pBuffer);
 195     return (LPCWSTR)pBuffer;
 196   }
 197
 198   LPCWSTR utf82w(LPCSTR pStr, UINT cch)
 199   {
 200     if(pStr==NULL)
 201       return NULL;
 202
 203     // Calculate required buffer size
 204     int count = MultiByteToWideChar(CP_UTF8, 0, pStr, cch, NULL, 0);
 205     if(count==0)
 206     {
 207       return NULL;
 208     }
 209
 210     // Convert UNICODE->UTF8
 211     LPWSTR pBuffer = new wchar_t[count+1];
 212     int result = MultiByteToWideChar(CP_UTF8, 0, pStr, cch, (LPWSTR)pBuffer, count);
 213     if(result==0)
 214     {
 215       delete [] pBuffer;
 216       return NULL;
 217     }
 218
 219     // Zero-terminate
 220     pBuffer[count]=0;
 221
 222     m_ConvertedStrings.push_back(pBuffer);
 223     return (LPCWSTR)pBuffer;
 224   }
 225
 226   LPCSTR utf82a(LPCSTR lpsz)
 227   {
 228     return w2a(utf82w(lpsz));
 229   }
 230
 231   LPCTSTR utf82t(LPCSTR lpsz)
 232   {
 233 #ifdef UNICODE
 234     return utf82w(lpsz);
 235 #else
 236     return utf82a(lpsz);
 237 #endif
 238   }
 239
 240   LPCSTR t2a(LPCTSTR lpsz)
 241   {
 242 #ifdef UNICODE
 243     return w2a(lpsz);
 244 #else
 245     return lpsz;
 246 #endif
 247   }
 248
 249 LPCWSTR t2w(LPCTSTR lpsz)
 250   {
 251 #ifdef UNICODE
 252     return lpsz;
 253 #else
 254     return a2w(lpsz);
 255 #endif
 256   }
 257
 258   LPCTSTR a2t(LPCSTR lpsz)
 259   {
 260 #ifdef UNICODE
 261     return a2w(lpsz);
 262 #else
 263     return lpsz;
 264 #endif
 265   }
 266
 267 LPCTSTR w2t(LPCWSTR lpsz)
 268   {
 269 #ifdef UNICODE
 270     return lpsz;
 271 #else
 272     return w2a(lpsz);
 273 #endif
 274   }
 275
 276 LPCSTR t2utf8(LPCTSTR lpsz)
 277   {
 278 #ifdef UNICODE
 279     return w2utf8(lpsz);
 280 #else
 281     return a2utf8(lpsz);
 282 #endif
 283   }
 284
 285 private:
 286   std::vector<void*> m_ConvertedStrings;
 287 };
 288
 289 #endif  //_STRCONV_H
 290
 291