include/wx/strconv.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        strconv.h
   3 // Purpose:     conversion routines for char sets any Unicode
   4 // Author:      Robert Roebling, Ove Kaaven
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Ove Kaaven, Robert Roebling, Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_WXSTRCONVH__
  13 #define _WX_WXSTRCONVH__
  14
  15 #include "wx/defs.h"
  16 #include "wx/wxchar.h"
  17 #include "wx/buffer.h"
  18
  19 #ifdef __DIGITALMARS__
  20 #include "typeinfo.h"
  21 #endif
  22
  23 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
  24 #  undef __BSEXCPT__
  25 #endif
  26
  27 #include <stdlib.h>
  28
  29 #if wxUSE_WCHAR_T
  30
  31 // ----------------------------------------------------------------------------
  32 // wxMBConv (abstract base class for conversions)
  33 // ----------------------------------------------------------------------------
  34
  35 class WXDLLIMPEXP_BASE wxMBConv
  36 {
  37 public:
  38     // the actual conversion takes place here
  39     //
  40     // note that outputSize is the size of the output buffer, not the length of input
  41     // (the latter is always supposed to be NUL-terminated)
  42     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const = 0;
  43     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const = 0;
  44
  45     // MB <-> WC
  46     const wxWCharBuffer cMB2WC(const char *psz) const;
  47     const wxCharBuffer cWC2MB(const wchar_t *psz) const;
  48
  49     // MB <-> WC for strings with embedded null characters
  50     //
  51     // pszLen length of the input string
  52     // pOutSize gets the final size of the converted string
  53     const wxWCharBuffer cMB2WC(const char *psz, size_t pszLen, size_t* pOutSize) const;
  54     const wxCharBuffer cWC2MB(const wchar_t *psz, size_t pszLen, size_t* pOutSize) const;
  55
  56     // convenience functions for converting MB or WC to/from wxWin default
  57 #if wxUSE_UNICODE
  58     const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
  59     const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
  60     const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; }
  61     const wchar_t* cWX2WC(const wchar_t *psz) const { return psz; }
  62 #else // ANSI
  63     const char* cMB2WX(const char *psz) const { return psz; }
  64     const char* cWX2MB(const char *psz) const { return psz; }
  65     const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
  66     const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }
  67 #endif // Unicode/ANSI
  68
  69     // virtual dtor for any base class
  70     virtual ~wxMBConv();
  71 };
  72
  73 // ----------------------------------------------------------------------------
  74 // wxMBConvLibc uses standard mbstowcs() and wcstombs() functions for
  75 //              conversion (hence it depends on the current locale)
  76 // ----------------------------------------------------------------------------
  77
  78 class WXDLLIMPEXP_BASE wxMBConvLibc : public wxMBConv
  79 {
  80 public:
  81     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
  82     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
  83 };
  84
  85 #ifdef __UNIX__
  86
  87 // ----------------------------------------------------------------------------
  88 // wxConvBrokenFileNames is made for Unix in Unicode mode when
  89 // files are accidentally written in an encoding which is not
  90 // the system encoding. Typically, the system encoding will be
  91 // UTF8 but there might be files stored in ISO8859-1 on disk.
  92 // ----------------------------------------------------------------------------
  93
  94 class WXDLLIMPEXP_BASE wxConvBrokenFileNames : public wxMBConv
  95 {
  96 public:
  97     wxConvBrokenFileNames(const wxChar *charset);
  98     virtual ~wxConvBrokenFileNames() { delete m_conv; }
  99
 100     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 101     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 102
 103 private:
 104     // the conversion object we forward to
 105     wxMBConv *m_conv;
 106 };
 107
 108 #endif
 109
 110 // ----------------------------------------------------------------------------
 111 // wxMBConvUTF7 (for conversion using UTF7 encoding)
 112 // ----------------------------------------------------------------------------
 113
 114 class WXDLLIMPEXP_BASE wxMBConvUTF7 : public wxMBConv
 115 {
 116 public:
 117     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 118     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 119 };
 120
 121 // ----------------------------------------------------------------------------
 122 // wxMBConvUTF8 (for conversion using UTF8 encoding)
 123 // ----------------------------------------------------------------------------
 124
 125 class WXDLLIMPEXP_BASE wxMBConvUTF8 : public wxMBConv
 126 {
 127 public:
 128     enum {
 129         MAP_INVALID_UTF8_NOT = 0,
 130         MAP_INVALID_UTF8_TO_PUA = 1,
 131         MAP_INVALID_UTF8_TO_OCTAL = 2
 132     };
 133
 134     wxMBConvUTF8(int options = MAP_INVALID_UTF8_NOT) : m_options(options) { }
 135     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 136     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 137
 138 private:
 139     int m_options;
 140 };
 141
 142 // ----------------------------------------------------------------------------
 143 // wxMBConvUTF16LE (for conversion using UTF16 Little Endian encoding)
 144 // ----------------------------------------------------------------------------
 145
 146 class WXDLLIMPEXP_BASE wxMBConvUTF16LE : public wxMBConv
 147 {
 148 public:
 149     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 150     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 151 };
 152
 153 // ----------------------------------------------------------------------------
 154 // wxMBConvUTF16BE (for conversion using UTF16 Big Endian encoding)
 155 // ----------------------------------------------------------------------------
 156
 157 class WXDLLIMPEXP_BASE wxMBConvUTF16BE : public wxMBConv
 158 {
 159 public:
 160     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 161     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 162 };
 163
 164 // ----------------------------------------------------------------------------
 165 // wxMBConvUTF32LE (for conversion using UTF32 Little Endian encoding)
 166 // ----------------------------------------------------------------------------
 167
 168 class WXDLLIMPEXP_BASE wxMBConvUTF32LE : public wxMBConv
 169 {
 170 public:
 171     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 172     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 173 };
 174
 175 // ----------------------------------------------------------------------------
 176 // wxMBConvUTF32BE (for conversion using UTF32 Big Endian encoding)
 177 // ----------------------------------------------------------------------------
 178
 179 class WXDLLIMPEXP_BASE wxMBConvUTF32BE : public wxMBConv
 180 {
 181 public:
 182     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 183     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 184 };
 185
 186 // ----------------------------------------------------------------------------
 187 // wxCSConv (for conversion based on loadable char sets)
 188 // ----------------------------------------------------------------------------
 189
 190 #include "wx/fontenc.h"
 191
 192 class WXDLLIMPEXP_BASE wxCSConv : public wxMBConv
 193 {
 194 public:
 195     // we can be created either from charset name or from an encoding constant
 196     // but we can't have both at once
 197     wxCSConv(const wxChar *charset);
 198     wxCSConv(wxFontEncoding encoding);
 199
 200     wxCSConv(const wxCSConv& conv);
 201     virtual ~wxCSConv();
 202
 203     wxCSConv& operator=(const wxCSConv& conv);
 204
 205     virtual size_t MB2WC(wchar_t *outputBuf, const char *psz, size_t outputSize) const;
 206     virtual size_t WC2MB(char *outputBuf, const wchar_t *psz, size_t outputSize) const;
 207
 208     void Clear() ;
 209
 210 private:
 211     // common part of all ctors
 212     void Init();
 213
 214     // creates m_convReal if necessary
 215     void CreateConvIfNeeded() const;
 216
 217     // do create m_convReal (unconditionally)
 218     wxMBConv *DoCreate() const;
 219
 220     // set the name (may be only called when m_name == NULL), makes copy of
 221     // charset string
 222     void SetName(const wxChar *charset);
 223
 224
 225     // note that we can't use wxString here because of compilation
 226     // dependencies: we're included from wx/string.h
 227     wxChar *m_name;
 228     wxFontEncoding m_encoding;
 229
 230     // use CreateConvIfNeeded() before accessing m_convReal!
 231     wxMBConv *m_convReal;
 232     bool m_deferred;
 233 };
 234
 235
 236 // ----------------------------------------------------------------------------
 237 // declare predefined conversion objects
 238 // ----------------------------------------------------------------------------
 239
 240 // conversion to be used with all standard functions affected by locale, e.g.
 241 // strtol(), strftime(), ...
 242 extern WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc;
 243
 244 // conversion ISO-8859-1/UTF-7/UTF-8 <-> wchar_t
 245 extern WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1;
 246 extern WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7;
 247 extern WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8;
 248
 249 // conversion used for the file names on the systems where they're not Unicode
 250 // (basically anything except Windows)
 251 //
 252 // this is used by all file functions, can be changed by the application
 253 //
 254 // by default UTF-8 under Mac OS X and wxConvLibc elsewhere (but it's not used
 255 // under Windows normally)
 256 extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvFileName;
 257
 258 // backwards compatible define
 259 #define wxConvFile (*wxConvFileName)
 260
 261 // the current conversion object, may be set to any conversion, is used by
 262 // default in a couple of places inside wx (initially same as wxConvLibc)
 263 extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent;
 264
 265 // ???
 266 extern WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal;
 267
 268
 269 // ----------------------------------------------------------------------------
 270 // endianness-dependent conversions
 271 // ----------------------------------------------------------------------------
 272
 273 #ifdef WORDS_BIGENDIAN
 274     typedef wxMBConvUTF16BE wxMBConvUTF16;
 275     typedef wxMBConvUTF32BE wxMBConvUTF32;
 276 #else
 277     typedef wxMBConvUTF16LE wxMBConvUTF16;
 278     typedef wxMBConvUTF32LE wxMBConvUTF32;
 279 #endif
 280
 281 // ----------------------------------------------------------------------------
 282 // filename conversion macros
 283 // ----------------------------------------------------------------------------
 284
 285 // filenames are multibyte on Unix and probably widechar on Windows?
 286 #if defined(__UNIX__) || defined(__BORLANDC__) || defined(__WXMAC__ )
 287     #define wxMBFILES 1
 288 #else
 289     #define wxMBFILES 0
 290 #endif
 291
 292 #if wxMBFILES && wxUSE_UNICODE
 293     #define wxFNCONV(name) wxConvFileName->cWX2MB(name)
 294     #define wxFNSTRINGCAST wxMBSTRINGCAST
 295 #else
 296 #if defined( __WXOSX__ ) && wxMBFILES
 297     #define wxFNCONV(name) wxConvFileName->cWC2MB( wxConvLocal.cWX2WC(name) )
 298 #else
 299     #define wxFNCONV(name) name
 300 #endif
 301     #define wxFNSTRINGCAST WXSTRINGCAST
 302 #endif
 303
 304 #else // !wxUSE_WCHAR_T
 305
 306 // ----------------------------------------------------------------------------
 307 // stand-ins in absence of wchar_t
 308 // ----------------------------------------------------------------------------
 309
 310 class WXDLLIMPEXP_BASE wxMBConv
 311 {
 312 public:
 313     const char* cMB2WX(const char *psz) const { return psz; }
 314     const char* cWX2MB(const char *psz) const { return psz; }
 315 };
 316
 317 #define wxConvFile wxConvLocal
 318
 319 extern WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
 320                                        wxConvLocal,
 321                                        wxConvISO8859_1,
 322                                        wxConvUTF8;
 323 extern WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent;
 324
 325 #define wxFNCONV(name) name
 326 #define wxFNSTRINGCAST WXSTRINGCAST
 327
 328 #endif
 329   // wxUSE_WCHAR_T
 330
 331 // ----------------------------------------------------------------------------
 332 // macros for the most common conversions
 333 // ----------------------------------------------------------------------------
 334
 335 #if wxUSE_UNICODE
 336     #define wxConvertWX2MB(s)   wxConvCurrent->cWX2MB(s)
 337     #define wxConvertMB2WX(s)   wxConvCurrent->cMB2WX(s)
 338 #else // ANSI
 339     // no conversions to do
 340     #define wxConvertWX2MB(s)   (s)
 341     #define wxConvertMB2WX(s)   (s)
 342 #endif // Unicode/ANSI
 343
 344 #endif
 345   // _WX_WXSTRCONVH__
 346