]> 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
corrected WX_DEFINE_VARARG_FUNC_NOP usage
[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 // RCS-ID: $Id$
7 // Copyright: (c) 2007 REA Elektronik GmbH
8 // Licence: wxWindows licence
9 ///////////////////////////////////////////////////////////////////////////////
10
11 #ifndef _WX_STRVARARG_H_
12 #define _WX_STRVARARG_H_
13
14 #include "wx/platform.h"
15 #if wxONLY_WATCOM_EARLIER_THAN(1,4)
16 #error "OpenWatcom version >= 1.4 is required to compile this code"
17 #endif
18
19 // include wchar_t definition if needed:
20 #if defined(__WATCOMC__)
21 #include <inttypes.h>
22 #elif defined(__VISUALC__)
23 #include <stdlib.h>
24 #endif
25
26
27 class WXDLLIMPEXP_BASE wxCStrData;
28 class WXDLLIMPEXP_BASE wxString;
29 class WXDLLIMPEXP_BASE wxCharBuffer;
30 class WXDLLIMPEXP_BASE wxWCharBuffer;
31
32
33 // ----------------------------------------------------------------------------
34 // WX_DEFINE_VARARG_FUNC* macros
35 // ----------------------------------------------------------------------------
36
37 // This macro is used to implement type-safe wrappers for variadic functions
38 // that accept strings as arguments. This makes it possible to pass char*,
39 // wchar_t* or even wxString (as opposed to having to use wxString::c_str())
40 // to e.g. wxPrintf().
41 //
42 // This is done by defining a set of N template function taking 1..N arguments
43 // (currently, N is set to 30 in this header). These functions are just thin
44 // wrappers around another variadic function (@a impl) and the only thing
45 // the wrapper does is that it normalizes the arguments passed in so that
46 // they are of the type expected by variadic functions taking string
47 // arguments, i.e., char* or wchar_t*, depending on the build:
48 // * char* in the current locale's charset in ANSI build
49 // * whchar_t* in the Unicode build
50 //
51 // Parameters:
52 // rettype Functions' return type.
53 // name Name of the function.
54 // impl Name of the variadic function that implements 'name'.
55 #define WX_DEFINE_VARARG_FUNC(rettype, name, impl) \
56 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
57 _WX_VARARG_DEFINE_FUNC, \
58 rettype, name, impl)
59
60 // Like WX_DEFINE_VARARG_FUNC, but for variadic functions that don't return
61 // a value.
62 #define WX_DEFINE_VARARG_FUNC_VOID(name, impl) \
63 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
64 _WX_VARARG_DEFINE_FUNC_VOID, \
65 void, name, impl)
66
67 // Like WX_DEFINE_VARARG_FUNC_VOID, but instead of wrapping an implementation
68 // function, does nothing in defined functions' bodies.
69 //
70 // Used to implement wxLogXXX functions if wxUSE_LOG=0.
71 #define WX_DEFINE_VARARG_FUNC_NOP(name) \
72 _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
73 _WX_VARARG_DEFINE_FUNC_NOP, \
74 void, name, dummy)
75
76 // ----------------------------------------------------------------------------
77 // implementation
78 // ----------------------------------------------------------------------------
79
80 // Converts an argument passed to wxPrint etc. into standard form expected,
81 // by wxXXX functions, e.g. all strings (wxString, char*, wchar_t*) are
82 // converted into wchar_t* or char* depending on the build.
83 template<typename T>
84 struct wxArgNormalizer
85 {
86 wxArgNormalizer(const T& value) : m_value(value) {}
87
88 // Returns the value in a form that can be safely passed to real vararg
89 // functions. In case of strings, this is char* in ANSI build and wchar_t*
90 // in Unicode build.
91 const T& get() const { return m_value; }
92
93 const T& m_value;
94 };
95
96 // special cases for converting strings:
97
98 // FIXME-UTF8: move this to wxchartype.h!
99 #if wxUSE_UNICODE
100 /* for now, all Unicode builds are wchar_t* based: */
101 #define wxUSE_UNICODE_WCHAR 1
102 #else
103 #define wxUSE_UNICODE_WCHAR 0
104 #endif
105
106 // FIXME-UTF8: include wx/wxchartype.h and use wxChar after headers split
107 // FIXME-UTF8: this will be char* in UTF-8 build and wchar_t* on Windows
108 #if wxUSE_UNICODE_WCHAR
109 typedef wchar_t wxArgNativeCharType;
110 #else
111 typedef char wxArgNativeCharType;
112 #endif
113
114 template<>
115 struct WXDLLIMPEXP_BASE wxArgNormalizer<const wxCStrData&>
116 {
117 wxArgNormalizer(const wxCStrData& value) : m_value(value) {}
118 const wxArgNativeCharType *get() const;
119
120 const wxCStrData& m_value;
121 };
122
123 template<>
124 struct wxArgNormalizer<wxCStrData> : public wxArgNormalizer<const wxCStrData&>
125 {
126 wxArgNormalizer(const wxCStrData& value)
127 : wxArgNormalizer<const wxCStrData&>(value) {}
128 };
129
130 template<>
131 struct WXDLLIMPEXP_BASE wxArgNormalizer<const wxString&>
132 {
133 wxArgNormalizer(const wxString& value) : m_value(value) {}
134 const wxArgNativeCharType *get() const;
135
136 const wxString& m_value;
137 };
138
139 template<>
140 struct wxArgNormalizer<wxString> : public wxArgNormalizer<const wxString&>
141 {
142 wxArgNormalizer(const wxString& value)
143 : wxArgNormalizer<const wxString&>(value) {}
144 };
145
146 #if wxUSE_UNICODE_WCHAR
147
148 template<>
149 struct WXDLLIMPEXP_BASE wxArgNormalizer<const char*>
150 {
151 wxArgNormalizer(const char *value);
152 ~wxArgNormalizer();
153 const wchar_t *get() const;
154
155 wxWCharBuffer *m_value;
156 };
157
158 template<>
159 struct wxArgNormalizer<char*> : public wxArgNormalizer<const char*>
160 {
161 wxArgNormalizer(char *value)
162 : wxArgNormalizer<const char*>(value) {}
163 };
164
165 #elif wxUSE_WCHAR_T // !wxUSE_UNICODE_WCHAR && wxUSE_WCHAR_T
166
167 template<>
168 struct WXDLLIMPEXP_BASE wxArgNormalizer<const wchar_t*>
169 {
170 wxArgNormalizer(const wchar_t *value);
171 ~wxArgNormalizer();
172 const char *get() const;
173
174 wxCharBuffer *m_value;
175 };
176
177 template<>
178 struct wxArgNormalizer<wchar_t*> : public wxArgNormalizer<const wchar_t*>
179 {
180 wxArgNormalizer(wchar_t *value)
181 : wxArgNormalizer<const wchar_t*>(value) {}
182 };
183
184 #endif // wxUSE_UNICODE_WCHAR / !wxUSE_UNICODE_WCHAR && wxUSE_WCHAR_T
185
186 // NB: The vararg emulation code is limited to 30 arguments at the moment.
187 // If you need more, you need to
188 // 1) increase the value of _WX_VARARG_MAX_ARGS
189 // 2) add _WX_VARARG_JOIN_* and _WX_VARARG_ITER_* up to the new
190 // _WX_VARARG_MAX_ARGS value to the lists below
191 #define _WX_VARARG_MAX_ARGS 30
192
193 #define _WX_VARARG_JOIN_1(m) m(1)
194 #define _WX_VARARG_JOIN_2(m) _WX_VARARG_JOIN_1(m), m(2)
195 #define _WX_VARARG_JOIN_3(m) _WX_VARARG_JOIN_2(m), m(3)
196 #define _WX_VARARG_JOIN_4(m) _WX_VARARG_JOIN_3(m), m(4)
197 #define _WX_VARARG_JOIN_5(m) _WX_VARARG_JOIN_4(m), m(5)
198 #define _WX_VARARG_JOIN_6(m) _WX_VARARG_JOIN_5(m), m(6)
199 #define _WX_VARARG_JOIN_7(m) _WX_VARARG_JOIN_6(m), m(7)
200 #define _WX_VARARG_JOIN_8(m) _WX_VARARG_JOIN_7(m), m(8)
201 #define _WX_VARARG_JOIN_9(m) _WX_VARARG_JOIN_8(m), m(9)
202 #define _WX_VARARG_JOIN_10(m) _WX_VARARG_JOIN_9(m), m(10)
203 #define _WX_VARARG_JOIN_11(m) _WX_VARARG_JOIN_10(m), m(11)
204 #define _WX_VARARG_JOIN_12(m) _WX_VARARG_JOIN_11(m), m(12)
205 #define _WX_VARARG_JOIN_13(m) _WX_VARARG_JOIN_12(m), m(13)
206 #define _WX_VARARG_JOIN_14(m) _WX_VARARG_JOIN_13(m), m(14)
207 #define _WX_VARARG_JOIN_15(m) _WX_VARARG_JOIN_14(m), m(15)
208 #define _WX_VARARG_JOIN_16(m) _WX_VARARG_JOIN_15(m), m(16)
209 #define _WX_VARARG_JOIN_17(m) _WX_VARARG_JOIN_16(m), m(17)
210 #define _WX_VARARG_JOIN_18(m) _WX_VARARG_JOIN_17(m), m(18)
211 #define _WX_VARARG_JOIN_19(m) _WX_VARARG_JOIN_18(m), m(19)
212 #define _WX_VARARG_JOIN_20(m) _WX_VARARG_JOIN_19(m), m(20)
213 #define _WX_VARARG_JOIN_21(m) _WX_VARARG_JOIN_20(m), m(21)
214 #define _WX_VARARG_JOIN_22(m) _WX_VARARG_JOIN_21(m), m(22)
215 #define _WX_VARARG_JOIN_23(m) _WX_VARARG_JOIN_22(m), m(23)
216 #define _WX_VARARG_JOIN_24(m) _WX_VARARG_JOIN_23(m), m(24)
217 #define _WX_VARARG_JOIN_25(m) _WX_VARARG_JOIN_24(m), m(25)
218 #define _WX_VARARG_JOIN_26(m) _WX_VARARG_JOIN_25(m), m(26)
219 #define _WX_VARARG_JOIN_27(m) _WX_VARARG_JOIN_26(m), m(27)
220 #define _WX_VARARG_JOIN_28(m) _WX_VARARG_JOIN_27(m), m(28)
221 #define _WX_VARARG_JOIN_29(m) _WX_VARARG_JOIN_28(m), m(29)
222 #define _WX_VARARG_JOIN_30(m) _WX_VARARG_JOIN_29(m), m(30)
223
224 #define _WX_VARARG_ITER_1(m,a,b,c) m(1,a,b,c)
225 #define _WX_VARARG_ITER_2(m,a,b,c) _WX_VARARG_ITER_1(m,a,b,c) m(2,a,b,c)
226 #define _WX_VARARG_ITER_3(m,a,b,c) _WX_VARARG_ITER_2(m,a,b,c) m(3,a,b,c)
227 #define _WX_VARARG_ITER_4(m,a,b,c) _WX_VARARG_ITER_3(m,a,b,c) m(4,a,b,c)
228 #define _WX_VARARG_ITER_5(m,a,b,c) _WX_VARARG_ITER_4(m,a,b,c) m(5,a,b,c)
229 #define _WX_VARARG_ITER_6(m,a,b,c) _WX_VARARG_ITER_5(m,a,b,c) m(6,a,b,c)
230 #define _WX_VARARG_ITER_7(m,a,b,c) _WX_VARARG_ITER_6(m,a,b,c) m(7,a,b,c)
231 #define _WX_VARARG_ITER_8(m,a,b,c) _WX_VARARG_ITER_7(m,a,b,c) m(8,a,b,c)
232 #define _WX_VARARG_ITER_9(m,a,b,c) _WX_VARARG_ITER_8(m,a,b,c) m(9,a,b,c)
233 #define _WX_VARARG_ITER_10(m,a,b,c) _WX_VARARG_ITER_9(m,a,b,c) m(10,a,b,c)
234 #define _WX_VARARG_ITER_11(m,a,b,c) _WX_VARARG_ITER_10(m,a,b,c) m(11,a,b,c)
235 #define _WX_VARARG_ITER_12(m,a,b,c) _WX_VARARG_ITER_11(m,a,b,c) m(12,a,b,c)
236 #define _WX_VARARG_ITER_13(m,a,b,c) _WX_VARARG_ITER_12(m,a,b,c) m(13,a,b,c)
237 #define _WX_VARARG_ITER_14(m,a,b,c) _WX_VARARG_ITER_13(m,a,b,c) m(14,a,b,c)
238 #define _WX_VARARG_ITER_15(m,a,b,c) _WX_VARARG_ITER_14(m,a,b,c) m(15,a,b,c)
239 #define _WX_VARARG_ITER_16(m,a,b,c) _WX_VARARG_ITER_15(m,a,b,c) m(16,a,b,c)
240 #define _WX_VARARG_ITER_17(m,a,b,c) _WX_VARARG_ITER_16(m,a,b,c) m(17,a,b,c)
241 #define _WX_VARARG_ITER_18(m,a,b,c) _WX_VARARG_ITER_17(m,a,b,c) m(18,a,b,c)
242 #define _WX_VARARG_ITER_19(m,a,b,c) _WX_VARARG_ITER_18(m,a,b,c) m(19,a,b,c)
243 #define _WX_VARARG_ITER_20(m,a,b,c) _WX_VARARG_ITER_19(m,a,b,c) m(20,a,b,c)
244 #define _WX_VARARG_ITER_21(m,a,b,c) _WX_VARARG_ITER_20(m,a,b,c) m(21,a,b,c)
245 #define _WX_VARARG_ITER_22(m,a,b,c) _WX_VARARG_ITER_21(m,a,b,c) m(22,a,b,c)
246 #define _WX_VARARG_ITER_23(m,a,b,c) _WX_VARARG_ITER_22(m,a,b,c) m(23,a,b,c)
247 #define _WX_VARARG_ITER_24(m,a,b,c) _WX_VARARG_ITER_23(m,a,b,c) m(24,a,b,c)
248 #define _WX_VARARG_ITER_25(m,a,b,c) _WX_VARARG_ITER_24(m,a,b,c) m(25,a,b,c)
249 #define _WX_VARARG_ITER_26(m,a,b,c) _WX_VARARG_ITER_25(m,a,b,c) m(26,a,b,c)
250 #define _WX_VARARG_ITER_27(m,a,b,c) _WX_VARARG_ITER_26(m,a,b,c) m(27,a,b,c)
251 #define _WX_VARARG_ITER_28(m,a,b,c) _WX_VARARG_ITER_27(m,a,b,c) m(28,a,b,c)
252 #define _WX_VARARG_ITER_29(m,a,b,c) _WX_VARARG_ITER_28(m,a,b,c) m(29,a,b,c)
253 #define _WX_VARARG_ITER_30(m,a,b,c) _WX_VARARG_ITER_29(m,a,b,c) m(30,a,b,c)
254
255 // This macro calls another macro 'm' passed as second argument 'N' times,
256 // with its only argument set to 1..N, and concatenates the results using
257 // comma as separator.
258 //
259 // An example:
260 // #define foo(i) x##i
261 // // this expands to "x1,x2,x3,x4"
262 // _WX_VARARG_JOIN(4, foo)
263 //
264 //
265 // N must not be greater than _WX_VARARG_MAX_ARGS (=30).
266 #define _WX_VARARG_JOIN(N, m) _WX_VARARG_JOIN_IMPL(N, m)
267 #define _WX_VARARG_JOIN_IMPL(N, m) _WX_VARARG_JOIN_##N(m)
268
269 // This macro calls another macro 'm' passed as second argument 'N' times, with
270 // its first argument set to 1..N and the remaining arguments set to 'a', 'b'
271 // and 'c'. The results are separated with whitespace in the expansion.
272 //
273 // An example:
274 // // this macro expands to:
275 // // foo(1,a,b,c)
276 // // foo(2,a,b,c)
277 // // foo(3,a,b,c)
278 // _WX_VARARG_ITER(3, foo, a, b, c)
279 //
280 // N must not be greater than _WX_VARARG_MAX_ARGS (=30).
281 #define _WX_VARARG_ITER(N, m,a,b,c) _WX_VARARG_ITER_IMPL(N, m, a, b, c)
282 #define _WX_VARARG_ITER_IMPL(N, m,a,b,c) _WX_VARARG_ITER_##N(m, a, b, c)
283
284 // Generates code snippet for i-th argument in vararg function's prototype.
285 #define _WX_VARARG_ARG(i) T##i a##i
286
287 // Like _WX_VARARG_ARG_UNUSED, but outputs argument's type with WXUNUSED.
288 #define _WX_VARARG_ARG_UNUSED(i) T##i WXUNUSED(a##i)
289
290 // Generates code snippet for i-th type in vararg function's template<...>.
291 #define _WX_VARARG_TEMPL(i) typename T##i
292
293 // Generates code snippet for passing i-th argument of vararg function
294 // wrapper to its implementation, normalizing it in the process
295 #define _WX_VARARG_PASS(i) wxArgNormalizer<T##i>(a##i).get()
296
297
298 // Macro to be used with _WX_VARARG_ITER in the implementation of
299 // WX_DEFINE_VARARG_FUNC (see its documentation for the meaning of arguments)
300 #define _WX_VARARG_DEFINE_FUNC(N, rettype, name, impl) \
301 template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)> \
302 rettype name(_WX_VARARG_JOIN(N, _WX_VARARG_ARG)) \
303 { \
304 return impl(_WX_VARARG_JOIN(N, _WX_VARARG_PASS)); \
305 }
306
307 // Macro to be used with _WX_VARARG_ITER in the implementation of
308 // WX_DEFINE_VARARG_FUNC_VOID (see its documentation for the meaning of
309 // arguments; rettype is ignored and is used only to satisfy _WX_VARARG_ITER's
310 // requirements).
311 #define _WX_VARARG_DEFINE_FUNC_VOID(N, rettype, name, impl) \
312 template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)> \
313 void name(_WX_VARARG_JOIN(N, _WX_VARARG_ARG)) \
314 { \
315 impl(_WX_VARARG_JOIN(N, _WX_VARARG_PASS)); \
316 }
317
318 // Macro to be used with _WX_VARARG_ITER in the implementation of
319 // WX_DEFINE_VARARG_FUNC_NOP, i.e. empty stub for a disabled vararg function.
320 // The rettype and impl arguments are ignored.
321 #define _WX_VARARG_DEFINE_FUNC_NOP(N, rettype, name, impl) \
322 template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)> \
323 void name(_WX_VARARG_JOIN(N, _WX_VARARG_ARG_UNUSED)) {}
324
325
326 #endif // _WX_STRVARARG_H_
wxWidgets (Impactor)