1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Declarations common to wx char/wchar_t usage (wide chars)
4 // Author: Joel Farley, Ove Kåven
5 // Modified by: Vadim Zeitlin, Robert Roebling
8 // Copyright: (c) 1998-2002 wxWindows dev team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
16 #pragma interface "wxchar.h"
19 // ----------------------------------------------------------------------------
20 // first deal with Unicode setting: wxUSE_UNICODE should be defined as 0 or 1
21 // and is used by wxWindows, _UNICODE and/or UNICODE may be defined or used by
22 // the system headers so bring these settings in sync
23 // ----------------------------------------------------------------------------
25 // set wxUSE_UNICODE to 1 if UNICODE or _UNICODE is defined
26 #if defined(_UNICODE) || defined(UNICODE)
28 #define wxUSE_UNICODE 1
31 #define wxUSE_UNICODE 0
35 // and vice versa: define UNICODE and _UNICODE if wxUSE_UNICODE is 1...
45 // check whether we have wchar_t
46 #if !defined(wxUSE_WCHAR_T)
47 #if defined(__WIN16__)
48 // no wchar_t under Win16 regadrless of compiler used
49 #define wxUSE_WCHAR_T 0
50 #elif defined(__UNIX__)
51 #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
52 #define wxUSE_WCHAR_T 1
54 #define wxUSE_WCHAR_T 0
56 #elif defined(__GNUWIN32__) && !defined(__MINGW32__)
57 #define wxUSE_WCHAR_T 0
58 #elif defined(__WATCOMC__)
59 #define wxUSE_WCHAR_T 0
60 #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
61 #define wxUSE_WCHAR_T 0
63 // add additional compiler checks if this fails
64 #define wxUSE_WCHAR_T 1
66 #endif // !defined(wxUSE_WCHAR_T)
68 // Unicode support requires wchar_t
69 #if wxUSE_UNICODE && !wxUSE_WCHAR_T
70 #error "wchar_t must be available in Unicode build"
73 // ----------------------------------------------------------------------------
74 // standard headers we need here
76 // NB: don't include any wxWindows headers here because almost of them include
78 // ----------------------------------------------------------------------------
80 // Required for wxPrintf() etc
83 // Almost all compiler have strdup(), but not quite all: CodeWarrior under Mac
84 // and VC++ for Windows CE don't provide it
85 #if !(defined(__MWERKS__) && defined(__WXMAC__)) && !defined(__WXWINCE__)
86 // use #define, not inline wrapper, as it is tested with #ifndef below
87 #define wxStrdupA strdup
90 // non Unix compilers which do have wchar.h (but not tchar.h which is included
91 // below and which includes wchar.h anyhow).
92 // Actually MinGW has tchar.h, but it does not include wchar.h
93 #if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__)
101 // the current (as of Nov 2002) version of cygwin has a bug in its
102 // wchar.h -- there is no extern "C" around the declarations in it and
103 // this results in linking errors later; also, at least on some
104 // Cygwin versions, wchar.h requires sys/types.h
106 #include <sys/types.h>
113 #elif defined(HAVE_WCSTR_H)
114 // old compilers have relevant declarations here
116 #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
117 // include stdlib.h for wchar_t
119 #endif // HAVE_WCHAR_H
120 #endif // wxUSE_WCHAR_T
122 // ----------------------------------------------------------------------------
123 // define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type
124 // mapped to either char or wchar_t depending on the ASCII/Unicode mode and have
125 // the function mapping _tfoo() -> foo() or wfoo()
126 // ----------------------------------------------------------------------------
128 // VC++ and BC++ starting with 5.2 have TCHAR support
130 #define wxHAVE_TCHAR_SUPPORT
131 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
132 #define wxHAVE_TCHAR_SUPPORT
134 #elif defined(__WATCOMC__)
135 #define wxHAVE_TCHAR_SUPPORT
136 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
137 #define wxHAVE_TCHAR_SUPPORT
141 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
142 // VZ: the old VisualAge definitions were completely wrong and had no
143 // chance at all to work in Unicode build anyhow so let's pretend that
144 // VisualAge does _not_ support TCHAR for the moment (as indicated by
145 // "0 &&" above) until someone really has time to delve into Unicode
148 // VisualAge 4.0+ supports TCHAR
149 #define wxHAVE_TCHAR_SUPPORT
150 #endif // compilers with (good) TCHAR support
156 #ifdef wxHAVE_TCHAR_SUPPORT
157 // get TCHAR definition if we've got it
160 // we surely do have wchar_t if we have TCHAR
161 #ifndef wxUSE_WCHAR_T
162 #define wxUSE_WCHAR_T 1
163 #endif // !defined(wxUSE_WCHAR_T)
165 // and we also do have wcslen()
169 #endif // wxHAVE_TCHAR_SUPPORT
171 // ----------------------------------------------------------------------------
172 // define wxChar type
173 // ----------------------------------------------------------------------------
175 // TODO: define wxCharInt to be equal to either int or wint_t?
179 typedef signed char wxSChar
;
180 typedef unsigned char wxUChar
;
182 // VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as
183 // signed/unsigned version of it which (a) makes sense to me (unlike
184 // char wchar_t is always unsigned) and (b) was how the previous
185 // definitions worked so keep it like this
187 // GNU libc has __WCHAR_TYPE__ which requires special treatment, see
189 #if !defined(__WCHAR_TYPE__) || \
190 (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
192 typedef wchar_t wxChar
;
193 typedef wchar_t wxSChar
;
194 typedef wchar_t wxUChar
;
195 #else // __WCHAR_TYPE__ and gcc < 2.96
196 // VS: wxWindows used to define wxChar as __WCHAR_TYPE__ here. However,
197 // this doesn't work with new GCC 3.x compilers because wchar_t is
198 // C++'s builtin type in the new standard. OTOH, old compilers (GCC
199 // 2.x) won't accept new definition of wx{S,U}Char, therefore we
200 // have to define wxChar conditionally depending on detected
201 // compiler & compiler version.
202 // with old definition of wxChar.
203 typedef __WCHAR_TYPE__ wxChar
;
204 typedef __WCHAR_TYPE__ wxSChar
;
205 typedef __WCHAR_TYPE__ wxUChar
;
206 #endif // __WCHAR_TYPE__
207 #endif // ASCII/Unicode
209 // ----------------------------------------------------------------------------
210 // define _T() and related macros
211 // ----------------------------------------------------------------------------
213 // BSD systems define _T() to be something different in ctype.h, override it
214 #if defined(__FreeBSD__) || defined(__DARWIN__)
219 // could already be defined by tchar.h (it's quasi standard)
225 #endif // ASCII/Unicode
226 #endif // !defined(_T)
228 // although global macros with such names are normally bad, we want to have
229 // another name for _T() which should be used to avoid confusion between _T()
230 // and _() in wxWindows sources
233 // Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs
235 #define __XFILE__(x) wxT(x)
236 #define __TFILE__ __XFILE__(__FILE__)
240 #define __XDATE__(x) wxT(x)
241 #define __TDATE__ __XDATE__(__DATE__)
245 #define __XTIME__(x) wxT(x)
246 #define __TTIME__ __XTIME__(__TIME__)
249 // ----------------------------------------------------------------------------
250 // define wxFoo() function for each standard foo() function whose signature
251 // (exceptionally including the return type) includes any mention of char:
252 // wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
253 // the same signature but with char replaced by wxChar which allows us to use
254 // it in Unicode build as well
255 // ----------------------------------------------------------------------------
257 #ifdef wxHAVE_TCHAR_SUPPORT
261 #define wxIsalnum _istalnum
262 #define wxIsalpha _istalpha
263 #define wxIsctrl _istctrl
264 #define wxIsdigit _istdigit
265 #define wxIsgraph _istgraph
266 #define wxIslower _istlower
267 #define wxIsprint _istprint
268 #define wxIspunct _istpunct
269 #define wxIsspace _istspace
270 #define wxIsupper _istupper
271 #define wxIsxdigit _istxdigit
272 #define wxTolower _totlower
273 #define wxToupper _totupper
276 #define wxSetlocale _tsetlocale
278 // string.h functions
279 #define wxStrcat _tcscat
280 #define wxStrchr _tcschr
281 #define wxStrcmp _tcscmp
282 #define wxStrcoll _tcscoll
283 #define wxStrcpy _tcscpy
284 #define wxStrcspn _tcscspn
285 #define wxStrdupW _wcsdup // notice the 'W'!
286 #define wxStrftime _tcsftime
287 #define wxStricmp _tcsicmp
288 #define wxStrnicmp _tcsnicmp
289 #define wxStrlen_ _tcslen // used in wxStrlen inline function
290 #define wxStrncat _tcsncat
291 #define wxStrncmp _tcsncmp
292 #define wxStrncpy _tcsncpy
293 #define wxStrpbrk _tcspbrk
294 #define wxStrrchr _tcsrchr
295 #define wxStrspn _tcsspn
296 #define wxStrstr _tcsstr
297 #define wxStrtod _tcstod
298 #define wxStrtol _tcstol
299 #define wxStrtoul _tcstoul
300 #define wxStrxfrm _tcsxfrm
303 #define wxFgetc _fgettc
304 #define wxFgetchar _fgettchar
305 #define wxFgets _fgetts
306 #define wxFopen _tfopen
307 #define wxFputc _fputtc
308 #define wxFputchar _fputtchar
309 #define wxFprintf _ftprintf
310 #define wxFputs _fputts
311 #define wxFreopen _tfreopen
312 #define wxFscanf _ftscanf
313 #define wxGetc _gettc
314 #define wxGetchar _gettchar
315 #define wxGets _getts
316 #define wxPerror _tperror
317 #define wxPrintf _tprintf
318 #define wxPutc _puttc
319 #define wxPutchar _puttchar
320 #define wxPuts _putts
321 #define wxScanf _tscanf
322 #define wxSprintf _stprintf
323 #define wxSscanf _stscanf
324 #define wxTmpnam _ttmpnam
325 #define wxUngetc _tungetc
326 #define wxVfprintf _vftprintf
327 #define wxVprintf _vtprintf
328 #define wxVsscanf _vstscanf
329 #define wxVsprintf _vstprintf
331 // special case: not all TCHAR-aware compilers have those
332 #if defined(__VISUALC__) || \
333 (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
334 #define wxVsnprintf_ _vsntprintf
335 #define wxSnprintf_ _sntprintf
338 // special case: these functions are missing under Win9x with Unicows so we
339 // have to implement them ourselves
340 #if wxUSE_UNICODE_MSLU
341 #define wxRemove wxMSLU__tremove
342 #define wxRename wxMSLU__trename
345 #define wxRemove DeleteFile
347 #define wxRemove _tremove
348 #define wxRename _trename
352 // stdlib.h functions
355 // #define wxAtof _tttof -- notice that there is no such thing (why?)
356 #define wxGetenv _tgetenv
357 #define wxSystem _tsystem
360 #define wxAsctime _tasctime
361 #define wxCtime _tctime
362 #else // !TCHAR-aware compilers
366 // this is probably glibc-specific
367 #if defined(__WCHAR_TYPE__)
368 // ctype.h functions (wctype.h)
369 #define wxIsalnum iswalnum
370 #define wxIsalpha iswalpha
371 #define wxIsctrl iswcntrl
372 #define wxIsdigit iswdigit
373 #define wxIsgraph iswgraph
374 #define wxIslower iswlower
375 #define wxIsprint iswprint
376 #define wxIspunct iswpunct
377 #define wxIsspace iswspace
378 #define wxIsupper iswupper
379 #define wxIsxdigit iswxdigit
381 #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
382 // /usr/include/wctype.h incorrectly declares translations
383 // tables which provokes tons of compile-time warnings -- try
385 #define wxTolower(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
386 #define wxToupper(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
388 #define wxTolower towlower
389 #define wxToupper towupper
392 // string.h functions (wchar.h)
393 #define wxStrcat wcscat
394 #define wxStrchr wcschr
395 #define wxStrcmp wcscmp
396 #define wxStrcoll wcscoll
397 #define wxStrcpy wcscpy
398 #define wxStrcspn wcscspn
399 #define wxStrlen_ wxWcslen // wxStrlen_() is used in wxStrlen()
400 #define wxStrncat wcsncat
401 #define wxStrncmp wcsncmp
402 #define wxStrncpy wcsncpy
403 #define wxStrpbrk wcspbrk
404 #define wxStrrchr wcsrchr
405 #define wxStrspn wcsspn
406 #define wxStrstr wcsstr
407 #define wxStrtod wcstod
408 #define wxStrtol wcstol
409 #define wxStrtoul wcstoul
410 #define wxStrxfrm wcsxfrm
412 #define wxFgetc fgetwc
413 #define wxFgetchar fgetwchar
414 #define wxFgets fgetws
415 #define wxFputc fputwc
416 #define wxFputchar fputwchar
418 #define wxGetchar getwchar
420 #define wxUngetc ungetwc
424 #define wxPutchar wputchar
426 #define wxFputs fputws
428 #define wxNEED_FPUTWC
432 int wxFputs(const wxChar
*ch
, FILE *stream
);
433 int wxPutc(wxChar ch
, FILE *stream
);
435 #define wxPuts(ws) wxFputs(ws, stdout)
436 #define wxPutchar(wch) wxPutc(wch, stdout)
439 // we need %s to %ls conversion for printf and scanf etc
440 #define wxNEED_PRINTF_CONVERSION
442 // glibc doesn't have wide char equivalents of the other stuff so
443 // use our own versions
444 #define wxNEED_WX_STDIO_H
445 #define wxNEED_WX_STDLIB_H
446 #define wxNEED_WX_TIME_H
447 #elif defined(__MWERKS__) && ( defined(macintosh) || defined(__MACH__) )
448 // ctype.h functions (wctype.h)
449 #define wxIsalnum iswalnum
450 #define wxIsalpha iswalpha
451 #define wxIsctrl iswcntrl
452 #define wxIsdigit iswdigit
453 #define wxIsgraph iswgraph
454 #define wxIslower iswlower
455 #define wxIsprint iswprint
456 #define wxIspunct iswpunct
457 #define wxIsspace iswspace
458 #define wxIsupper iswupper
459 #define wxIsxdigit iswxdigit
460 #define wxTolower towlower
461 #define wxToupper towupper
463 // string.h functions (wchar.h)
464 #define wxStrcat wcscat
465 #define wxStrchr wcschr
466 #define wxStrcmp wcscmp
467 #define wxStrcoll wcscoll
468 #define wxStrcpy wcscpy
469 #define wxStrcspn wcscspn
470 #define wxStrlen_ wxWcslen // wxStrlen_() is used in wxStrlen()
471 #define wxStrncat wcsncat
472 #define wxStrncmp wcsncmp
473 #define wxStrncpy wcsncpy
474 #define wxStrpbrk wcspbrk
475 #define wxStrrchr wcsrchr
476 #define wxStrspn wcsspn
477 #define wxStrstr wcsstr
478 #define wxStrtod wcstod
479 #define wxStrtol wcstol
480 #define wxStrtoul wcstoul
481 #define wxStrxfrm wcsxfrm
483 #define wxFgetc fgetwc
484 #define wxFgetchar fgetwchar
485 #define wxFgets fgetws
486 #define wxFputc fputwc
487 #define wxFputchar fputwchar
489 #define wxGetchar getwchar
491 #define wxUngetc ungetwc
493 #define wxNEED_PRINTF_CONVERSION
496 #define wxPutchar putwchar
497 #define wxFputs fputws
501 #define wxNEED_WX_STDIO_H
503 // stdlib.h functions
507 #define wxGetenv(a) ((wxChar*)NULL)
508 #define wxSystem(a) ((int)NULL)
511 #define wxAsctime wasciitime
512 #define wxCtime wctime
513 // #define wxStrftime wcsftime
516 #define wxNEED_FPUTWC
520 int wxFputs(const wxChar *ch, FILE *stream);
521 int wxPutc(wxChar ch, FILE *stream);
523 #define wxPuts(ws) wxFputs(ws, stdout)
524 #define wxPutchar(wch) wxPutc(wch, stdout)
526 // we need %s to %ls conversion for printf and scanf etc
527 #define wxNEED_PRINTF_CONVERSION
528 // glibc doesn't have wide char equivalents of the other stuff so
529 // use our own versions
530 #define wxNEED_WX_STDIO_H
531 #define wxNEED_WX_STDLIB_H
533 #define wxNEED_WX_TIME_H
534 #else // !metrowerks for apple
535 #error "Please define wide character functions for your environment"
542 #define wxIsalnum isalnum
543 #define wxIsalpha isalpha
544 #define wxIsctrl isctrl
545 #define wxIsdigit isdigit
546 #define wxIsgraph isgraph
547 #define wxIslower islower
548 #define wxIsprint isprint
549 #define wxIspunct ispunct
550 #define wxIsspace isspace
551 #define wxIsupper isupper
552 #define wxIsxdigit isxdigit
553 #define wxTolower tolower
554 #define wxToupper toupper
557 #define wxSetlocale setlocale
559 // string.h functions
560 #define wxStrcat strcat
561 #define wxStrchr strchr
562 #define wxStrcmp strcmp
563 #define wxStrcoll strcoll
564 #define wxStrcpy strcpy
565 #define wxStrcspn strcspn
567 // wxStricmp and wxStrnicmp are defined below
568 #define wxStrlen_ strlen // used in wxStrlen inline function
569 #define wxStrncat strncat
570 #define wxStrncmp strncmp
571 #define wxStrncpy strncpy
572 #define wxStrpbrk strpbrk
573 #define wxStrrchr strrchr
574 #define wxStrspn strspn
575 #define wxStrstr strstr
576 #define wxStrtod strtod
578 #define wxStrtok(str, sep, last) strtok_r(str, sep, last)
580 #define wxStrtol strtol
581 #define wxStrtoul strtoul
582 #define wxStrxfrm strxfrm
585 #define wxFopen fopen
586 #define wxFreopen freopen
587 #define wxRemove remove
588 #define wxRename rename
590 #define wxPerror perror
591 #define wxTmpnam tmpnam
593 #define wxFgetc fgetc
594 #define wxFgetchar fgetchar
595 #define wxFgets fgets
596 #define wxFputc fputc
597 #define wxFputchar fputchar
598 #define wxFprintf fprintf
599 #define wxFscanf fscanf
601 #define wxGetchar getchar
603 #define wxPrintf printf
605 #define wxPutchar putchar
607 #define wxScanf scanf
608 #define wxSprintf sprintf
609 #define wxSscanf sscanf
610 #define wxUngetc ungetc
611 #define wxVfprintf vfprintf
612 #define wxVprintf vprintf
613 #define wxVsscanf vsscanf
614 #define wxVsprintf vsprintf
616 // stdlib.h functions
620 #define wxGetenv getenv
621 #define wxSystem system
624 #define wxAsctime asctime
625 #define wxCtime ctime
626 #define wxStrftime strftime
627 #endif // Unicode/ASCII
628 #endif // TCHAR-aware compilers/the others
630 // ----------------------------------------------------------------------------
631 // various special cases
632 // ----------------------------------------------------------------------------
634 // define wxStricmp and wxStrnicmp for various compilers
636 // note that in Unicode mode we definitely are going to need our own version
637 #if !defined(wxStricmp) && !wxUSE_UNICODE
638 #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
639 defined(__SALFORDC__) || defined(__VISAGECPP__) || \
640 defined(__EMX__) || defined(__DJGPP__)
641 #define wxStricmp stricmp
642 #define wxStrnicmp strnicmp
643 #elif defined(__SYMANTEC__) || defined(__VISUALC__) || \
644 (defined(__MWERKS__) && defined(__INTEL__))
645 #define wxStricmp _stricmp
646 #define wxStrnicmp _strnicmp
647 #elif defined(__UNIX__) || defined(__GNUWIN32__)
648 #define wxStricmp strcasecmp
649 #define wxStrnicmp strncasecmp
650 // #else -- use wxWindows implementation
652 #endif // !defined(wxStricmp)
654 // define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
655 // it's used in wx/buffer.h -- and also might be used just below by wxStrlen()
656 // when wxStrlen_() is #define'd as wxWcslen so do it before defining wxStrlen)
659 #define wxWcslen wcslen
661 inline size_t wxWcslen(const wchar_t *s
)
670 #endif // wxUSE_WCHAR_T
672 // checks whether the passed in pointer is NULL and if the string is empty
673 inline bool wxIsEmpty(const wxChar
*p
) { return !p
|| !*p
; }
675 // safe version of strlen() (returns 0 if passed NULL pointer)
676 inline size_t wxStrlen(const wxChar
*psz
) { return psz
? wxStrlen_(psz
) : 0; }
678 // each of strdup() and wcsdup() may or may not be available but we need both
679 // of them anyhow for wx/buffer.h so we define the missing one(s) in
680 // wxchar.cpp and so we should always have both wxStrdupA and wxStrdupW
681 // defined -- if this is somehow not the case in some situations, please
682 // correct that and not the lines here
684 #define wxStrdup wxStrdupW
686 #define wxStrdup wxStrdupA
689 WXDLLIMPEXP_BASE
bool wxOKlibc(); // for internal use
691 // ----------------------------------------------------------------------------
692 // printf() family saga
693 // ----------------------------------------------------------------------------
696 For some systems vsnprintf() exists in the system libraries but not in the
697 headers, so we need to declare it ourselves to be able to use it.
699 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
701 int vsnprintf(char *str
, size_t size
, const char *format
, va_list ap
);
702 #endif // !HAVE_VSNPRINTF_DECL
705 First of all, we always want to define safe snprintf() function to be used
706 instead of sprintf(). Some compilers already have it (or rather vsnprintf()
707 which we really need...), otherwise we implement it using our own printf()
710 We define function with a trailing underscore here because the real one is a
711 wrapper around it as explained below
715 #if defined(__MWERKS__)
716 #define HAVE_WCSRTOMBS 1
717 #define HAVE_VSWPRINTF 1
719 #if defined(HAVE__VSNWPRINTF)
720 #define wxVsnprintf_ _vsnwprintf
721 /* MinGW?MSVCRT has the wrong vswprintf */
722 #elif defined(HAVE_VSWPRINTF) && !defined(__MINGW32__)
723 #define wxVsnprintf_ vswprintf
726 // all versions of CodeWarrior supported by wxWindows apparently have
728 #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
729 // assume we have snprintf() too if we have vsnprintf()
730 #define wxVsnprintf_ vsnprintf
731 #define wxSnprintf_ snprintf
734 #endif // wxVsnprintf_ not defined yet
737 // no [v]snprintf(), cook our own
738 WXDLLIMPEXP_BASE
int wxSnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
,
739 ...) ATTRIBUTE_PRINTF_3
;
742 WXDLLIMPEXP_BASE
int wxVsnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
,
747 In Unicode mode we need to have all standard functions such as wprintf() and
748 so on but not all systems have them so use our own implementations in this
751 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
752 #define wxNEED_WPRINTF
756 More Unicode complications: although both ANSI C and C++ define a number of
757 wide character functions such as wprintf(), not all environments have them.
758 Worse, those which do have different behaviours: under Windows, %s format
759 specifier changes its meaning in Unicode build and expects a Unicode string
760 while under Unix/POSIX it still means an ASCII string even for wprintf() and
761 %ls has to be used for wide strings.
763 We choose to always emulate Windows behaviour as more useful for us so even
764 if we have wprintf() we still must wrap it in a non trivial wxPrintf().
766 However, if we don't have any vswprintf() at all we don't need to redefine
767 anything as our own wxVsnprintf_() already behaves as needed.
770 #undef wxNEED_PRINTF_CONVERSION
773 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
774 // we need to implement all wide character printf and scanf functions
775 // either because we don't have them at all or because they don't have the
778 #include <stdio.h> // for FILE
780 int wxScanf( const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_1
;
781 int wxSscanf( const wxChar
*str
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
782 int wxFscanf( FILE *stream
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
783 int wxVsscanf( const wxChar
*str
, const wxChar
*format
, va_list ap
);
784 int wxPrintf( const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_1
;
785 int wxSprintf( wxChar
*str
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
786 int wxFprintf( FILE *stream
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
787 int wxVfprintf( FILE *stream
, const wxChar
*format
, va_list ap
);
788 int wxVprintf( const wxChar
*format
, va_list ap
);
789 int wxVsprintf( wxChar
*str
, const wxChar
*format
, va_list ap
);
790 #endif // wxNEED_PRINTF_CONVERSION
792 // these 2 can be simply mapped to the versions with underscore at the end
793 // if we don't have to do the conversion
794 #ifdef wxNEED_PRINTF_CONVERSION
795 int wxSnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
796 int wxVsnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, va_list ap
);
798 #define wxSnprintf wxSnprintf_
799 #define wxVsnprintf wxVsnprintf_
802 // ----------------------------------------------------------------------------
803 // various functions which might not be available in libc and for which we
804 // provide our own replacements in wxchar.cpp
805 // ----------------------------------------------------------------------------
809 // VZ: note that this is never defined currently
810 #ifdef wxNEED_WX_CTYPE_H
811 WXDLLIMPEXP_BASE
int wxIsalnum(wxChar ch
);
812 WXDLLIMPEXP_BASE
int wxIsalpha(wxChar ch
);
813 WXDLLIMPEXP_BASE
int wxIsctrl(wxChar ch
);
814 WXDLLIMPEXP_BASE
int wxIsdigit(wxChar ch
);
815 WXDLLIMPEXP_BASE
int wxIsgraph(wxChar ch
);
816 WXDLLIMPEXP_BASE
int wxIslower(wxChar ch
);
817 WXDLLIMPEXP_BASE
int wxIsprint(wxChar ch
);
818 WXDLLIMPEXP_BASE
int wxIspunct(wxChar ch
);
819 WXDLLIMPEXP_BASE
int wxIsspace(wxChar ch
);
820 WXDLLIMPEXP_BASE
int wxIsupper(wxChar ch
);
821 WXDLLIMPEXP_BASE
int wxIsxdigit(wxChar ch
);
822 WXDLLIMPEXP_BASE
int wxTolower(wxChar ch
);
823 WXDLLIMPEXP_BASE
int wxToupper(wxChar ch
);
824 #endif // wxNEED_WX_CTYPE_H
826 // under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
827 // the file parsing -- this may be true for 5.0 as well, update #ifdef then
828 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
830 #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
834 // string.h functions
836 // VZ: this is never defined neither currently
837 #ifdef wxNEED_WX_STRING_H
838 WXDLLIMPEXP_BASE wxChar
* wxStrcat(wxChar
*dest
, const wxChar
*src
);
839 WXDLLIMPEXP_BASE
const wxChar
* wxStrchr(const wxChar
*s
, wxChar c
);
840 WXDLLIMPEXP_BASE wxChar
* wxStrchr(wxChar
*s
, wxChar c
)
841 { return (wxChar
*)wxStrchr((const wxChar
*)s
, c
); }
842 WXDLLIMPEXP_BASE
int wxStrcmp(const wxChar
*s1
, const wxChar
*s2
);
843 WXDLLIMPEXP_BASE
int wxStrcoll(const wxChar
*s1
, const wxChar
*s2
);
844 WXDLLIMPEXP_BASE wxChar
* wxStrcpy(wxChar
*dest
, const wxChar
*src
);
845 WXDLLIMPEXP_BASE
size_t wxStrcspn(const wxChar
*s
, const wxChar
*reject
);
846 WXDLLIMPEXP_BASE
size_t wxStrlen(const wxChar
*s
);
847 WXDLLIMPEXP_BASE wxChar
* wxStrncat(wxChar
*dest
, const wxChar
*src
, size_t n
);
848 WXDLLIMPEXP_BASE
int wxStrncmp(const wxChar
*s1
, const wxChar
*s2
, size_t n
);
849 WXDLLIMPEXP_BASE wxChar
* wxStrncpy(wxChar
*dest
, const wxChar
*src
, size_t n
);
850 WXDLLIMPEXP_BASE
const wxChar
* wxStrpbrk(const wxChar
*s
, const wxChar
*accept
);
851 WXDLLIMPEXP_BASE wxChar
* wxStrpbrk(wxChar
*s
, const wxChar
*accept
)
852 { return (wxChar
*)wxStrpbrk((const wxChar
*)s
, accept
); }
853 WXDLLIMPEXP_BASE
const wxChar
* wxStrrchr(const wxChar
*s
, wxChar c
);
854 WXDLLIMPEXP_BASE wxChar
* wxStrrchr(wxChar
*s
, wxChar c
)
855 { return (wxChar
*)wxStrrchr((const wxChar
*)s
, c
); }
856 WXDLLIMPEXP_BASE
size_t wxStrspn(const wxChar
*s
, const wxChar
*accept
);
857 WXDLLIMPEXP_BASE
const wxChar
* wxStrstr(const wxChar
*haystack
, const wxChar
*needle
);
858 WXDLLIMPEXP_BASE wxChar
*wxStrstr(wxChar
*haystack
, const wxChar
*needle
)
859 { return (wxChar
*)wxStrstr((const wxChar
*)haystack
, needle
); }
860 WXDLLIMPEXP_BASE
double wxStrtod(const wxChar
*nptr
, wxChar
**endptr
);
861 WXDLLIMPEXP_BASE
long int wxStrtol(const wxChar
*nptr
, wxChar
**endptr
, int base
);
862 WXDLLIMPEXP_BASE
unsigned long int wxStrtoul(const wxChar
*nptr
, wxChar
**endptr
, int base
);
863 WXDLLIMPEXP_BASE
size_t wxStrxfrm(wxChar
*dest
, const wxChar
*src
, size_t n
);
864 #endif // wxNEED_WX_STRING_H
867 WXDLLIMPEXP_BASE
char *wxStrdupA(const char *psz
);
871 WXDLLIMPEXP_BASE
wchar_t *wxStrdupW(const wchar_t *pwz
);
875 WXDLLIMPEXP_BASE
int wxStricmp(const wxChar
*psz1
, const wxChar
*psz2
);
879 WXDLLIMPEXP_BASE
int wxStrnicmp(const wxChar
*psz1
, const wxChar
*psz2
, size_t len
);
883 WXDLLIMPEXP_BASE wxChar
* wxStrtok(wxChar
*psz
, const wxChar
*delim
, wxChar
**save_ptr
);
887 class WXDLLIMPEXP_BASE wxWCharBuffer
;
888 WXDLLIMPEXP_BASE wxWCharBuffer
wxSetlocale(int category
, const wxChar
*locale
);
892 #ifdef wxNEED_WX_STDIO_H
894 WXDLLIMPEXP_BASE
FILE * wxFopen(const wxChar
*path
, const wxChar
*mode
);
895 WXDLLIMPEXP_BASE
FILE * wxFreopen(const wxChar
*path
, const wxChar
*mode
, FILE *stream
);
896 WXDLLIMPEXP_BASE
int wxRemove(const wxChar
*path
);
897 WXDLLIMPEXP_BASE
int wxRename(const wxChar
*oldpath
, const wxChar
*newpath
);
899 // *printf() family is handled separately
900 #endif // wxNEED_WX_STDIO_H
903 // stdlib.h functions
905 WXDLLIMPEXP_BASE
double wxAtof(const wxChar
*psz
);
908 #ifdef wxNEED_WX_STDLIB_H
909 WXDLLIMPEXP_BASE
int wxAtoi(const wxChar
*psz
);
910 WXDLLIMPEXP_BASE
long wxAtol(const wxChar
*psz
);
911 WXDLLIMPEXP_BASE wxChar
* wxGetenv(const wxChar
*name
);
912 WXDLLIMPEXP_BASE
int wxSystem(const wxChar
*psz
);
917 #ifdef wxNEED_WX_TIME_H
918 #if defined(__MWERKS__) && defined(macintosh)
921 WXDLLIMPEXP_BASE
size_t wxStrftime(wxChar
*s
, size_t max
,
922 const wxChar
*fmt
, const struct tm
*tm
);
923 #endif // wxNEED_WX_TIME_H
925 // missing functions in WinCE
927 WXDLLIMPEXP_BASE
char* strdup(const char* s
);
928 WXDLLIMPEXP_BASE
void *calloc( size_t num
, size_t size
);
930 #if _WIN32_WCE <= 211
931 WXDLLIMPEXP_BASE
int isspace(int c
);
932 WXDLLIMPEXP_BASE
int isascii( int c
);
936 // ----------------------------------------------------------------------------
937 // multibyte to wide char conversion functions and macros
938 // ----------------------------------------------------------------------------
941 // multibyte<->widechar conversion
942 WXDLLIMPEXP_BASE
size_t wxMB2WC(wchar_t *buf
, const char *psz
, size_t n
);
943 WXDLLIMPEXP_BASE
size_t wxWC2MB(char *buf
, const wchar_t *psz
, size_t n
);
946 #define wxMB2WX wxMB2WC
947 #define wxWX2MB wxWC2MB
948 #define wxWC2WX wxStrncpy
949 #define wxWX2WC wxStrncpy
951 #define wxMB2WX wxStrncpy
952 #define wxWX2MB wxStrncpy
953 #define wxWC2WX wxWC2MB
954 #define wxWX2WC wxMB2WC
956 #else // !wxUSE_UNICODE
957 // No wxUSE_WCHAR_T: we have to do something (JACS)
958 #define wxMB2WC wxStrncpy
959 #define wxWC2MB wxStrncpy
960 #define wxMB2WX wxStrncpy
961 #define wxWX2MB wxStrncpy
962 #define wxWC2WX wxWC2MB
963 #define wxWX2WC wxMB2WC
966 #endif //_WX_WXCHAR_H_