]> git.saurik.com Git - wxWidgets.git/blob - include/wx/strvararg.h
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add wxActivateEvent::GetActivationReason().
[wxWidgets.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 #if wxONLY_WATCOM_EARLIER_THAN(1,4)
15 #error "OpenWatcom version >= 1.4 is required to compile this code"
16 #endif
17
18 #include "wx/cpp.h"
19 #include "wx/chartype.h"
20 #include "wx/strconv.h"
21 #include "wx/buffer.h"
22 #include "wx/unichar.h"
23
24 #if defined(HAVE_TYPE_TRAITS)
25 #include <type_traits>
26 #elif defined(HAVE_TR1_TYPE_TRAITS)
27 #ifdef __VISUALC__
28 #include <type_traits>
29 #else
30 #include <tr1/type_traits>
31 #endif
32 #endif
33
34 class WXDLLIMPEXP_FWD_BASE wxCStrData;
35 class WXDLLIMPEXP_FWD_BASE wxString;
36
37 // ----------------------------------------------------------------------------
38 // WX_DEFINE_VARARG_FUNC* macros
39 // ----------------------------------------------------------------------------
40
41 // This macro is used to implement type-safe wrappers for variadic functions
42 // that accept strings as arguments. This makes it possible to pass char*,
43 // wchar_t* or even wxString (as opposed to having to use wxString::c_str())
44 // to e.g. wxPrintf().
45 //
46 // This is done by defining a set of N template function taking 1..N arguments
47 // (currently, N is set to 30 in this header). These functions are just thin
48 // wrappers around another variadic function ('impl' or 'implUtf8' arguments,
49 // see below) and the only thing the wrapper does is that it normalizes the
50 // arguments passed in so that they are of the type expected by variadic
51 // functions taking string arguments, i.e., char* or wchar_t*, depending on the
52 // build:
53 // * char* in the current locale's charset in ANSI build
54 // * char* with UTF-8 encoding if wxUSE_UNICODE_UTF8 and the app is running
55 // under an UTF-8 locale
56 // * wchar_t* if wxUSE_UNICODE_WCHAR or if wxUSE_UNICODE_UTF8 and the current
57 // locale is not UTF-8
58 //
59 // Note that wxFormatString *must* be used for the format parameter of these
60 // functions, otherwise the implementation won't work correctly. Furthermore,
61 // it must be passed by value, not reference, because it's modified by the
62 // vararg templates internally.
63 //
64 // Parameters:
65 // [ there are examples in square brackets showing values of the parameters
66 // for the wxFprintf() wrapper for fprintf() function with the following
67 // prototype:
68 // int wxFprintf(FILE *stream, const wxString& format, ...); ]
69 //
70 // rettype Functions' return type [int]
71 // name Name of the function [fprintf]
72 // numfixed The number of leading "fixed" (i.e., not variadic)
73 // arguments of the function (e.g. "stream" and "format"
74 // arguments of fprintf()); their type is _not_ converted
75 // using wxArgNormalizer<T>, unlike the rest of
76 // the function's arguments [2]
77 // fixed List of types of the leading "fixed" arguments, in
78 // parenthesis [(FILE*,const wxString&)]
79 // impl Name of the variadic function that implements 'name' for
80 // the native strings representation (wchar_t* if
81 // wxUSE_UNICODE_WCHAR or wxUSE_UNICODE_UTF8 when running under
82 // non-UTF8 locale, char* in ANSI build) [wxCrt_Fprintf]
83 // implUtf8 Like 'impl', but for the UTF-8 char* version to be used
84 // if wxUSE_UNICODE_UTF8 and running under UTF-8 locale
85 // (ignored otherwise) [fprintf]
86 //
87 #define WX_DEFINE_VARARG_FUNC(rettype, name, numfixed, fixed, impl, implUtf8) \
88 _WX_VARARG_DEFINE_FUNC_N0(rettype, name, impl, implUtf8, numfixed, fixed) \
89 WX_DEFINE_VARARG_FUNC_SANS_N0(rettype, name, numfixed, fixed, impl, implUtf8)
90
91 // ditto, but without the version with 0 template/vararg arguments
92 #define WX_DEFINE_VARARG_FUNC_SANS_N0(rettype, name, \
93 numfixed, fixed, impl, implUtf8) \
94 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
95 _WX_VARARG_DEFINE_FUNC, \
96 rettype, name, impl, implUtf8, numfixed, fixed)
97
98 // Like WX_DEFINE_VARARG_FUNC, but for variadic functions that don't return
99 // a value.
100 #define WX_DEFINE_VARARG_FUNC_VOID(name, numfixed, fixed, impl, implUtf8) \
101 _WX_VARARG_DEFINE_FUNC_VOID_N0(name, impl, implUtf8, numfixed, fixed) \
102 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
103 _WX_VARARG_DEFINE_FUNC_VOID, \
104 void, name, impl, implUtf8, numfixed, fixed)
105
106 // Like WX_DEFINE_VARARG_FUNC_VOID, but instead of wrapping an implementation
107 // function, does nothing in defined functions' bodies.
108 //
109 // Used to implement wxLogXXX functions if wxUSE_LOG=0.
110 #define WX_DEFINE_VARARG_FUNC_NOP(name, numfixed, fixed) \
111 _WX_VARARG_DEFINE_FUNC_NOP_N0(name, numfixed, fixed) \
112 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
113 _WX_VARARG_DEFINE_FUNC_NOP, \
114 void, name, dummy, dummy, numfixed, fixed)
115
116 // Like WX_DEFINE_VARARG_FUNC_CTOR, but for defining template constructors
117 #define WX_DEFINE_VARARG_FUNC_CTOR(name, numfixed, fixed, impl, implUtf8) \
118 _WX_VARARG_DEFINE_FUNC_CTOR_N0(name, impl, implUtf8, numfixed, fixed) \
119 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
120 _WX_VARARG_DEFINE_FUNC_CTOR, \
121 void, name, impl, implUtf8, numfixed, fixed)
122
123
124 // ----------------------------------------------------------------------------
125 // wxFormatString
126 // ----------------------------------------------------------------------------
127
128 // This class must be used for format string argument of the functions
129 // defined using WX_DEFINE_VARARG_FUNC_* macros. It converts the string to
130 // char* or wchar_t* for passing to implementation function efficiently (i.e.
131 // without keeping the converted string in memory for longer than necessary,
132 // like c_str()). It also converts format string to the correct form that
133 // accounts for string changes done by wxArgNormalizer<>
134 //
135 // Note that this class can _only_ be used for function arguments!
136 class WXDLLIMPEXP_BASE wxFormatString
137 {
138 public:
139 wxFormatString(const char *str)
140 : m_char(wxScopedCharBuffer::CreateNonOwned(str)), m_str(NULL), m_cstr(NULL) {}
141 wxFormatString(const wchar_t *str)
142 : m_wchar(wxScopedWCharBuffer::CreateNonOwned(str)), m_str(NULL), m_cstr(NULL) {}
143 wxFormatString(const wxString& str)
144 : m_str(&str), m_cstr(NULL) {}
145 wxFormatString(const wxCStrData& str)
146 : m_str(NULL), m_cstr(&str) {}
147 wxFormatString(const wxScopedCharBuffer& str)
148 : m_char(str), m_str(NULL), m_cstr(NULL) {}
149 wxFormatString(const wxScopedWCharBuffer& str)
150 : m_wchar(str), m_str(NULL), m_cstr(NULL) {}
151
152 // Possible argument types. These are or-combinable for wxASSERT_ARG_TYPE
153 // convenience. Some of the values are or-combined with another value, this
154 // expresses "supertypes" for use with wxASSERT_ARG_TYPE masks. For example,
155 // a char* string is also a pointer and an integer is also a char.
156 enum ArgumentType
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>(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
1160 // ----------------------------------------------------------------------------
1161 // workaround for OpenWatcom bug #351
1162 // ----------------------------------------------------------------------------
1163
1164 #ifdef __WATCOMC__
1165 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1166
1167 // This macro can be used to forward a 'vararg' template to another one with
1168 // different fixed arguments types. Parameters are same as for
1169 // WX_DEFINE_VARARG_FUNC (rettype=void can be used here), 'convfixed' is how
1170 // to convert fixed arguments. For example, this is typical code for dealing
1171 // with different forms of format string:
1172 //
1173 // WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wxFormatString&),
1174 // DoPrintfWchar, DoPrintfUtf8)
1175 // #ifdef __WATCOMC__
1176 // WX_VARARG_WATCOM_WORKAROUND(void, Printf, 1, (const wxString&),
1177 // (wxFormatString(f1)))
1178 // WX_VARARG_WATCOM_WORKAROUND(void, Printf, 1, (const char*),
1179 // (wxFormatString(f1)))
1180 // ...
1181 #define WX_VARARG_WATCOM_WORKAROUND(rettype, name, numfixed, fixed, convfixed)\
1182 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
1183 _WX_VARARG_WATCOM_WORKAROUND, \
1184 rettype, name, convfixed, dummy, numfixed, fixed)
1185
1186 #define WX_VARARG_WATCOM_WORKAROUND_CTOR(name, numfixed, fixed, convfixed) \
1187 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
1188 _WX_VARARG_WATCOM_WORKAROUND_CTOR, \
1189 dummy, name, convfixed, dummy, numfixed, fixed)
1190
1191 #define _WX_VARARG_WATCOM_UNPACK_1(a1) a1
1192 #define _WX_VARARG_WATCOM_UNPACK_2(a1, a2) a1, a2
1193 #define _WX_VARARG_WATCOM_UNPACK_3(a1, a2, a3) a1, a2, a3
1194 #define _WX_VARARG_WATCOM_UNPACK_4(a1, a2, a3, a4) a1, a2, a3, a4
1195 #define _WX_VARARG_WATCOM_UNPACK(N, convfixed) \
1196 _WX_VARARG_WATCOM_UNPACK_##N convfixed
1197
1198 #define _WX_VARARG_PASS_WATCOM(i) a##i
1199
1200 #define _WX_VARARG_WATCOM_WORKAROUND(N, rettype, name, \
1201 convfixed, dummy, numfixed, fixed) \
1202 template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)> \
1203 rettype name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed), \
1204 _WX_VARARG_JOIN(N, _WX_VARARG_ARG)) \
1205 { \
1206 return name(_WX_VARARG_WATCOM_UNPACK(numfixed, convfixed), \
1207 _WX_VARARG_JOIN(N, _WX_VARARG_PASS_WATCOM)); \
1208 }
1209
1210 #define _WX_VARARG_WATCOM_WORKAROUND_CTOR(N, dummy1, name, \
1211 convfixed, dummy2, numfixed, fixed) \
1212 template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)> \
1213 name(_WX_VARARG_FIXED_EXPAND(numfixed, fixed), \
1214 _WX_VARARG_JOIN(N, _WX_VARARG_ARG)) \
1215 { \
1216 name(_WX_VARARG_WATCOM_UNPACK(numfixed, convfixed), \
1217 _WX_VARARG_JOIN(N, _WX_VARARG_PASS_WATCOM)); \
1218 }
1219
1220 #endif // __WATCOMC__
1221
1222 #endif // _WX_STRVARARG_H_
wxWidgets (Impactor)