include/wx/wxcrtvararg.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/wxcrtvararg.h
   3 // Purpose:     Type-safe ANSI and Unicode builds compatible wrappers for
   4 //              printf(), scanf() and related CRT functions
   5 // Author:      Joel Farley, Ove Kåven
   6 // Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
   7 // Created:     2007-02-19
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2007 REA Elektronik GmbH
  10 // Licence:     wxWindows licence
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #ifndef _WX_WXCRTVARARG_H_
  14 #define _WX_WXCRTVARARG_H_
  15
  16 #include "wx/wxcrt.h"
  17 #include "wx/strvararg.h"
  18
  19 #include "wx/string.h"
  20
  21 // ----------------------------------------------------------------------------
  22 // CRT functions aliases
  23 // ----------------------------------------------------------------------------
  24
  25 /* Required for wxPrintf() etc */
  26 #include <stdarg.h>
  27
  28 #ifdef wxHAVE_TCHAR_SUPPORT
  29     #define  wxCRT_Fprintf   _ftprintf
  30     #define  wxCRT_Printf    _tprintf
  31     #define  wxCRT_Scanf     _tscanf
  32
  33     #define  wxCRT_Sscanf    _stscanf
  34     #define  wxCRT_Vfprintf  _vftprintf
  35     #define  wxCRT_Vprintf   _vtprintf
  36     #define  wxCRT_Vsscanf   _vstscanf
  37     #define  wxCRT_Vsprintf  _vstprintf
  38
  39 #else /* !TCHAR-aware compilers */
  40
  41     #if !wxUSE_UNICODE /* ASCII */
  42         #define  wxCRT_Fprintf   fprintf
  43         #define  wxCRT_Fscanf    fscanf
  44         #define  wxCRT_Printf    printf
  45         #define  wxCRT_Scanf     scanf
  46         #define  wxCRT_Sscanf    sscanf
  47         #define  wxCRT_Vfprintf  vfprintf
  48         #define  wxCRT_Vprintf   vprintf
  49         #define  wxCRT_Vsscanf   vsscanf
  50         #define  wxCRT_Vsprintf  vsprintf
  51     #endif /* ASCII */
  52 #endif /* TCHAR-aware compilers/the others */
  53
  54 /* printf() family saga */
  55
  56 /*
  57    For some systems [v]snprintf() exists in the system libraries but not in the
  58    headers, so we need to declare it ourselves to be able to use it.
  59  */
  60 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
  61 #ifdef __cplusplus
  62     extern "C"
  63 #else
  64     extern
  65 #endif
  66     int vsnprintf(char *str, size_t size, const char *format, va_list ap);
  67 #endif /* !HAVE_VSNPRINTF_DECL */
  68
  69 #if defined(HAVE_SNPRINTF) && !defined(HAVE_SNPRINTF_DECL)
  70 #ifdef __cplusplus
  71     extern "C"
  72 #else
  73     extern
  74 #endif
  75     WXDLLIMPEXP_BASE int snprintf(char *str, size_t size, const char *format, ...);
  76 #endif /* !HAVE_SNPRINTF_DECL */
  77
  78 /* Wrapper for vsnprintf if it's 3rd parameter is non-const. Note: the
  79  * same isn't done for snprintf below, the builtin wxSnprintf_ is used
  80  * instead since it's already a simple wrapper */
  81 #if defined __cplusplus && defined HAVE_BROKEN_VSNPRINTF_DECL
  82     inline int wx_fixed_vsnprintf(char *str, size_t size, const char *format, va_list ap)
  83     {
  84         return vsnprintf(str, size, (char*)format, ap);
  85     }
  86 #endif
  87
  88 /*
  89    MinGW MSVCRT has non-standard vswprintf() (for MSVC compatibility
  90    presumably) and normally _vsnwprintf() is used instead
  91  */
  92 #if defined(HAVE_VSWPRINTF) && defined(__MINGW32__)
  93     #undef HAVE_VSWPRINTF
  94 #endif
  95
  96 #if wxUSE_PRINTF_POS_PARAMS
  97     /*
  98         The systems where vsnprintf() supports positional parameters should
  99         define the HAVE_UNIX98_PRINTF symbol.
 100
 101         On systems which don't (e.g. Windows) we are forced to use
 102         our wxVsnprintf() implementation.
 103     */
 104     #if defined(HAVE_UNIX98_PRINTF)
 105         #if wxUSE_UNICODE
 106             #ifdef HAVE_VSWPRINTF
 107                 #define wxVsnprintf_        vswprintf
 108             #endif
 109         #else /* ASCII */
 110             #ifdef HAVE_BROKEN_VSNPRINTF_DECL
 111                 #define wxVsnprintf_    wx_fixed_vsnprintf
 112             #else
 113                 #define wxVsnprintf_    vsnprintf
 114             #endif
 115         #endif
 116     #else /* !HAVE_UNIX98_PRINTF */
 117         /*
 118             The only compiler with positional parameters support under Windows
 119             is VC++ 8.0 which provides a new xxprintf_p() functions family.
 120             The 2003 PSDK includes a slightly earlier version of VC8 than the
 121             main release and does not have the printf_p functions.
 122          */
 123         #if defined _MSC_FULL_VER && _MSC_FULL_VER >= 140050727 && !defined __WXWINCE__
 124             #if wxUSE_UNICODE
 125                 #define wxVsnprintf_    _vswprintf_p
 126             #else
 127                 #define wxVsnprintf_    _vsprintf_p
 128             #endif
 129         #endif
 130     #endif /* HAVE_UNIX98_PRINTF/!HAVE_UNIX98_PRINTF */
 131 #else /* !wxUSE_PRINTF_POS_PARAMS */
 132     /*
 133        We always want to define safe snprintf() function to be used instead of
 134        sprintf(). Some compilers already have it (or rather vsnprintf() which
 135        we really need...), otherwise we implement it using our own printf()
 136        code.
 137
 138        We define function with a trailing underscore here because the real one
 139        is a wrapper around it as explained below
 140      */
 141
 142     /* first deal with TCHAR-aware compilers which have _vsntprintf */
 143     #ifndef wxVsnprintf_
 144         #if defined(__VISUALC__) || \
 145                 (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
 146             #define wxVsnprintf_    _vsntprintf
 147         #endif
 148     #endif
 149
 150     /* if this didn't work, define it separately for Unicode and ANSI builds */
 151     #ifndef wxVsnprintf_
 152         #if wxUSE_UNICODE
 153             #if defined(HAVE__VSNWPRINTF)
 154                 #define wxVsnprintf_    _vsnwprintf
 155             #elif defined(HAVE_VSWPRINTF)
 156                 #define wxVsnprintf_     vswprintf
 157             #elif defined(__WATCOMC__)
 158                 #define wxVsnprintf_    _vsnwprintf
 159             #endif
 160         #else /* ASCII */
 161             /*
 162                All versions of CodeWarrior supported by wxWidgets apparently
 163                have both snprintf() and vsnprintf()
 164              */
 165             #if defined(HAVE_VSNPRINTF) \
 166                 || defined(__MWERKS__) || defined(__WATCOMC__)
 167                 #ifdef HAVE_BROKEN_VSNPRINTF_DECL
 168                     #define wxVsnprintf_    wx_fixed_vsnprintf
 169                 #else
 170                     #define wxVsnprintf_    vsnprintf
 171                 #endif
 172             #endif
 173         #endif /* Unicode/ASCII */
 174     #endif /* wxVsnprintf_ */
 175 #endif /* wxUSE_PRINTF_POS_PARAMS/!wxUSE_PRINTF_POS_PARAMS */
 176
 177 #ifndef wxVsnprintf_
 178     /* no (suitable) vsnprintf(), cook our own */
 179     WXDLLIMPEXP_BASE int
 180     wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format, va_list argptr);
 181
 182     #define wxUSE_WXVSNPRINTF 1
 183 #else
 184     #define wxUSE_WXVSNPRINTF 0
 185 #endif
 186
 187 /*
 188    In Unicode mode we need to have all standard functions such as wprintf() and
 189    so on but not all systems have them so use our own implementations in this
 190    case.
 191  */
 192 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
 193     #define wxNEED_WPRINTF
 194 #endif
 195
 196 /*
 197    More Unicode complications: although both ANSI C and C++ define a number of
 198    wide character functions such as wprintf(), not all environments have them.
 199    Worse, those which do have different behaviours: under Windows, %s format
 200    specifier changes its meaning in Unicode build and expects a Unicode string
 201    while under Unix/POSIX it still means an ASCII string even for wprintf() and
 202    %ls has to be used for wide strings.
 203
 204    We choose to always emulate Windows behaviour as more useful for us so even
 205    if we have wprintf() we still must wrap it in a non trivial wxPrintf().
 206
 207 */
 208
 209 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
 210     /*
 211         we need to implement all wide character printf and scanf functions
 212         either because we don't have them at all or because they don't have the
 213         semantics we need
 214      */
 215     int wxCRT_Scanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
 216     int wxCRT_Sscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 217     int wxCRT_Fscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 218     int wxCRT_Vsscanf( const wxChar *str, const wxChar *format, va_list ap );
 219     int wxCRT_Printf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
 220     int wxCRT_Fprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
 221     int wxCRT_Vfprintf( FILE *stream, const wxChar *format, va_list ap );
 222     int wxCRT_Vprintf( const wxChar *format, va_list ap );
 223     int wxCRT_Vsprintf( wxChar *str, const wxChar *format, va_list ap );
 224 #endif /* wxNEED_PRINTF_CONVERSION */
 225
 226 /* these 2 can be simply mapped to the versions with underscore at the end */
 227 /* if we don't have to do the conversion */
 228 /*
 229    However, if we don't have any vswprintf() at all we don't need to redefine
 230    anything as our own wxVsnprintf_() already behaves as needed.
 231 */
 232 #if defined(wxNEED_PRINTF_CONVERSION) && defined(wxVsnprintf_)
 233     int wxCRT_Vsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap );
 234 #else
 235     #define wxCRT_Vsnprintf wxVsnprintf_
 236 #endif
 237
 238
 239 // ----------------------------------------------------------------------------
 240 // user-friendly wrappers to CRT functions
 241 // ----------------------------------------------------------------------------
 242
 243 #ifdef __WATCOMC__
 244     // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 245     #define wxPrintf    wxPrintf_Impl
 246     #define wxFprintf   wxFprintf_Impl
 247     #define wxSprintf   wxSprintf_Impl
 248     #define wxSnprintf  wxSnprintf_Impl
 249 #endif
 250
 251 // FIXME-UTF8: explicit wide-string and short-string format specifiers
 252 //             (%hs, %ls and variants) are currently broken, only %s works
 253 //             as expected (regardless of the build)
 254
 255 // FIXME-UTF8: %c (and %hc, %lc) don't work as expected either: in UTF-8 build,
 256 //             we should replace them with %s (as some Unicode chars may be
 257 //             encoded with >1 bytes) and in all builds, we should use wchar_t
 258 //             for all characters and convert char to it;
 259 //             we'll also need wxArgNormalizer<T> specializations for char,
 260 //             wchar_t, wxUniChar and wxUniCharRef to handle this correctly
 261
 262 WX_DEFINE_VARARG_FUNC(int, wxPrintf, 1, (const wxString&),
 263                       wxCRT_Printf, printf)
 264 WX_DEFINE_VARARG_FUNC(int, wxFprintf, 2, (FILE*, const wxString&),
 265                       wxCRT_Fprintf, fprintf)
 266
 267 // va_list versions of printf functions simply forward to the respective
 268 // CRT function; note that they assume that va_list was created using
 269 // wxArgNormalizer<T>!
 270 #if wxUSE_UNICODE_UTF8
 271     #if wxUSE_UTF8_LOCALE_ONLY
 272         #define WX_VARARG_VFOO_IMPL(args, implWchar, implUtf8)              \
 273             return implUtf8 args
 274     #else
 275         #define WX_VARARG_VFOO_IMPL(args, implWchar, implUtf8)              \
 276             if ( wxLocaleIsUtf8 ) return implUtf8 args;                     \
 277             else return implWchar args
 278     #endif
 279 #else // wxUSE_UNICODE_WCHAR / ANSI
 280     #define WX_VARARG_VFOO_IMPL(args, implWchar, implUtf8)                  \
 281         return implWchar args
 282 #endif
 283
 284 inline int
 285 wxVprintf(const wxString& format, va_list ap)
 286 {
 287     WX_VARARG_VFOO_IMPL((format, ap), wxCRT_Vprintf, vprintf);
 288 }
 289
 290 inline int
 291 wxVfprintf(FILE *f, const wxString& format, va_list ap)
 292 {
 293     WX_VARARG_VFOO_IMPL((f, format, ap), wxCRT_Vfprintf, vfprintf);
 294 }
 295
 296 #undef WX_VARARG_VFOO_IMPL
 297
 298
 299 // wxSprintf() and friends have to be implemented in two forms, one for
 300 // writing to char* buffer and one for writing to wchar_t*:
 301
 302 #if !wxUSE_UTF8_LOCALE_ONLY
 303 int WXDLLIMPEXP_BASE wxDoSprintfWchar(char *str, const wxChar *format, ...);
 304 #endif
 305 #if wxUSE_UNICODE_UTF8
 306 int WXDLLIMPEXP_BASE wxDoSprintfUtf8(char *str, const char *format, ...);
 307 #endif
 308 WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (char*, const wxString&),
 309                       wxDoSprintfWchar, wxDoSprintfUtf8)
 310
 311 int WXDLLIMPEXP_BASE
 312 wxVsprintf(char *str, const wxString& format, va_list argptr);
 313
 314 #if !wxUSE_UTF8_LOCALE_ONLY
 315 int WXDLLIMPEXP_BASE wxDoSnprintfWchar(char *str, size_t size, const wxChar *format, ...);
 316 #endif
 317 #if wxUSE_UNICODE_UTF8
 318 int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(char *str, size_t size, const char *format, ...);
 319 #endif
 320 WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (char*, size_t, const wxString&),
 321                       wxDoSnprintfWchar, wxDoSnprintfUtf8)
 322
 323 int WXDLLIMPEXP_BASE
 324 wxVsnprintf(char *str, size_t size, const wxString& format, va_list argptr);
 325
 326 #if wxUSE_UNICODE
 327
 328 #if !wxUSE_UTF8_LOCALE_ONLY
 329 int WXDLLIMPEXP_BASE wxDoSprintfWchar(wchar_t *str, const wxChar *format, ...);
 330 #endif
 331 #if wxUSE_UNICODE_UTF8
 332 int WXDLLIMPEXP_BASE wxDoSprintfUtf8(wchar_t *str, const char *format, ...);
 333 #endif
 334 WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (wchar_t*, const wxString&),
 335                       wxDoSprintfWchar, wxDoSprintfUtf8)
 336
 337 int WXDLLIMPEXP_BASE
 338 wxVsprintf(wchar_t *str, const wxString& format, va_list argptr);
 339
 340 #if !wxUSE_UTF8_LOCALE_ONLY
 341 int WXDLLIMPEXP_BASE wxDoSnprintfWchar(wchar_t *str, size_t size, const wxChar *format, ...);
 342 #endif
 343 #if wxUSE_UNICODE_UTF8
 344 int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...);
 345 #endif
 346 WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (wchar_t*, size_t, const wxString&),
 347                       wxDoSnprintfWchar, wxDoSnprintfUtf8)
 348
 349 int WXDLLIMPEXP_BASE
 350 wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argptr);
 351
 352 #endif // wxUSE_UNICODE
 353
 354 #ifdef __WATCOMC__
 355     // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 356     //
 357     // fortunately, OpenWatcom implements __VA_ARGS__, so we can provide macros
 358     // that cast the format argument to wxString:
 359     #undef wxPrintf
 360     #undef wxFprintf
 361     #undef wxSprintf
 362     #undef wxSnprintf
 363
 364     #define wxPrintf(fmt, ...) \
 365             wxPrintf_Impl(wxString(fmt), __VA_ARGS__)
 366     #define wxFprintf(f, fmt, ...) \
 367             wxFprintf_Impl(f, wxString(fmt), __VA_ARGS__)
 368     #define wxSprintf(s, fmt, ...) \
 369             wxSprintf_Impl(s, wxString(fmt), __VA_ARGS__)
 370     #define wxSnprintf(s, n, fmt, ...) \
 371             wxSnprintf_Impl(s, n, wxString(fmt), __VA_ARGS__)
 372 #endif // __WATCOMC__
 373
 374
 375 // We can't use wxArgNormalizer<T> for variadic arguments to wxScanf() etc.
 376 // because they are writable, so instead of providing friendly template
 377 // vararg-like functions, we just provide both char* and wchar_t* variants
 378 // of these functions. The type of output variadic arguments for %s must match
 379 // the type of 'str' and 'format' arguments.
 380
 381 // FIXME-UTF8: actually do it, for now we only have wxChar* variants:
 382 #define wxScanf   wxCRT_Scanf
 383 #define wxFscanf  wxCRT_Fscanf
 384 #define wxSscanf  wxCRT_Sscanf
 385 #define wxVsscanf wxCRT_Vsscanf
 386
 387 #endif /* _WX_WXCRTVARARG_H_ */