include/wx/strvararg.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/strvararg.h
   3 // Purpose:     macros for implementing type-safe vararg passing of strings
   4 // Author:      Vaclav Slavik
   5 // Created:     2007-02-19
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2007 REA Elektronik GmbH
   8 // Licence:     wxWindows licence
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef _WX_STRVARARG_H_
  12 #define _WX_STRVARARG_H_
  13
  14 #include "wx/platform.h"
  15 #if wxONLY_WATCOM_EARLIER_THAN(1,4)
  16     #error "OpenWatcom version >= 1.4 is required to compile this code"
  17 #endif
  18
  19 #include "wx/cpp.h"
  20 #include "wx/chartype.h"
  21 #include "wx/strconv.h"
  22 #include "wx/buffer.h"
  23 #include "wx/unichar.h"
  24
  25 class WXDLLIMPEXP_FWD_BASE wxCStrData;
  26 class WXDLLIMPEXP_FWD_BASE wxString;
  27
  28 // ----------------------------------------------------------------------------
  29 // WX_DEFINE_VARARG_FUNC* macros
  30 // ----------------------------------------------------------------------------
  31
  32 // This macro is used to implement type-safe wrappers for variadic functions
  33 // that accept strings as arguments. This makes it possible to pass char*,
  34 // wchar_t* or even wxString (as opposed to having to use wxString::c_str())
  35 // to e.g. wxPrintf().
  36 //
  37 // This is done by defining a set of N template function taking 1..N arguments
  38 // (currently, N is set to 30 in this header). These functions are just thin
  39 // wrappers around another variadic function ('impl' or 'implUtf8' arguments,
  40 // see below) and the only thing the wrapper does is that it normalizes the
  41 // arguments passed in so that they are of the type expected by variadic
  42 // functions taking string arguments, i.e., char* or wchar_t*, depending on the
  43 // build:
  44 //   * char* in the current locale's charset in ANSI build
  45 //   * char* with UTF-8 encoding if wxUSE_UNICODE_UTF8 and the app is running
  46 //     under an UTF-8 locale
  47 //   * wchar_t* if wxUSE_UNICODE_WCHAR or if wxUSE_UNICODE_UTF8 and the current
  48 //     locale is not UTF-8
  49 //
  50 // Note that wxFormatString *must* be used for the format parameter of these
  51 // functions, otherwise the implementation won't work correctly. Furthermore,
  52 // it must be passed by value, not reference, because it's modified by the
  53 // vararg templates internally.
  54 //
  55 // Parameters:
  56 // [ there are examples in square brackets showing values of the parameters
  57 //   for the wxFprintf() wrapper for fprintf() function with the following
  58 //   prototype:
  59 //   int wxFprintf(FILE *stream, const wxString& format, ...); ]
  60 //
  61 //        rettype   Functions' return type  [int]
  62 //        name      Name of the function  [fprintf]
  63 //        numfixed  The number of leading "fixed" (i.e., not variadic)
  64 //                  arguments of the function (e.g. "stream" and "format"
  65 //                  arguments of fprintf()); their type is _not_ converted
  66 //                  using wxArgNormalizer<T>, unlike the rest of
  67 //                  the function's arguments  [2]
  68 //        fixed     List of types of the leading "fixed" arguments, in
  69 //                  parenthesis  [(FILE*,const wxString&)]
  70 //        impl      Name of the variadic function that implements 'name' for
  71 //                  the native strings representation (wchar_t* if
  72 //                  wxUSE_UNICODE_WCHAR or wxUSE_UNICODE_UTF8 when running under
  73 //                  non-UTF8 locale, char* in ANSI build)  [wxCrt_Fprintf]
  74 //        implUtf8  Like 'impl', but for the UTF-8 char* version to be used
  75 //                  if wxUSE_UNICODE_UTF8 and running under UTF-8 locale
  76 //                  (ignored otherwise)  [fprintf]
  77 //
  78 #define WX_DEFINE_VARARG_FUNC(rettype, name, numfixed, fixed, impl, implUtf8) \
  79     _WX_VARARG_DEFINE_FUNC_N0(rettype, name, impl, implUtf8, numfixed, fixed) \
  80     WX_DEFINE_VARARG_FUNC_SANS_N0(rettype, name, numfixed, fixed, impl, implUtf8)
  81
  82 // ditto, but without the version with 0 template/vararg arguments
  83 #define WX_DEFINE_VARARG_FUNC_SANS_N0(rettype, name,                          \
  84                                        numfixed, fixed, impl, implUtf8)       \
  85     _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                      \
  86                     _WX_VARARG_DEFINE_FUNC,                                   \
  87                     rettype, name, impl, implUtf8, numfixed, fixed)
  88
  89 // Like WX_DEFINE_VARARG_FUNC, but for variadic functions that don't return
  90 // a value.
  91 #define WX_DEFINE_VARARG_FUNC_VOID(name, numfixed, fixed, impl, implUtf8)     \
  92     _WX_VARARG_DEFINE_FUNC_VOID_N0(name, impl, implUtf8, numfixed, fixed)     \
  93     _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                      \
  94                     _WX_VARARG_DEFINE_FUNC_VOID,                              \
  95                     void, name, impl, implUtf8, numfixed, fixed)
  96
  97 // Like WX_DEFINE_VARARG_FUNC_VOID, but instead of wrapping an implementation
  98 // function, does nothing in defined functions' bodies.
  99 //
 100 // Used to implement wxLogXXX functions if wxUSE_LOG=0.
 101 #define WX_DEFINE_VARARG_FUNC_NOP(name, numfixed, fixed)                      \
 102         _WX_VARARG_DEFINE_FUNC_NOP_N0(name, numfixed, fixed)                  \
 103         _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                  \
 104                         _WX_VARARG_DEFINE_FUNC_NOP,                           \
 105                         void, name, dummy, dummy, numfixed, fixed)
 106
 107 // Like WX_DEFINE_VARARG_FUNC_CTOR, but for defining template constructors
 108 #define WX_DEFINE_VARARG_FUNC_CTOR(name, numfixed, fixed, impl, implUtf8)     \
 109     _WX_VARARG_DEFINE_FUNC_CTOR_N0(name, impl, implUtf8, numfixed, fixed)     \
 110     _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                      \
 111                     _WX_VARARG_DEFINE_FUNC_CTOR,                              \
 112                     void, name, impl, implUtf8, numfixed, fixed)
 113
 114
 115 // ----------------------------------------------------------------------------
 116 // wxFormatString
 117 // ----------------------------------------------------------------------------
 118
 119 // This class must be used for format string argument of the functions
 120 // defined using WX_DEFINE_VARARG_FUNC_* macros. It converts the string to
 121 // char* or wchar_t* for passing to implementation function efficiently (i.e.
 122 // without keeping the converted string in memory for longer than necessary,
 123 // like c_str()). It also converts format string to the correct form that
 124 // accounts for string changes done by wxArgNormalizer<>
 125 //
 126 // Note that this class can _only_ be used for function arguments!
 127 class WXDLLIMPEXP_BASE wxFormatString
 128 {
 129 public:
 130     wxFormatString(const char *str)
 131         : m_char(wxCharBuffer::CreateNonOwned(str)), m_str(NULL), m_cstr(NULL) {}
 132     wxFormatString(const wchar_t *str)
 133         : m_wchar(wxWCharBuffer::CreateNonOwned(str)), m_str(NULL), m_cstr(NULL) {}
 134     wxFormatString(const wxString& str)
 135         : m_str(&str), m_cstr(NULL) {}
 136     wxFormatString(const wxCStrData& str)
 137         : m_str(NULL), m_cstr(&str) {}
 138     wxFormatString(const wxCharBuffer& str)
 139         : m_char(str), m_str(NULL), m_cstr(NULL)  {}
 140     wxFormatString(const wxWCharBuffer& str)
 141         : m_wchar(str), m_str(NULL), m_cstr(NULL) {}
 142
 143
 144     enum ArgumentType
 145     {
 146         Arg_Char,    // character as char
 147
 148         Arg_Other    // something else, for example int for %d
 149     };
 150
 151     // returns the type of format specifier for n-th variadic argument (this is
 152     // not necessarily n-th format specifier if positional specifiers are used);
 153     // called by wxArgNormalizer<> specializations to get information about
 154     // n-th variadic argument desired representation
 155     ArgumentType GetArgumentType(unsigned n) const;
 156
 157 #if !wxUSE_UNICODE_WCHAR
 158     operator const char*() const
 159         { return const_cast<wxFormatString*>(this)->AsChar(); }
 160 private:
 161     // InputAsChar() returns the value converted passed to ctor, only converted
 162     // to char, while AsChar() takes the the string returned by InputAsChar()
 163     // and does format string conversion on it as well (and similarly for
 164     // ..AsWChar() below)
 165     const char* InputAsChar();
 166     const char* AsChar();
 167     wxCharBuffer m_convertedChar;
 168 #endif // !wxUSE_UNICODE_WCHAR
 169
 170 #if wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 171 public:
 172     operator const wchar_t*() const
 173         { return const_cast<wxFormatString*>(this)->AsWChar(); }
 174 private:
 175     const wchar_t* InputAsWChar();
 176     const wchar_t* AsWChar();
 177     wxWCharBuffer m_convertedWChar;
 178 #endif // wxUSE_UNICODE && !wxUSE_UTF8_LOCALE_ONLY
 179
 180 private:
 181     wxCharBuffer  m_char;
 182     wxWCharBuffer m_wchar;
 183
 184     // NB: we can use a pointer here, because wxFormatString is only used
 185     //     as function argument, so it has shorter life than the string
 186     //     passed to the ctor
 187     const wxString * const m_str;
 188     const wxCStrData * const m_cstr;
 189
 190     DECLARE_NO_ASSIGN_CLASS(wxFormatString)
 191 };
 192
 193 // these two helper classes are used to find wxFormatString argument among fixed
 194 // arguments passed to a vararg template
 195 struct wxFormatStringArgument
 196 {
 197     wxFormatStringArgument(const wxFormatString *s = NULL) : m_str(s) {}
 198     const wxFormatString *m_str;
 199
 200     // overriding this operator allows us to reuse _WX_VARARG_JOIN macro
 201     wxFormatStringArgument operator,(const wxFormatStringArgument& a) const
 202     {
 203         wxASSERT_MSG( m_str == NULL || a.m_str == NULL,
 204                       "can't have two format strings in vararg function" );
 205         return wxFormatStringArgument(m_str ? m_str : a.m_str);
 206     }
 207
 208     operator const wxFormatString*() const { return m_str; }
 209 };
 210
 211 template<typename T>
 212 struct wxFormatStringArgumentFinder
 213 {
 214     static wxFormatStringArgument find(T)
 215     {
 216         // by default, arguments are not format strings, so return "not found"
 217         return wxFormatStringArgument();
 218     }
 219 };
 220
 221 template<>
 222 struct wxFormatStringArgumentFinder<const wxFormatString&>
 223 {
 224     static wxFormatStringArgument find(const wxFormatString& arg)
 225         { return wxFormatStringArgument(&arg); }
 226 };
 227
 228 template<>
 229 struct wxFormatStringArgumentFinder<wxFormatString>
 230     : public wxFormatStringArgumentFinder<const wxFormatString&> {};
 231
 232 // avoid passing big objects by value to wxFormatStringArgumentFinder::find()
 233 // (and especially wx[W]CharBuffer with its auto_ptr<> style semantics!):
 234 template<>
 235 struct wxFormatStringArgumentFinder<wxString>
 236     : public wxFormatStringArgumentFinder<const wxString&> {};
 237
 238 template<>
 239 struct wxFormatStringArgumentFinder<wxCharBuffer>
 240     : public wxFormatStringArgumentFinder<const wxCharBuffer&> {};
 241
 242 template<>
 243 struct wxFormatStringArgumentFinder<wxWCharBuffer>
 244     : public wxFormatStringArgumentFinder<const wxWCharBuffer&> {};
 245
 246
 247 // ----------------------------------------------------------------------------
 248 // wxArgNormalizer*<T> converters
 249 // ----------------------------------------------------------------------------
 250
 251 // Converts an argument passed to wxPrint etc. into standard form expected,
 252 // by wxXXX functions, e.g. all strings (wxString, char*, wchar_t*) are
 253 // converted into wchar_t* or char* depending on the build.
 254 template<typename T>
 255 struct wxArgNormalizer
 256 {
 257     // Ctor. 'value' is the value passed as variadic argument, 'fmt' is pointer
 258     // to printf-like format string or NULL if the variadic function doesn't
 259     // use format string and 'index' is index of 'value' in variadic arguments
 260     // list (starting at 1)
 261     wxArgNormalizer(T value,
 262                     const wxFormatString *WXUNUSED(fmt), unsigned WXUNUSED(index))
 263         : m_value(value) {}
 264
 265     // Returns the value in a form that can be safely passed to real vararg
 266     // functions. In case of strings, this is char* in ANSI build and wchar_t*
 267     // in Unicode build.
 268     T get() const { return m_value; }
 269
 270     T m_value;
 271 };
 272
 273 // normalizer for passing arguments to functions working with wchar_t* (and
 274 // until ANSI build is removed, char* in ANSI build as well - FIXME-UTF8)
 275 // string representation
 276 #if !wxUSE_UTF8_LOCALE_ONLY
 277 template<typename T>
 278 struct wxArgNormalizerWchar : public wxArgNormalizer<T>
 279 {
 280     wxArgNormalizerWchar(T value,
 281                          const wxFormatString *fmt, unsigned index)
 282         : wxArgNormalizer<T>(value, fmt, index) {}
 283 };
 284 #endif // !wxUSE_UTF8_LOCALE_ONLY
 285
 286 // normalizer for passing arguments to functions working with UTF-8 encoded
 287 // char* strings
 288 #if wxUSE_UNICODE_UTF8
 289     template<typename T>
 290     struct wxArgNormalizerUtf8 : public wxArgNormalizer<T>
 291     {
 292         wxArgNormalizerUtf8(T value,
 293                             const wxFormatString *fmt, unsigned index)
 294             : wxArgNormalizer<T>(value, fmt, index) {}
 295     };
 296
 297     #define wxArgNormalizerNative wxArgNormalizerUtf8
 298 #else // wxUSE_UNICODE_WCHAR
 299     #define wxArgNormalizerNative wxArgNormalizerWchar
 300 #endif // wxUSE_UNICODE_UTF8 // wxUSE_UNICODE_UTF8
 301
 302
 303
 304 // special cases for converting strings:
 305
 306
 307 // base class for wxArgNormalizer<T> specializations that need to do conversion;
 308 // CharType is either wxStringCharType or wchar_t in UTF-8 build when wrapping
 309 // widechar CRT function
 310 template<typename CharType>
 311 struct wxArgNormalizerWithBuffer
 312 {
 313     typedef wxCharTypeBuffer<CharType> CharBuffer;
 314
 315     wxArgNormalizerWithBuffer() {}
 316     wxArgNormalizerWithBuffer(const CharBuffer& buf,
 317                               const wxFormatString *WXUNUSED(fmt),
 318                               unsigned WXUNUSED(index))
 319         : m_value(buf) {}
 320
 321     const CharType *get() const { return m_value; }
 322
 323     CharBuffer m_value;
 324 };
 325
 326 // string objects:
 327 template<>
 328 struct WXDLLIMPEXP_BASE wxArgNormalizerNative<const wxString&>
 329 {
 330     wxArgNormalizerNative(const wxString& s,
 331                           const wxFormatString *WXUNUSED(fmt),
 332                           unsigned WXUNUSED(index))
 333         : m_value(s) {}
 334
 335     const wxStringCharType *get() const;
 336
 337     const wxString& m_value;
 338 };
 339
 340 // c_str() values:
 341 template<>
 342 struct WXDLLIMPEXP_BASE wxArgNormalizerNative<const wxCStrData&>
 343 {
 344     wxArgNormalizerNative(const wxCStrData& value,
 345                           const wxFormatString *WXUNUSED(fmt),
 346                           unsigned WXUNUSED(index))
 347         : m_value(value) {}
 348
 349     const wxStringCharType *get() const;
 350
 351     const wxCStrData& m_value;
 352 };
 353
 354 // wxString/wxCStrData conversion to wchar_t* value
 355 #if wxUSE_UNICODE_UTF8 && !wxUSE_UTF8_LOCALE_ONLY
 356 template<>
 357 struct WXDLLIMPEXP_BASE wxArgNormalizerWchar<const wxString&>
 358     : public wxArgNormalizerWithBuffer<wchar_t>
 359 {
 360     wxArgNormalizerWchar(const wxString& s,
 361                          const wxFormatString *fmt, unsigned index);
 362 };
 363
 364 template<>
 365 struct WXDLLIMPEXP_BASE wxArgNormalizerWchar<const wxCStrData&>
 366     : public wxArgNormalizerWithBuffer<wchar_t>
 367 {
 368     wxArgNormalizerWchar(const wxCStrData& s,
 369                          const wxFormatString *fmt, unsigned index);
 370 };
 371 #endif // wxUSE_UNICODE_UTF8 && !wxUSE_UTF8_LOCALE_ONLY
 372
 373
 374 // C string pointers of the wrong type (wchar_t* for ANSI or UTF8 build,
 375 // char* for wchar_t Unicode build or UTF8):
 376 #if wxUSE_UNICODE_WCHAR
 377
 378 template<>
 379 struct wxArgNormalizerWchar<const char*>
 380     : public wxArgNormalizerWithBuffer<wchar_t>
 381 {
 382     wxArgNormalizerWchar(const char* s,
 383                          const wxFormatString *fmt, unsigned index)
 384         : wxArgNormalizerWithBuffer<wchar_t>(wxConvLibc.cMB2WC(s), fmt, index) {}
 385 };
 386
 387 #elif wxUSE_UNICODE_UTF8
 388
 389 template<>
 390 struct wxArgNormalizerUtf8<const wchar_t*>
 391     : public wxArgNormalizerWithBuffer<char>
 392 {
 393     wxArgNormalizerUtf8(const wchar_t* s,
 394                         const wxFormatString *fmt, unsigned index)
 395         : wxArgNormalizerWithBuffer<char>(wxConvUTF8.cWC2MB(s), fmt, index) {}
 396 };
 397
 398 template<>
 399 struct wxArgNormalizerUtf8<const char*>
 400     : public wxArgNormalizerWithBuffer<char>
 401 {
 402     wxArgNormalizerUtf8(const char* s,
 403                         const wxFormatString *WXUNUSED(fmt),
 404                         unsigned WXUNUSED(index))
 405     {
 406         if ( wxLocaleIsUtf8 )
 407         {
 408             m_value = wxCharBuffer::CreateNonOwned(s);
 409         }
 410         else
 411         {
 412             // convert to widechar string first:
 413             wxWCharBuffer buf(wxConvLibc.cMB2WC(s));
 414
 415             // then to UTF-8:
 416             if ( buf )
 417                 m_value = wxConvUTF8.cWC2MB(buf);
 418         }
 419     }
 420 };
 421
 422 // UTF-8 build needs conversion to wchar_t* too:
 423 #if !wxUSE_UTF8_LOCALE_ONLY
 424 template<>
 425 struct wxArgNormalizerWchar<const char*>
 426     : public wxArgNormalizerWithBuffer<wchar_t>
 427 {
 428     wxArgNormalizerWchar(const char* s,
 429                          const wxFormatString *fmt, unsigned index)
 430         : wxArgNormalizerWithBuffer<wchar_t>(wxConvLibc.cMB2WC(s), fmt, index) {}
 431 };
 432 #endif // !wxUSE_UTF8_LOCALE_ONLY
 433
 434 #else // ANSI - FIXME-UTF8
 435
 436 template<>
 437 struct wxArgNormalizerWchar<const wchar_t*>
 438     : public wxArgNormalizerWithBuffer<char>
 439 {
 440     wxArgNormalizerWchar(const wchar_t* s,
 441                          const wxFormatString *fmt, unsigned index)
 442         : wxArgNormalizerWithBuffer<char>(wxConvLibc.cWC2MB(s), fmt, index) {}
 443 };
 444
 445 #endif // wxUSE_UNICODE_WCHAR/wxUSE_UNICODE_UTF8/ANSI
 446
 447
 448 // this macro is used to implement specialization that are exactly same as
 449 // some other specialization, i.e. to "forward" the implementation (e.g. for
 450 // T=wxString and T=const wxString&). Note that the ctor takes BaseT argument,
 451 // not T!
 452 #if wxUSE_UNICODE_UTF8
 453     #if wxUSE_UTF8_LOCALE_ONLY
 454         #define WX_ARG_NORMALIZER_FORWARD(T, BaseT)                         \
 455           _WX_ARG_NORMALIZER_FORWARD_IMPL(wxArgNormalizerUtf8, T, BaseT)
 456     #else // possibly non-UTF8 locales
 457         #define WX_ARG_NORMALIZER_FORWARD(T, BaseT)                         \
 458           _WX_ARG_NORMALIZER_FORWARD_IMPL(wxArgNormalizerWchar, T, BaseT);  \
 459           _WX_ARG_NORMALIZER_FORWARD_IMPL(wxArgNormalizerUtf8, T, BaseT)
 460     #endif
 461 #else // wxUSE_UNICODE_WCHAR
 462     #define WX_ARG_NORMALIZER_FORWARD(T, BaseT)                             \
 463         _WX_ARG_NORMALIZER_FORWARD_IMPL(wxArgNormalizerWchar, T, BaseT)
 464 #endif // wxUSE_UNICODE_UTF8/wxUSE_UNICODE_WCHAR
 465
 466 #define _WX_ARG_NORMALIZER_FORWARD_IMPL(Normalizer, T, BaseT)               \
 467     template<>                                                              \
 468     struct Normalizer<T> : public Normalizer<BaseT>                         \
 469     {                                                                       \
 470         Normalizer(BaseT value,                                             \
 471                    const wxFormatString *fmt, unsigned index)               \
 472             : Normalizer<BaseT>(value, fmt, index) {}                       \
 473     }
 474
 475 // non-reference versions of specializations for string objects
 476 WX_ARG_NORMALIZER_FORWARD(wxString, const wxString&);
 477 WX_ARG_NORMALIZER_FORWARD(wxCStrData, const wxCStrData&);
 478
 479 // versions for passing non-const pointers:
 480 WX_ARG_NORMALIZER_FORWARD(char*, const char*);
 481 WX_ARG_NORMALIZER_FORWARD(wchar_t*, const wchar_t*);
 482
 483 // versions for passing wx[W]CharBuffer:
 484 WX_ARG_NORMALIZER_FORWARD(wxCharBuffer, const char*);
 485 WX_ARG_NORMALIZER_FORWARD(const wxCharBuffer&, const char*);
 486 WX_ARG_NORMALIZER_FORWARD(wxWCharBuffer, const wchar_t*);
 487 WX_ARG_NORMALIZER_FORWARD(const wxWCharBuffer&, const wchar_t*);
 488
 489 // versions for std::[w]string:
 490 #if wxUSE_STD_STRING
 491
 492 #include "wx/stringimpl.h"
 493
 494 #if !wxUSE_UTF8_LOCALE_ONLY
 495 template<>
 496 struct wxArgNormalizerWchar<const std::string&>
 497     : public wxArgNormalizerWchar<const char*>
 498 {
 499     wxArgNormalizerWchar(const std::string& s,
 500                          const wxFormatString *fmt, unsigned index)
 501         : wxArgNormalizerWchar<const char*>(s.c_str(), fmt, index) {}
 502 };
 503
 504 template<>
 505 struct wxArgNormalizerWchar<const wxStdWideString&>
 506     : public wxArgNormalizerWchar<const wchar_t*>
 507 {
 508     wxArgNormalizerWchar(const wxStdWideString& s,
 509                          const wxFormatString *fmt, unsigned index)
 510         : wxArgNormalizerWchar<const wchar_t*>(s.c_str(), fmt, index) {}
 511 };
 512 #endif // !wxUSE_UTF8_LOCALE_ONLY
 513
 514 #if wxUSE_UNICODE_UTF8
 515 template<>
 516 struct wxArgNormalizerUtf8<const std::string&>
 517     : public wxArgNormalizerUtf8<const char*>
 518 {
 519     wxArgNormalizerUtf8(const std::string& s,
 520                         const wxFormatString *fmt, unsigned index)
 521         : wxArgNormalizerUtf8<const char*>(s.c_str(), fmt, index) {}
 522 };
 523
 524 template<>
 525 struct wxArgNormalizerUtf8<const wxStdWideString&>
 526     : public wxArgNormalizerUtf8<const wchar_t*>
 527 {
 528     wxArgNormalizerUtf8(const wxStdWideString& s,
 529                         const wxFormatString *fmt, unsigned index)
 530         : wxArgNormalizerUtf8<const wchar_t*>(s.c_str(), fmt, index) {}
 531 };
 532 #endif // wxUSE_UNICODE_UTF8
 533
 534 WX_ARG_NORMALIZER_FORWARD(std::string, const std::string&);
 535 WX_ARG_NORMALIZER_FORWARD(wxStdWideString, const wxStdWideString&);
 536
 537 #endif // wxUSE_STD_STRING
 538
 539
 540 // versions for wxUniChar, wxUniCharRef:
 541 // (this is same for UTF-8 and Wchar builds, we just convert to wchar_t)
 542 template<>
 543 struct wxArgNormalizer<const wxUniChar&> : public wxArgNormalizer<wchar_t>
 544 {
 545     wxArgNormalizer(const wxUniChar& s,
 546                     const wxFormatString *fmt, unsigned index)
 547         : wxArgNormalizer<wchar_t>(s.GetValue(), fmt, index) {}
 548 };
 549
 550 // for wchar_t, default handler does the right thing
 551
 552 // char has to be treated differently in Unicode builds: a char argument may
 553 // be used either for a character value (which should be converted into
 554 // wxUniChar) or as an integer value (which should be left as-is). We take
 555 // advantage of the fact that both char and wchar_t are converted into int
 556 // in variadic arguments here.
 557 #if wxUSE_UNICODE
 558 template<typename T>
 559 struct wxArgNormalizerNarrowChar
 560 {
 561     wxArgNormalizerNarrowChar(T value,
 562                               const wxFormatString *fmt, unsigned index)
 563     {
 564         // FIXME-UTF8: which one is better default in absence of fmt string
 565         //             (i.e. when used like e.g. Foo("foo", "bar", 'c', NULL)?
 566         if ( !fmt || fmt->GetArgumentType(index) == wxFormatString::Arg_Char )
 567             m_value = wx_truncate_cast(T, wxUniChar(value).GetValue());
 568         else
 569             m_value = value;
 570     }
 571
 572     int get() const { return m_value; }
 573
 574     T m_value;
 575 };
 576
 577 template<>
 578 struct wxArgNormalizer<char> : public wxArgNormalizerNarrowChar<char>
 579 {
 580     wxArgNormalizer(char value,
 581                     const wxFormatString *fmt, unsigned index)
 582         : wxArgNormalizerNarrowChar<char>(value, fmt, index) {}
 583 };
 584
 585 template<>
 586 struct wxArgNormalizer<unsigned char>
 587     : public wxArgNormalizerNarrowChar<unsigned char>
 588 {
 589     wxArgNormalizer(unsigned char value,
 590                     const wxFormatString *fmt, unsigned index)
 591         : wxArgNormalizerNarrowChar<unsigned char>(value, fmt, index) {}
 592 };
 593
 594 #endif // wxUSE_UNICODE
 595
 596 // convert references:
 597 WX_ARG_NORMALIZER_FORWARD(wxUniChar, const wxUniChar&);
 598 WX_ARG_NORMALIZER_FORWARD(const wxUniCharRef&, const wxUniChar&);
 599 WX_ARG_NORMALIZER_FORWARD(wxUniCharRef, const wxUniChar&);
 600 WX_ARG_NORMALIZER_FORWARD(const wchar_t&, wchar_t);
 601
 602 WX_ARG_NORMALIZER_FORWARD(const char&, char);
 603 WX_ARG_NORMALIZER_FORWARD(const unsigned char&, unsigned char);
 604
 605
 606 #undef WX_ARG_NORMALIZER_FORWARD
 607 #undef _WX_ARG_NORMALIZER_FORWARD_IMPL
 608
 609 // ----------------------------------------------------------------------------
 610 // WX_VA_ARG_STRING
 611 // ----------------------------------------------------------------------------
 612
 613 // Replacement for va_arg() for use with strings in functions that accept
 614 // strings normalized by wxArgNormalizer<T>:
 615
 616 struct WXDLLIMPEXP_BASE wxArgNormalizedString
 617 {
 618     wxArgNormalizedString(const void* ptr) : m_ptr(ptr) {}
 619
 620     // returns true if non-NULL string was passed in
 621     bool IsValid() const { return m_ptr != NULL; }
 622     operator bool() const { return IsValid(); }
 623
 624     // extracts the string, returns empty string if NULL was passed in
 625     wxString GetString() const;
 626     operator wxString() const;
 627
 628 private:
 629     const void *m_ptr;
 630 };
 631
 632 #define WX_VA_ARG_STRING(ap) wxArgNormalizedString(va_arg(ap, const void*))
 633
 634 // ----------------------------------------------------------------------------
 635 // implementation of the WX_DEFINE_VARARG_* macros
 636 // ----------------------------------------------------------------------------
 637
 638 // NB: The vararg emulation code is limited to 30 variadic and 4 fixed
 639 //     arguments at the moment.
 640 //     If you need more variadic arguments, you need to
 641 //        1) increase the value of _WX_VARARG_MAX_ARGS
 642 //        2) add _WX_VARARG_JOIN_* and _WX_VARARG_ITER_* up to the new
 643 //           _WX_VARARG_MAX_ARGS value to the lists below
 644 //     If you need more fixed arguments, you need to
 645 //        1) increase the value of _WX_VARARG_MAX_FIXED_ARGS
 646 //        2) add _WX_VARARG_FIXED_EXPAND_* and _WX_VARARG_FIXED_UNUSED_EXPAND_*
 647 //           macros below
 648 #define _WX_VARARG_MAX_ARGS        30
 649 #define _WX_VARARG_MAX_FIXED_ARGS   4
 650
 651 #define _WX_VARARG_JOIN_1(m)                                 m(1)
 652 #define _WX_VARARG_JOIN_2(m)       _WX_VARARG_JOIN_1(m),     m(2)
 653 #define _WX_VARARG_JOIN_3(m)       _WX_VARARG_JOIN_2(m),     m(3)
 654 #define _WX_VARARG_JOIN_4(m)       _WX_VARARG_JOIN_3(m),     m(4)
 655 #define _WX_VARARG_JOIN_5(m)       _WX_VARARG_JOIN_4(m),     m(5)
 656 #define _WX_VARARG_JOIN_6(m)       _WX_VARARG_JOIN_5(m),     m(6)
 657 #define _WX_VARARG_JOIN_7(m)       _WX_VARARG_JOIN_6(m),     m(7)
 658 #define _WX_VARARG_JOIN_8(m)       _WX_VARARG_JOIN_7(m),     m(8)
 659 #define _WX_VARARG_JOIN_9(m)       _WX_VARARG_JOIN_8(m),     m(9)
 660 #define _WX_VARARG_JOIN_10(m)      _WX_VARARG_JOIN_9(m),     m(10)
 661 #define _WX_VARARG_JOIN_11(m)      _WX_VARARG_JOIN_10(m),    m(11)
 662 #define _WX_VARARG_JOIN_12(m)      _WX_VARARG_JOIN_11(m),    m(12)
 663 #define _WX_VARARG_JOIN_13(m)      _WX_VARARG_JOIN_12(m),    m(13)
 664 #define _WX_VARARG_JOIN_14(m)      _WX_VARARG_JOIN_13(m),    m(14)
 665 #define _WX_VARARG_JOIN_15(m)      _WX_VARARG_JOIN_14(m),    m(15)
 666 #define _WX_VARARG_JOIN_16(m)      _WX_VARARG_JOIN_15(m),    m(16)
 667 #define _WX_VARARG_JOIN_17(m)      _WX_VARARG_JOIN_16(m),    m(17)
 668 #define _WX_VARARG_JOIN_18(m)      _WX_VARARG_JOIN_17(m),    m(18)
 669 #define _WX_VARARG_JOIN_19(m)      _WX_VARARG_JOIN_18(m),    m(19)
 670 #define _WX_VARARG_JOIN_20(m)      _WX_VARARG_JOIN_19(m),    m(20)
 671 #define _WX_VARARG_JOIN_21(m)      _WX_VARARG_JOIN_20(m),    m(21)
 672 #define _WX_VARARG_JOIN_22(m)      _WX_VARARG_JOIN_21(m),    m(22)
 673 #define _WX_VARARG_JOIN_23(m)      _WX_VARARG_JOIN_22(m),    m(23)
 674 #define _WX_VARARG_JOIN_24(m)      _WX_VARARG_JOIN_23(m),    m(24)
 675 #define _WX_VARARG_JOIN_25(m)      _WX_VARARG_JOIN_24(m),    m(25)
 676 #define _WX_VARARG_JOIN_26(m)      _WX_VARARG_JOIN_25(m),    m(26)
 677 #define _WX_VARARG_JOIN_27(m)      _WX_VARARG_JOIN_26(m),    m(27)
 678 #define _WX_VARARG_JOIN_28(m)      _WX_VARARG_JOIN_27(m),    m(28)
 679 #define _WX_VARARG_JOIN_29(m)      _WX_VARARG_JOIN_28(m),    m(29)
 680 #define _WX_VARARG_JOIN_30(m)      _WX_VARARG_JOIN_29(m),    m(30)
 681
 682 #define _WX_VARARG_ITER_1(m,a,b,c,d,e,f)                                    m(1,a,b,c,d,e,f)
 683 #define _WX_VARARG_ITER_2(m,a,b,c,d,e,f)  _WX_VARARG_ITER_1(m,a,b,c,d,e,f)  m(2,a,b,c,d,e,f)
 684 #define _WX_VARARG_ITER_3(m,a,b,c,d,e,f)  _WX_VARARG_ITER_2(m,a,b,c,d,e,f)  m(3,a,b,c,d,e,f)
 685 #define _WX_VARARG_ITER_4(m,a,b,c,d,e,f)  _WX_VARARG_ITER_3(m,a,b,c,d,e,f)  m(4,a,b,c,d,e,f)
 686 #define _WX_VARARG_ITER_5(m,a,b,c,d,e,f)  _WX_VARARG_ITER_4(m,a,b,c,d,e,f)  m(5,a,b,c,d,e,f)
 687 #define _WX_VARARG_ITER_6(m,a,b,c,d,e,f)  _WX_VARARG_ITER_5(m,a,b,c,d,e,f)  m(6,a,b,c,d,e,f)
 688 #define _WX_VARARG_ITER_7(m,a,b,c,d,e,f)  _WX_VARARG_ITER_6(m,a,b,c,d,e,f)  m(7,a,b,c,d,e,f)
 689 #define _WX_VARARG_ITER_8(m,a,b,c,d,e,f)  _WX_VARARG_ITER_7(m,a,b,c,d,e,f)  m(8,a,b,c,d,e,f)
 690 #define _WX_VARARG_ITER_9(m,a,b,c,d,e,f)  _WX_VARARG_ITER_8(m,a,b,c,d,e,f)  m(9,a,b,c,d,e,f)
 691 #define _WX_VARARG_ITER_10(m,a,b,c,d,e,f) _WX_VARARG_ITER_9(m,a,b,c,d,e,f)  m(10,a,b,c,d,e,f)
 692 #define _WX_VARARG_ITER_11(m,a,b,c,d,e,f) _WX_VARARG_ITER_10(m,a,b,c,d,e,f) m(11,a,b,c,d,e,f)
 693 #define _WX_VARARG_ITER_12(m,a,b,c,d,e,f) _WX_VARARG_ITER_11(m,a,b,c,d,e,f) m(12,a,b,c,d,e,f)
 694 #define _WX_VARARG_ITER_13(m,a,b,c,d,e,f) _WX_VARARG_ITER_12(m,a,b,c,d,e,f) m(13,a,b,c,d,e,f)
 695 #define _WX_VARARG_ITER_14(m,a,b,c,d,e,f) _WX_VARARG_ITER_13(m,a,b,c,d,e,f) m(14,a,b,c,d,e,f)
 696 #define _WX_VARARG_ITER_15(m,a,b,c,d,e,f) _WX_VARARG_ITER_14(m,a,b,c,d,e,f) m(15,a,b,c,d,e,f)
 697 #define _WX_VARARG_ITER_16(m,a,b,c,d,e,f) _WX_VARARG_ITER_15(m,a,b,c,d,e,f) m(16,a,b,c,d,e,f)
 698 #define _WX_VARARG_ITER_17(m,a,b,c,d,e,f) _WX_VARARG_ITER_16(m,a,b,c,d,e,f) m(17,a,b,c,d,e,f)
 699 #define _WX_VARARG_ITER_18(m,a,b,c,d,e,f) _WX_VARARG_ITER_17(m,a,b,c,d,e,f) m(18,a,b,c,d,e,f)
 700 #define _WX_VARARG_ITER_19(m,a,b,c,d,e,f) _WX_VARARG_ITER_18(m,a,b,c,d,e,f) m(19,a,b,c,d,e,f)
 701 #define _WX_VARARG_ITER_20(m,a,b,c,d,e,f) _WX_VARARG_ITER_19(m,a,b,c,d,e,f) m(20,a,b,c,d,e,f)
 702 #define _WX_VARARG_ITER_21(m,a,b,c,d,e,f) _WX_VARARG_ITER_20(m,a,b,c,d,e,f) m(21,a,b,c,d,e,f)
 703 #define _WX_VARARG_ITER_22(m,a,b,c,d,e,f) _WX_VARARG_ITER_21(m,a,b,c,d,e,f) m(22,a,b,c,d,e,f)
 704 #define _WX_VARARG_ITER_23(m,a,b,c,d,e,f) _WX_VARARG_ITER_22(m,a,b,c,d,e,f) m(23,a,b,c,d,e,f)
 705 #define _WX_VARARG_ITER_24(m,a,b,c,d,e,f) _WX_VARARG_ITER_23(m,a,b,c,d,e,f) m(24,a,b,c,d,e,f)
 706 #define _WX_VARARG_ITER_25(m,a,b,c,d,e,f) _WX_VARARG_ITER_24(m,a,b,c,d,e,f) m(25,a,b,c,d,e,f)
 707 #define _WX_VARARG_ITER_26(m,a,b,c,d,e,f) _WX_VARARG_ITER_25(m,a,b,c,d,e,f) m(26,a,b,c,d,e,f)
 708 #define _WX_VARARG_ITER_27(m,a,b,c,d,e,f) _WX_VARARG_ITER_26(m,a,b,c,d,e,f) m(27,a,b,c,d,e,f)
 709 #define _WX_VARARG_ITER_28(m,a,b,c,d,e,f) _WX_VARARG_ITER_27(m,a,b,c,d,e,f) m(28,a,b,c,d,e,f)
 710 #define _WX_VARARG_ITER_29(m,a,b,c,d,e,f) _WX_VARARG_ITER_28(m,a,b,c,d,e,f) m(29,a,b,c,d,e,f)
 711 #define _WX_VARARG_ITER_30(m,a,b,c,d,e,f) _WX_VARARG_ITER_29(m,a,b,c,d,e,f) m(30,a,b,c,d,e,f)
 712
 713
 714 #define _WX_VARARG_FIXED_EXPAND_1(t1) \
 715          t1 f1
 716 #define _WX_VARARG_FIXED_EXPAND_2(t1,t2) \
 717          t1 f1, t2 f2
 718 #define _WX_VARARG_FIXED_EXPAND_3(t1,t2,t3) \
 719          t1 f1, t2 f2, t3 f3
 720 #define _WX_VARARG_FIXED_EXPAND_4(t1,t2,t3,t4) \
 721          t1 f1, t2 f2, t3 f3, t4 f4
 722
 723 #define _WX_VARARG_FIXED_UNUSED_EXPAND_1(t1) \
 724          t1 WXUNUSED(f1)
 725 #define _WX_VARARG_FIXED_UNUSED_EXPAND_2(t1,t2) \
 726          t1 WXUNUSED(f1), t2 WXUNUSED(f2)
 727 #define _WX_VARARG_FIXED_UNUSED_EXPAND_3(t1,t2,t3) \
 728          t1 WXUNUSED(f1), t2 WXUNUSED(f2), t3 WXUNUSED(f3)
 729 #define _WX_VARARG_FIXED_UNUSED_EXPAND_4(t1,t2,t3,t4) \
 730          t1 WXUNUSED(f1), t2 WXUNUSED(f2), t3 WXUNUSED(f3), t4 WXUNUSED(f4)
 731
 732 #define _WX_VARARG_FIXED_TYPEDEFS_1(t1) \
 733              typedef t1 TF1
 734 #define _WX_VARARG_FIXED_TYPEDEFS_2(t1,t2) \
 735              _WX_VARARG_FIXED_TYPEDEFS_1(t1); typedef t2 TF2
 736 #define _WX_VARARG_FIXED_TYPEDEFS_3(t1,t2,t3) \
 737              _WX_VARARG_FIXED_TYPEDEFS_2(t1,t2); typedef t3 TF3
 738 #define _WX_VARARG_FIXED_TYPEDEFS_4(t1,t2,t3,t4) \
 739              _WX_VARARG_FIXED_TYPEDEFS_3(t1,t2,t3); typedef t4 TF4
 740
 741 // This macro expands N-items tuple of fixed arguments types into part of
 742 // function's declaration. For example,
 743 // "_WX_VARARG_FIXED_EXPAND(3, (int, char*, int))" expands into
 744 // "int f1, char* f2, int f3".
 745 #define _WX_VARARG_FIXED_EXPAND(N, args) \
 746                 _WX_VARARG_FIXED_EXPAND_IMPL(N, args)
 747 #define _WX_VARARG_FIXED_EXPAND_IMPL(N, args) \
 748                 _WX_VARARG_FIXED_EXPAND_##N args
 749
 750 // Ditto for unused arguments
 751 #define _WX_VARARG_FIXED_UNUSED_EXPAND(N, args) \
 752                 _WX_VARARG_FIXED_UNUSED_EXPAND_IMPL(N, args)
 753 #define _WX_VARARG_FIXED_UNUSED_EXPAND_IMPL(N, args) \
 754                 _WX_VARARG_FIXED_UNUSED_EXPAND_##N args
 755
 756 // Declarates typedefs for fixed arguments types; i-th fixed argument types
 757 // will have TFi typedef.
 758 #define _WX_VARARG_FIXED_TYPEDEFS(N, args) \
 759                 _WX_VARARG_FIXED_TYPEDEFS_IMPL(N, args)
 760 #define _WX_VARARG_FIXED_TYPEDEFS_IMPL(N, args) \
 761                 _WX_VARARG_FIXED_TYPEDEFS_##N args
 762
 763
 764 // This macro calls another macro 'm' passed as second argument 'N' times,
 765 // with its only argument set to 1..N, and concatenates the results using
 766 // comma as separator.
 767 //
 768 // An example:
 769 //     #define foo(i)  x##i
 770 //     // this expands to "x1,x2,x3,x4"
 771 //     _WX_VARARG_JOIN(4, foo)
 772 //
 773 //
 774 // N must not be greater than _WX_VARARG_MAX_ARGS (=30).
 775 #define _WX_VARARG_JOIN(N, m)             _WX_VARARG_JOIN_IMPL(N, m)
 776 #define _WX_VARARG_JOIN_IMPL(N, m)        _WX_VARARG_JOIN_##N(m)
 777
 778
 779 // This macro calls another macro 'm' passed as second argument 'N' times, with
 780 // its first argument set to 1..N and the remaining arguments set to 'a', 'b',
 781 // 'c', 'd', 'e' and 'f'. The results are separated with whitespace in the
 782 // expansion.
 783 //
 784 // An example:
 785 //     // this macro expands to:
 786 //     //     foo(1,a,b,c,d,e,f)
 787 //     //     foo(2,a,b,c,d,e,f)
 788 //     //     foo(3,a,b,c,d,e,f)
 789 //     _WX_VARARG_ITER(3, foo, a, b, c, d, e, f)
 790 //
 791 // N must not be greater than _WX_VARARG_MAX_ARGS (=30).
 792 #define _WX_VARARG_ITER(N,m,a,b,c,d,e,f) \
 793         _WX_VARARG_ITER_IMPL(N,m,a,b,c,d,e,f)
 794 #define _WX_VARARG_ITER_IMPL(N,m,a,b,c,d,e,f) \
 795         _WX_VARARG_ITER_##N(m,a,b,c,d,e,f)
 796
 797 // Generates code snippet for i-th "variadic" argument in vararg function's
 798 // prototype:
 799 #define _WX_VARARG_ARG(i)               T##i a##i
 800
 801 // Like _WX_VARARG_ARG_UNUSED, but outputs argument's type with WXUNUSED:
 802 #define _WX_VARARG_ARG_UNUSED(i)        T##i WXUNUSED(a##i)
 803
 804 // Generates code snippet for i-th type in vararg function's template<...>:
 805 #define _WX_VARARG_TEMPL(i)             typename T##i
 806
 807 // Generates code snippet for passing i-th argument of vararg function
 808 // wrapper to its implementation, normalizing it in the process:
 809 #define _WX_VARARG_PASS_WCHAR(i) \
 810     wxArgNormalizerWchar<T##i>(a##i, fmt, i).get()
 811 #define _WX_VARARG_PASS_UTF8(i) \
 812     wxArgNormalizerUtf8<T##i>(a##i, fmt, i).get()
 813
 814
 815 // And the same for fixed arguments, _not_ normalizing it:
 816 #define _WX_VARARG_PASS_FIXED(i)        f##i
 817
 818 #define _WX_VARARG_FIND_FMT(i) \
 819             (wxFormatStringArgumentFinder<TF##i>::find(f##i))
 820
 821 #define _WX_VARARG_FORMAT_STRING(numfixed, fixed)                             \
 822     _WX_VARARG_FIXED_TYPEDEFS(numfixed, fixed);                               \
 823     const wxFormatString *fmt =                                               \
 824             (_WX_VARARG_JOIN(numfixed, _WX_VARARG_FIND_FMT))
 825
 826 #if wxUSE_UNICODE_UTF8
 827     #define _WX_VARARG_DO_CALL_UTF8(return_kw, impl, implUtf8, N, numfixed)   \
 828         return_kw implUtf8(_WX_VARARG_JOIN(numfixed, _WX_VARARG_PASS_FIXED),  \
 829                         _WX_VARARG_JOIN(N, _WX_VARARG_PASS_UTF8))
 830     #define _WX_VARARG_DO_CALL0_UTF8(return_kw, impl, implUtf8, numfixed)     \
 831         return_kw implUtf8(_WX_VARARG_JOIN(numfixed, _WX_VARARG_PASS_FIXED))
 832 #endif // wxUSE_UNICODE_UTF8
 833
 834 #define _WX_VARARG_DO_CALL_WCHAR(return_kw, impl, implUtf8, N, numfixed)      \
 835     return_kw impl(_WX_VARARG_JOIN(numfixed, _WX_VARARG_PASS_FIXED),          \
 836                     _WX_VARARG_JOIN(N, _WX_VARARG_PASS_WCHAR))
 837 #define _WX_VARARG_DO_CALL0_WCHAR(return_kw, impl, implUtf8, numfixed)        \
 838     return_kw impl(_WX_VARARG_JOIN(numfixed, _WX_VARARG_PASS_FIXED))
 839
 840 #if wxUSE_UNICODE_UTF8
 841     #if wxUSE_UTF8_LOCALE_ONLY
 842         #define _WX_VARARG_DO_CALL _WX_VARARG_DO_CALL_UTF8
 843         #define _WX_VARARG_DO_CALL0 _WX_VARARG_DO_CALL0_UTF8
 844     #else // possibly non-UTF8 locales
 845         #define _WX_VARARG_DO_CALL(return_kw, impl, implUtf8, N, numfixed)    \
 846             if ( wxLocaleIsUtf8 )                                             \
 847               _WX_VARARG_DO_CALL_UTF8(return_kw, impl, implUtf8, N, numfixed);\
 848             else                                                              \
 849               _WX_VARARG_DO_CALL_WCHAR(return_kw, impl, implUtf8, N, numfixed)
 850
 851         #define _WX_VARARG_DO_CALL0(return_kw, impl, implUtf8, numfixed)      \
 852             if ( wxLocaleIsUtf8 )                                             \
 853               _WX_VARARG_DO_CALL0_UTF8(return_kw, impl, implUtf8, numfixed);  \
 854             else                                                              \
 855               _WX_VARARG_DO_CALL0_WCHAR(return_kw, impl, implUtf8, numfixed)
 856     #endif // wxUSE_UTF8_LOCALE_ONLY or not
 857 #else // wxUSE_UNICODE_WCHAR or ANSI
 858     #define _WX_VARARG_DO_CALL _WX_VARARG_DO_CALL_WCHAR
 859     #define _WX_VARARG_DO_CALL0 _WX_VARARG_DO_CALL0_WCHAR
 860 #endif // wxUSE_UNICODE_UTF8 / wxUSE_UNICODE_WCHAR
 861
 862
 863 // Macro to be used with _WX_VARARG_ITER in the implementation of
 864 // WX_DEFINE_VARARG_FUNC (see its documentation for the meaning of arguments)
 865 #define _WX_VARARG_DEFINE_FUNC(N, rettype, name,                              \
 866                                impl, implUtf8, numfixed, fixed)               \
 867     template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 868     rettype name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed),                    \
 869                  _WX_VARARG_JOIN(N, _WX_VARARG_ARG))                          \
 870     {                                                                         \
 871         _WX_VARARG_FORMAT_STRING(numfixed, fixed);                            \
 872         _WX_VARARG_DO_CALL(return, impl, implUtf8, N, numfixed);              \
 873     }
 874
 875 #define _WX_VARARG_DEFINE_FUNC_N0(rettype, name,                              \
 876                                   impl, implUtf8, numfixed, fixed)            \
 877     inline rettype name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed))             \
 878     {                                                                         \
 879         _WX_VARARG_DO_CALL0(return, impl, implUtf8, numfixed);                \
 880     }
 881
 882 // Macro to be used with _WX_VARARG_ITER in the implementation of
 883 // WX_DEFINE_VARARG_FUNC_VOID (see its documentation for the meaning of
 884 // arguments; rettype is ignored and is used only to satisfy _WX_VARARG_ITER's
 885 // requirements).
 886 #define _WX_VARARG_DEFINE_FUNC_VOID(N, rettype, name,                         \
 887                                     impl, implUtf8, numfixed, fixed)          \
 888     template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 889     void name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed),                       \
 890                  _WX_VARARG_JOIN(N, _WX_VARARG_ARG))                          \
 891     {                                                                         \
 892         _WX_VARARG_FORMAT_STRING(numfixed, fixed);                            \
 893         _WX_VARARG_DO_CALL(wxEMPTY_PARAMETER_VALUE,                           \
 894                            impl, implUtf8, N, numfixed);                      \
 895     }
 896
 897 #define _WX_VARARG_DEFINE_FUNC_VOID_N0(name, impl, implUtf8, numfixed, fixed) \
 898     inline void name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed))                \
 899     {                                                                         \
 900         _WX_VARARG_DO_CALL0(wxEMPTY_PARAMETER_VALUE,                          \
 901                             impl, implUtf8, numfixed);                        \
 902     }
 903
 904 // Macro to be used with _WX_VARARG_ITER in the implementation of
 905 // WX_DEFINE_VARARG_FUNC_CTOR (see its documentation for the meaning of
 906 // arguments; rettype is ignored and is used only to satisfy _WX_VARARG_ITER's
 907 // requirements).
 908 #define _WX_VARARG_DEFINE_FUNC_CTOR(N, rettype, name,                         \
 909                                     impl, implUtf8, numfixed, fixed)          \
 910     template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 911     name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed),                            \
 912                 _WX_VARARG_JOIN(N, _WX_VARARG_ARG))                           \
 913     {                                                                         \
 914         _WX_VARARG_FORMAT_STRING(numfixed, fixed);                            \
 915         _WX_VARARG_DO_CALL(wxEMPTY_PARAMETER_VALUE,                           \
 916                            impl, implUtf8, N, numfixed);                      \
 917     }
 918
 919 #define _WX_VARARG_DEFINE_FUNC_CTOR_N0(name, impl, implUtf8, numfixed, fixed) \
 920     inline name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed))                     \
 921     {                                                                         \
 922         _WX_VARARG_DO_CALL0(wxEMPTY_PARAMETER_VALUE,                          \
 923                             impl, implUtf8, numfixed);                        \
 924     }
 925
 926 // Macro to be used with _WX_VARARG_ITER in the implementation of
 927 // WX_DEFINE_VARARG_FUNC_NOP, i.e. empty stub for a disabled vararg function.
 928 // The rettype and impl arguments are ignored.
 929 #define _WX_VARARG_DEFINE_FUNC_NOP(N, rettype, name,                          \
 930                                    impl, implUtf8, numfixed, fixed)           \
 931     template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 932     void name(_WX_VARARG_FIXED_UNUSED_EXPAND(numfixed, fixed),                \
 933                  _WX_VARARG_JOIN(N, _WX_VARARG_ARG_UNUSED))                   \
 934     {}
 935
 936 #define _WX_VARARG_DEFINE_FUNC_NOP_N0(name, numfixed, fixed)                  \
 937     inline void name(_WX_VARARG_FIXED_UNUSED_EXPAND(numfixed, fixed))         \
 938     {}
 939
 940
 941 // ----------------------------------------------------------------------------
 942 // workaround for OpenWatcom bug #351
 943 // ----------------------------------------------------------------------------
 944
 945 #ifdef __WATCOMC__
 946 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 947
 948 // This macro can be used to forward a 'vararg' template to another one with
 949 // different fixed arguments types. Parameters are same as for
 950 // WX_DEFINE_VARARG_FUNC (rettype=void can be used here), 'convfixed' is how
 951 // to convert fixed arguments. For example, this is typical code for dealing
 952 // with different forms of format string:
 953 //
 954 // WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wxFormatString&),
 955 //                            DoPrintfWchar, DoPrintfUtf8)
 956 // #ifdef __WATCOMC__
 957 // WX_VARARG_WATCOM_WORKAROUND(void, Printf, 1, (const wxString&),
 958 //                             (wxFormatString(f1)))
 959 // WX_VARARG_WATCOM_WORKAROUND(void, Printf, 1, (const char*),
 960 //                             (wxFormatString(f1)))
 961 // ...
 962 #define WX_VARARG_WATCOM_WORKAROUND(rettype, name, numfixed, fixed, convfixed)\
 963     _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                      \
 964                     _WX_VARARG_WATCOM_WORKAROUND,                             \
 965                     rettype, name, convfixed, dummy, numfixed, fixed)
 966
 967 #define WX_VARARG_WATCOM_WORKAROUND_CTOR(name, numfixed, fixed, convfixed)    \
 968     _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                      \
 969                     _WX_VARARG_WATCOM_WORKAROUND_CTOR,                        \
 970                     dummy, name, convfixed, dummy, numfixed, fixed)
 971
 972 #define _WX_VARARG_WATCOM_UNPACK_1(a1)               a1
 973 #define _WX_VARARG_WATCOM_UNPACK_2(a1, a2)           a1, a2
 974 #define _WX_VARARG_WATCOM_UNPACK_3(a1, a2, a3)       a1, a2, a3
 975 #define _WX_VARARG_WATCOM_UNPACK_4(a1, a2, a3, a4)   a1, a2, a3, a4
 976 #define _WX_VARARG_WATCOM_UNPACK(N, convfixed) \
 977         _WX_VARARG_WATCOM_UNPACK_##N convfixed
 978
 979 #define _WX_VARARG_PASS_WATCOM(i) a##i
 980
 981 #define _WX_VARARG_WATCOM_WORKAROUND(N, rettype, name,                        \
 982                                      convfixed, dummy, numfixed, fixed)       \
 983     template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 984     rettype name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed),                    \
 985                  _WX_VARARG_JOIN(N, _WX_VARARG_ARG))                          \
 986     {                                                                         \
 987          return name(_WX_VARARG_WATCOM_UNPACK(numfixed, convfixed),           \
 988                      _WX_VARARG_JOIN(N, _WX_VARARG_PASS_WATCOM));             \
 989     }
 990
 991 #define _WX_VARARG_WATCOM_WORKAROUND_CTOR(N, dummy1, name,                    \
 992                                      convfixed, dummy2, numfixed, fixed)      \
 993     template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 994     name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed),                            \
 995                  _WX_VARARG_JOIN(N, _WX_VARARG_ARG))                          \
 996     {                                                                         \
 997          name(_WX_VARARG_WATCOM_UNPACK(numfixed, convfixed),                  \
 998                      _WX_VARARG_JOIN(N, _WX_VARARG_PASS_WATCOM));             \
 999     }
1000
1001 #endif // __WATCOMC__
1002
1003 #endif // _WX_STRVARARG_H_