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