← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Externals/wxWidgets3/include/wx/wxcrtvararg.h

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/wxWidgets3/include/wx/wxcrtvararg.h
 
1
///////////////////////////////////////////////////////////////////////////////
 
2
// Name:        wx/wxcrtvararg.h
 
3
// Purpose:     Type-safe ANSI and Unicode builds compatible wrappers for
 
4
//              printf(), scanf() and related CRT functions
 
5
// Author:      Joel Farley, Ove Kåven
 
6
// Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
 
7
// Created:     2007-02-19
 
8
// Copyright:   (c) 2007 REA Elektronik GmbH
 
9
// Licence:     wxWindows licence
 
10
///////////////////////////////////////////////////////////////////////////////
 
11
 
 
12
#ifndef _WX_WXCRTVARARG_H_
 
13
#define _WX_WXCRTVARARG_H_
 
14
 
 
15
// NB: User code should include wx/crt.h instead of including this
 
16
//     header directly.
 
17
 
 
18
#include "wx/wxcrt.h"
 
19
#include "wx/strvararg.h"
 
20
 
 
21
#include "wx/string.h"
 
22
 
 
23
// ----------------------------------------------------------------------------
 
24
// CRT functions aliases
 
25
// ----------------------------------------------------------------------------
 
26
 
 
27
/* Required for wxPrintf() etc */
 
28
#include <stdarg.h>
 
29
 
 
30
/* printf() family saga */
 
31
 
 
32
/*
 
33
   For many old Unix systems [v]snprintf()/vsscanf() exists in the system
 
34
   libraries but not in the headers, so we need to declare it ourselves to be
 
35
   able to use it.
 
36
 */
 
37
#ifdef __UNIX__
 
38
 
 
39
#if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
 
40
#ifdef __cplusplus
 
41
    extern "C"
 
42
#else
 
43
    extern
 
44
#endif
 
45
    int vsnprintf(char *str, size_t size, const char *format, va_list ap);
 
46
#endif /* !HAVE_VSNPRINTF_DECL */
 
47
 
 
48
#if defined(HAVE_SNPRINTF) && !defined(HAVE_SNPRINTF_DECL)
 
49
#ifdef __cplusplus
 
50
    extern "C"
 
51
#else
 
52
    extern
 
53
#endif
 
54
    int snprintf(char *str, size_t size, const char *format, ...);
 
55
#endif /* !HAVE_SNPRINTF_DECL */
 
56
 
 
57
#if defined(HAVE_VSSCANF) && !defined(HAVE_VSSCANF_DECL)
 
58
#ifdef __cplusplus
 
59
    extern "C"
 
60
#else
 
61
    extern
 
62
#endif
 
63
    int vsscanf(const char *str, const char *format, va_list ap);
 
64
#endif /* !HAVE_VSSCANF_DECL */
 
65
 
 
66
/* Wrapper for vsnprintf if it's 3rd parameter is non-const. Note: the
 
67
 * same isn't done for snprintf below, the builtin wxSnprintf_ is used
 
68
 * instead since it's already a simple wrapper */
 
69
#if defined __cplusplus && defined HAVE_BROKEN_VSNPRINTF_DECL
 
70
    inline int wx_fixed_vsnprintf(char *str, size_t size, const char *format, va_list ap)
 
71
    {
 
72
        return vsnprintf(str, size, (char*)format, ap);
 
73
    }
 
74
#endif
 
75
 
 
76
#endif /* __UNIX__ */
 
77
 
 
78
/*
 
79
   mingw32 normally uses MSVCRT which has non-standard vswprintf() and so
 
80
   normally _vsnwprintf() is used instead, the only exception is when mingw32
 
81
   is used with STLPort which does have a standard vswprintf() starting from
 
82
   version 5.1 which we can use.
 
83
 */
 
84
#ifdef __MINGW32__
 
85
    #if defined(_STLPORT_VERSION) && _STLPORT_VERSION >= 0x510
 
86
        #ifndef HAVE_VSWPRINTF
 
87
            #define HAVE_VSWPRINTF
 
88
        #endif
 
89
    #elif defined(HAVE_VSWPRINTF)
 
90
        /* can't use non-standard vswprintf() */
 
91
        #undef HAVE_VSWPRINTF
 
92
    #endif
 
93
#endif /* __MINGW32__ */
 
94
 
 
95
#if defined(__WATCOMC__)
 
96
    #define HAVE_VSWPRINTF 1
 
97
#endif
 
98
 
 
99
#if wxUSE_PRINTF_POS_PARAMS
 
100
    /*
 
101
        The systems where vsnprintf() supports positional parameters should
 
102
        define the HAVE_UNIX98_PRINTF symbol.
 
103
 
 
104
        On systems which don't (e.g. Windows) we are forced to use
 
105
        our wxVsnprintf() implementation.
 
106
    */
 
107
    #if defined(HAVE_UNIX98_PRINTF)
 
108
        #ifdef HAVE_VSWPRINTF
 
109
            #define wxCRT_VsnprintfW   vswprintf
 
110
        #endif
 
111
        #ifdef HAVE_BROKEN_VSNPRINTF_DECL
 
112
            #define wxCRT_VsnprintfA    wx_fixed_vsnprintf
 
113
        #else
 
114
            #define wxCRT_VsnprintfA    vsnprintf
 
115
        #endif
 
116
    #else /* !HAVE_UNIX98_PRINTF */
 
117
        /*
 
118
            The only compiler with positional parameters support under Windows
 
119
            is VC++ 8.0 which provides a new xxprintf_p() functions family.
 
120
            The 2003 PSDK includes a slightly earlier version of VC8 than the
 
121
            main release and does not have the printf_p functions.
 
122
         */
 
123
        #if defined _MSC_FULL_VER && _MSC_FULL_VER >= 140050727 && !defined __WXWINCE__
 
124
            #define wxCRT_VsnprintfA    _vsprintf_p
 
125
            #define wxCRT_VsnprintfW    _vswprintf_p
 
126
        #endif
 
127
    #endif /* HAVE_UNIX98_PRINTF/!HAVE_UNIX98_PRINTF */
 
128
#else /* !wxUSE_PRINTF_POS_PARAMS */
 
129
    /*
 
130
       We always want to define safe snprintf() function to be used instead of
 
131
       sprintf(). Some compilers already have it (or rather vsnprintf() which
 
132
       we really need...), otherwise we implement it using our own printf()
 
133
       code.
 
134
 
 
135
       We define function with a trailing underscore here because the real one
 
136
       is a wrapper around it as explained below
 
137
     */
 
138
 
 
139
    #if defined(__VISUALC__) || \
 
140
            (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
 
141
        #define wxCRT_VsnprintfA    _vsnprintf
 
142
        #define wxCRT_VsnprintfW    _vsnwprintf
 
143
    #else
 
144
        #if defined(HAVE__VSNWPRINTF)
 
145
            #define wxCRT_VsnprintfW    _vsnwprintf
 
146
        #elif defined(HAVE_VSWPRINTF)
 
147
            #define wxCRT_VsnprintfW     vswprintf
 
148
        #elif defined(__WATCOMC__)
 
149
            #define wxCRT_VsnprintfW    _vsnwprintf
 
150
        #endif
 
151
 
 
152
        #if defined(HAVE_VSNPRINTF) \
 
153
            || defined(__WATCOMC__)
 
154
            #ifdef HAVE_BROKEN_VSNPRINTF_DECL
 
155
                #define wxCRT_VsnprintfA    wx_fixed_vsnprintf
 
156
            #else
 
157
                #define wxCRT_VsnprintfA    vsnprintf
 
158
            #endif
 
159
        #endif
 
160
    #endif
 
161
#endif /* wxUSE_PRINTF_POS_PARAMS/!wxUSE_PRINTF_POS_PARAMS */
 
162
 
 
163
#ifndef wxCRT_VsnprintfW
 
164
    /* no (suitable) vsnprintf(), cook our own */
 
165
    WXDLLIMPEXP_BASE int
 
166
    wxCRT_VsnprintfW(wchar_t *buf, size_t len, const wchar_t *format, va_list argptr);
 
167
    #define wxUSE_WXVSNPRINTFW 1
 
168
#else
 
169
    #define wxUSE_WXVSNPRINTFW 0
 
170
#endif
 
171
 
 
172
#ifndef wxCRT_VsnprintfA
 
173
        /* no (suitable) vsnprintf(), cook our own */
 
174
        WXDLLIMPEXP_BASE int
 
175
        wxCRT_VsnprintfA(char *buf, size_t len, const char *format, va_list argptr);
 
176
        #define wxUSE_WXVSNPRINTFA 1
 
177
#else
 
178
        #define wxUSE_WXVSNPRINTFA 0
 
179
#endif
 
180
 
 
181
// for wxString code, define wxUSE_WXVSNPRINTF to indicate that wx
 
182
// implementation is used no matter what (in UTF-8 build, either *A or *W
 
183
// version may be called):
 
184
#if !wxUSE_UNICODE
 
185
    #define wxUSE_WXVSNPRINTF wxUSE_WXVSNPRINTFA
 
186
#elif wxUSE_UNICODE_WCHAR
 
187
    #define wxUSE_WXVSNPRINTF wxUSE_WXVSNPRINTFW
 
188
#elif wxUSE_UTF8_LOCALE_ONLY
 
189
    #define wxUSE_WXVSNPRINTF wxUSE_WXVSNPRINTFA
 
190
#else // UTF-8 under any locale
 
191
    #define wxUSE_WXVSNPRINTF (wxUSE_WXVSNPRINTFA && wxUSE_WXVSNPRINTFW)
 
192
#endif
 
193
 
 
194
#define wxCRT_FprintfA       fprintf
 
195
#define wxCRT_PrintfA        printf
 
196
#define wxCRT_VfprintfA      vfprintf
 
197
#define wxCRT_VprintfA       vprintf
 
198
#define wxCRT_VsprintfA      vsprintf
 
199
 
 
200
/*
 
201
   In Unicode mode we need to have all standard functions such as wprintf() and
 
202
   so on but not all systems have them so use our own implementations in this
 
203
   case.
 
204
 */
 
205
#if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
 
206
    #define wxNEED_WPRINTF
 
207
#endif
 
208
#if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_VSWSCANF)
 
209
    #define wxNEED_VSWSCANF
 
210
#endif
 
211
 
 
212
 
 
213
#if defined(wxNEED_WPRINTF)
 
214
    /*
 
215
        we need to implement all wide character printf functions either because
 
216
        we don't have them at all or because they don't have the semantics we
 
217
        need
 
218
     */
 
219
    int wxCRT_PrintfW( const wchar_t *format, ... );
 
220
    int wxCRT_FprintfW( FILE *stream, const wchar_t *format, ... );
 
221
    int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list ap );
 
222
    int wxCRT_VprintfW( const wchar_t *format, va_list ap );
 
223
    int wxCRT_VsprintfW( wchar_t *str, const wchar_t *format, va_list ap );
 
224
#else /* !wxNEED_WPRINTF */
 
225
    #define wxCRT_FprintfW      fwprintf
 
226
    #define wxCRT_PrintfW       wprintf
 
227
    #define wxCRT_VfprintfW     vfwprintf
 
228
    #define wxCRT_VprintfW      vwprintf
 
229
 
 
230
    #if defined(__WINDOWS__) && !defined(HAVE_VSWPRINTF)
 
231
        // only non-standard vswprintf() without buffer size argument can be used here
 
232
        #define  wxCRT_VsprintfW     vswprintf
 
233
    #endif
 
234
#endif /* wxNEED_WPRINTF */
 
235
 
 
236
 
 
237
/* Required for wxScanf() etc. */
 
238
#define wxCRT_ScanfA     scanf
 
239
#define wxCRT_SscanfA    sscanf
 
240
#define wxCRT_FscanfA    fscanf
 
241
#define wxCRT_VsscanfA   vsscanf
 
242
 
 
243
#if defined(wxNEED_WPRINTF)
 
244
    int wxCRT_ScanfW(const wchar_t *format, ...);
 
245
    int wxCRT_SscanfW(const wchar_t *str, const wchar_t *format, ...);
 
246
    int wxCRT_FscanfW(FILE *stream, const wchar_t *format, ...);
 
247
#else
 
248
    #define wxCRT_ScanfW     wxVMS_USE_STD wscanf
 
249
    #define wxCRT_SscanfW    wxVMS_USE_STD swscanf
 
250
    #define wxCRT_FscanfW    wxVMS_USE_STD fwscanf
 
251
#endif
 
252
#ifdef wxNEED_VSWSCANF
 
253
    int wxCRT_VsscanfW(const wchar_t *str, const wchar_t *format, va_list ap);
 
254
#else
 
255
    #define wxCRT_VsscanfW   wxVMS_USE_STD vswscanf
 
256
#endif
 
257
 
 
258
// ----------------------------------------------------------------------------
 
259
// user-friendly wrappers to CRT functions
 
260
// ----------------------------------------------------------------------------
 
261
 
 
262
#ifdef __WATCOMC__
 
263
    // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 
264
    #define wxPrintf    wxPrintf_Impl
 
265
    #define wxFprintf   wxFprintf_Impl
 
266
    #define wxSprintf   wxSprintf_Impl
 
267
    #define wxSnprintf  wxSnprintf_Impl
 
268
#endif
 
269
 
 
270
    // FIXME-UTF8: remove this
 
271
#if wxUSE_UNICODE
 
272
    #define wxCRT_PrintfNative wxCRT_PrintfW
 
273
    #define wxCRT_FprintfNative wxCRT_FprintfW
 
274
#else
 
275
    #define wxCRT_PrintfNative wxCRT_PrintfA
 
276
    #define wxCRT_FprintfNative wxCRT_FprintfA
 
277
#endif
 
278
 
 
279
 
 
280
WX_DEFINE_VARARG_FUNC_SANS_N0(int, wxPrintf, 1, (const wxFormatString&),
 
281
                              wxCRT_PrintfNative, wxCRT_PrintfA)
 
282
inline int wxPrintf(const wxFormatString& s)
 
283
{
 
284
    return wxPrintf("%s", s.InputAsString());
 
285
}
 
286
 
 
287
WX_DEFINE_VARARG_FUNC_SANS_N0(int, wxFprintf, 2, (FILE*, const wxFormatString&),
 
288
                              wxCRT_FprintfNative, wxCRT_FprintfA)
 
289
inline int wxFprintf(FILE *f, const wxFormatString& s)
 
290
{
 
291
    return wxFprintf(f, "%s", s.InputAsString());
 
292
}
 
293
 
 
294
// va_list versions of printf functions simply forward to the respective
 
295
// CRT function; note that they assume that va_list was created using
 
296
// wxArgNormalizer<T>!
 
297
#if wxUSE_UNICODE_UTF8
 
298
    #if wxUSE_UTF8_LOCALE_ONLY
 
299
        #define WX_VARARG_VFOO_IMPL(args, implW, implA)              \
 
300
            return implA args
 
301
    #else
 
302
        #define WX_VARARG_VFOO_IMPL(args, implW, implA)              \
 
303
            if ( wxLocaleIsUtf8 ) return implA args;                 \
 
304
            else return implW args
 
305
    #endif
 
306
#elif wxUSE_UNICODE_WCHAR
 
307
    #define WX_VARARG_VFOO_IMPL(args, implW, implA)                  \
 
308
        return implW args
 
309
#else // ANSI
 
310
    #define WX_VARARG_VFOO_IMPL(args, implW, implA)                  \
 
311
        return implA args
 
312
#endif
 
313
 
 
314
inline int
 
315
wxVprintf(const wxString& format, va_list ap)
 
316
{
 
317
    WX_VARARG_VFOO_IMPL((wxFormatString(format), ap),
 
318
                        wxCRT_VprintfW, wxCRT_VprintfA);
 
319
}
 
320
 
 
321
inline int
 
322
wxVfprintf(FILE *f, const wxString& format, va_list ap)
 
323
{
 
324
    WX_VARARG_VFOO_IMPL((f, wxFormatString(format), ap),
 
325
                        wxCRT_VfprintfW, wxCRT_VfprintfA);
 
326
}
 
327
 
 
328
#undef WX_VARARG_VFOO_IMPL
 
329
 
 
330
 
 
331
// wxSprintf() and friends have to be implemented in two forms, one for
 
332
// writing to char* buffer and one for writing to wchar_t*:
 
333
 
 
334
#if !wxUSE_UTF8_LOCALE_ONLY
 
335
int WXDLLIMPEXP_BASE wxDoSprintfWchar(char *str, const wxChar *format, ...);
 
336
#endif
 
337
#if wxUSE_UNICODE_UTF8
 
338
int WXDLLIMPEXP_BASE wxDoSprintfUtf8(char *str, const char *format, ...);
 
339
#endif
 
340
WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (char*, const wxFormatString&),
 
341
                      wxDoSprintfWchar, wxDoSprintfUtf8)
 
342
 
 
343
int WXDLLIMPEXP_BASE
 
344
wxVsprintf(char *str, const wxString& format, va_list argptr);
 
345
 
 
346
#if !wxUSE_UTF8_LOCALE_ONLY
 
347
int WXDLLIMPEXP_BASE wxDoSnprintfWchar(char *str, size_t size, const wxChar *format, ...);
 
348
#endif
 
349
#if wxUSE_UNICODE_UTF8
 
350
int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(char *str, size_t size, const char *format, ...);
 
351
#endif
 
352
WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (char*, size_t, const wxFormatString&),
 
353
                      wxDoSnprintfWchar, wxDoSnprintfUtf8)
 
354
 
 
355
int WXDLLIMPEXP_BASE
 
356
wxVsnprintf(char *str, size_t size, const wxString& format, va_list argptr);
 
357
 
 
358
#if wxUSE_UNICODE
 
359
 
 
360
#if !wxUSE_UTF8_LOCALE_ONLY
 
361
int WXDLLIMPEXP_BASE wxDoSprintfWchar(wchar_t *str, const wxChar *format, ...);
 
362
#endif
 
363
#if wxUSE_UNICODE_UTF8
 
364
int WXDLLIMPEXP_BASE wxDoSprintfUtf8(wchar_t *str, const char *format, ...);
 
365
#endif
 
366
WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (wchar_t*, const wxFormatString&),
 
367
                      wxDoSprintfWchar, wxDoSprintfUtf8)
 
368
 
 
369
int WXDLLIMPEXP_BASE
 
370
wxVsprintf(wchar_t *str, const wxString& format, va_list argptr);
 
371
 
 
372
#if !wxUSE_UTF8_LOCALE_ONLY
 
373
int WXDLLIMPEXP_BASE wxDoSnprintfWchar(wchar_t *str, size_t size, const wxChar *format, ...);
 
374
#endif
 
375
#if wxUSE_UNICODE_UTF8
 
376
int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...);
 
377
#endif
 
378
WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (wchar_t*, size_t, const wxFormatString&),
 
379
                      wxDoSnprintfWchar, wxDoSnprintfUtf8)
 
380
 
 
381
int WXDLLIMPEXP_BASE
 
382
wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argptr);
 
383
 
 
384
#endif // wxUSE_UNICODE
 
385
 
 
386
#ifdef __WATCOMC__
 
387
    // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
 
388
    //
 
389
    // fortunately, OpenWatcom implements __VA_ARGS__, so we can provide macros
 
390
    // that cast the format argument to wxString:
 
391
    #undef wxPrintf
 
392
    #undef wxFprintf
 
393
    #undef wxSprintf
 
394
    #undef wxSnprintf
 
395
 
 
396
    #define wxPrintf(fmt, ...) \
 
397
            wxPrintf_Impl(wxFormatString(fmt), __VA_ARGS__)
 
398
    #define wxFprintf(f, fmt, ...) \
 
399
            wxFprintf_Impl(f, wxFormatString(fmt), __VA_ARGS__)
 
400
    #define wxSprintf(s, fmt, ...) \
 
401
            wxSprintf_Impl(s, wxFormatString(fmt), __VA_ARGS__)
 
402
    #define wxSnprintf(s, n, fmt, ...) \
 
403
            wxSnprintf_Impl(s, n, wxFormatString(fmt), __VA_ARGS__)
 
404
#endif // __WATCOMC__
 
405
 
 
406
 
 
407
// We can't use wxArgNormalizer<T> for variadic arguments to wxScanf() etc.
 
408
// because they are writable, so instead of providing friendly template
 
409
// vararg-like functions, we just provide both char* and wchar_t* variants
 
410
// of these functions. The type of output variadic arguments for %s must match
 
411
// the type of 'str' and 'format' arguments.
 
412
//
 
413
// For compatibility with earlier wx versions, we also provide wxSscanf()
 
414
// version with the first argument (input string) wxString; for this version,
 
415
// the type of output string values is determined by the type of format string
 
416
// only.
 
417
 
 
418
#define _WX_SCANFUNC_EXTRACT_ARGS_1(x)   x
 
419
#define _WX_SCANFUNC_EXTRACT_ARGS_2(x,y) x, y
 
420
#define _WX_SCANFUNC_EXTRACT_ARGS(N, args) _WX_SCANFUNC_EXTRACT_ARGS_##N args
 
421
 
 
422
#define _WX_VARARG_PASS_WRITABLE(i) a##i
 
423
 
 
424
#define _WX_DEFINE_SCANFUNC(N, dummy1, name, impl, passfixed, numfixed, fixed)\
 
425
    template<_WX_VARARG_JOIN(N, _WX_VARARG_TEMPL)>                            \
 
426
    int name(_WX_SCANFUNC_EXTRACT_ARGS(numfixed, fixed),                      \
 
427
             _WX_VARARG_JOIN(N, _WX_VARARG_ARG))                              \
 
428
    {                                                                         \
 
429
        return  impl(_WX_SCANFUNC_EXTRACT_ARGS(numfixed, passfixed),          \
 
430
                     _WX_VARARG_JOIN(N, _WX_VARARG_PASS_WRITABLE));           \
 
431
    }
 
432
 
 
433
#define WX_DEFINE_SCANFUNC(name, numfixed, fixed, impl, passfixed)            \
 
434
    _WX_VARARG_ITER(_WX_VARARG_MAX_ARGS,                                      \
 
435
                    _WX_DEFINE_SCANFUNC,                                      \
 
436
                    dummy1, name, impl, passfixed, numfixed, fixed)
 
437
 
 
438
// this is needed to normalize the format string, see src/common/strvararg.cpp
 
439
// for more details
 
440
#ifdef __WINDOWS__
 
441
    #define wxScanfConvertFormatW(fmt) fmt
 
442
#else
 
443
    const wxScopedWCharBuffer
 
444
    WXDLLIMPEXP_BASE wxScanfConvertFormatW(const wchar_t *format);
 
445
#endif
 
446
 
 
447
WX_DEFINE_SCANFUNC(wxScanf, 1, (const char *format),
 
448
                   wxCRT_ScanfA, (format))
 
449
WX_DEFINE_SCANFUNC(wxScanf, 1, (const wchar_t *format),
 
450
                   wxCRT_ScanfW, (wxScanfConvertFormatW(format)))
 
451
 
 
452
WX_DEFINE_SCANFUNC(wxFscanf, 2, (FILE *stream, const char *format),
 
453
                   wxCRT_FscanfA, (stream, format))
 
454
WX_DEFINE_SCANFUNC(wxFscanf, 2, (FILE *stream, const wchar_t *format),
 
455
                   wxCRT_FscanfW, (stream, wxScanfConvertFormatW(format)))
 
456
 
 
457
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const char *str, const char *format),
 
458
                   wxCRT_SscanfA, (str, format))
 
459
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wchar_t *str, const wchar_t *format),
 
460
                   wxCRT_SscanfW, (str, wxScanfConvertFormatW(format)))
 
461
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxScopedCharBuffer& str, const char *format),
 
462
                   wxCRT_SscanfA, (str.data(), format))
 
463
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxScopedWCharBuffer& str, const wchar_t *format),
 
464
                   wxCRT_SscanfW, (str.data(), wxScanfConvertFormatW(format)))
 
465
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxString& str, const char *format),
 
466
                   wxCRT_SscanfA, (str.mb_str(), format))
 
467
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxString& str, const wchar_t *format),
 
468
                   wxCRT_SscanfW, (str.wc_str(), wxScanfConvertFormatW(format)))
 
469
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxCStrData& str, const char *format),
 
470
                   wxCRT_SscanfA, (str.AsCharBuf(), format))
 
471
WX_DEFINE_SCANFUNC(wxSscanf, 2, (const wxCStrData& str, const wchar_t *format),
 
472
                   wxCRT_SscanfW, (str.AsWCharBuf(), wxScanfConvertFormatW(format)))
 
473
 
 
474
// Visual C++ doesn't provide vsscanf()
 
475
#ifndef __VISUALC___
 
476
int WXDLLIMPEXP_BASE wxVsscanf(const char *str, const char *format, va_list ap);
 
477
int WXDLLIMPEXP_BASE wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap);
 
478
int WXDLLIMPEXP_BASE wxVsscanf(const wxScopedCharBuffer& str, const char *format, va_list ap);
 
479
int WXDLLIMPEXP_BASE wxVsscanf(const wxScopedWCharBuffer& str, const wchar_t *format, va_list ap);
 
480
int WXDLLIMPEXP_BASE wxVsscanf(const wxString& str, const char *format, va_list ap);
 
481
int WXDLLIMPEXP_BASE wxVsscanf(const wxString& str, const wchar_t *format, va_list ap);
 
482
int WXDLLIMPEXP_BASE wxVsscanf(const wxCStrData& str, const char *format, va_list ap);
 
483
int WXDLLIMPEXP_BASE wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap);
 
484
#endif // !__VISUALC__
 
485
 
 
486
#endif /* _WX_WXCRTVARARG_H_ */