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(__APPLE__)
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__) // Cygwin (not Mingw32) doesn't have wcslen.h, needed in buffer.h
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 #if defined(__CYGWIN__)
86 #endif // !HAVE_WCSLEN
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 #if defined(__MWERKS__) || defined(__VISAGECPP__)
100 // include wchar.h to get wcslen() declaration used by wx/buffer.h
102 #elif defined(HAVE_WCSTR_H)
103 // old compilers have wcslen() here
105 #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
106 // include stdlib.h for wchar_t, wcslen is provided in wxchar.cpp
108 size_t WXDLLEXPORT
wcslen(const wchar_t *s
);
109 #endif // HAVE_WCHAR_H
110 #endif // wxUSE_WCHAR_T
112 // ----------------------------------------------------------------------------
113 // define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type
114 // mapped to either char or wchar_t depending on the ASCII/Unicode mode and have
115 // the function mapping _tfoo() -> foo() or wfoo()
116 // ----------------------------------------------------------------------------
118 // VC++ and BC++ starting with 5.2 have TCHAR support
120 #define wxHAVE_TCHAR_SUPPORT
121 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
122 #define wxHAVE_TCHAR_SUPPORT
124 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
125 #define wxHAVE_TCHAR_SUPPORT
129 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
130 // VZ: the old VisualAge definitions were completely wrong and had no
131 // chance at all to work in Unicode build anyhow so let's pretend that
132 // VisualAge does _not_ support TCHAR for the moment (as indicated by
133 // "0 &&" above) until someone really has time to delve into Unicode
136 // VisualAge 4.0+ supports TCHAR
137 #define wxHAVE_TCHAR_SUPPORT
138 #endif // compilers with (good) TCHAR support
140 #ifdef wxHAVE_TCHAR_SUPPORT
141 // get TCHAR definition if we've got it
144 // we surely do have wchar_t if we have TCHAR
145 #ifndef wxUSE_WCHAR_T
146 #define wxUSE_WCHAR_T 1
147 #endif // !defined(wxUSE_WCHAR_T)
149 // and we also do have wcslen()
153 #endif // wxHAVE_TCHAR_SUPPORT
155 // ----------------------------------------------------------------------------
156 // define wxChar type
157 // ----------------------------------------------------------------------------
159 // TODO: define wxCharInt to be equal to either int or wint_t?
163 typedef signed char wxSChar
;
164 typedef unsigned char wxUChar
;
166 // VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as
167 // signed/unsigned version of it which (a) makes sense to me (unlike
168 // char wchar_t is always unsigned) and (b) was how the previous
169 // definitions worked so keep it like this
171 // GNU libc has __WCHAR_TYPE__ which requires special treatment, see
173 #if !defined(__WCHAR_TYPE__) || \
174 (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
176 typedef wchar_t wxChar
;
177 typedef wchar_t wxSChar
;
178 typedef wchar_t wxUChar
;
179 #else // __WCHAR_TYPE__ and gcc < 2.96
180 // VS: wxWindows used to define wxChar as __WCHAR_TYPE__ here. However,
181 // this doesn't work with new GCC 3.x compilers because wchar_t is
182 // C++'s builtin type in the new standard. OTOH, old compilers (GCC
183 // 2.x) won't accept new definition of wx{S,U}Char, therefore we
184 // have to define wxChar conditionally depending on detected
185 // compiler & compiler version.
186 // with old definition of wxChar.
187 typedef __WCHAR_TYPE__ wxChar
;
188 typedef __WCHAR_TYPE__ wxSChar
;
189 typedef __WCHAR_TYPE__ wxUChar
;
190 #endif // __WCHAR_TYPE__
191 #endif // ASCII/Unicode
193 // ----------------------------------------------------------------------------
194 // define _T() and related macros
195 // ----------------------------------------------------------------------------
197 // BSD systems define _T() to be something different in ctype.h, override it
198 #if defined(__FreeBSD__) || defined(__DARWIN__)
203 // could already be defined by tchar.h (it's quasi standard)
209 #endif // ASCII/Unicode
210 #endif // !defined(_T)
212 // although global macros with such names are normally bad, we want to have
213 // another name for _T() which should be used to avoid confusion between _T()
214 // and _() in wxWindows sources
217 // Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs
219 #define __XFILE__(x) wxT(x)
220 #define __TFILE__ __XFILE__(__FILE__)
224 #define __XDATE__(x) wxT(x)
225 #define __TDATE__ __XDATE__(__DATE__)
229 #define __XTIME__(x) wxT(x)
230 #define __TTIME__ __XTIME__(__TIME__)
233 // ----------------------------------------------------------------------------
234 // define wxFoo() function for each standard foo() function whose signature
235 // (exceptionally including the return type) includes any mention of char:
236 // wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
237 // the same signature but with char replaced by wxChar which allows us to use
238 // it in Unicode build as well
239 // ----------------------------------------------------------------------------
241 #ifdef wxHAVE_TCHAR_SUPPORT
243 #define wxIsalnum _istalnum
244 #define wxIsalpha _istalpha
245 #define wxIsctrl _istctrl
246 #define wxIsdigit _istdigit
247 #define wxIsgraph _istgraph
248 #define wxIslower _istlower
249 #define wxIsprint _istprint
250 #define wxIspunct _istpunct
251 #define wxIsspace _istspace
252 #define wxIsupper _istupper
253 #define wxIsxdigit _istxdigit
254 #define wxTolower _totlower
255 #define wxToupper _totupper
258 #define wxSetlocale _tsetlocale
260 // string.h functions
261 #define wxStrcat _tcscat
262 #define wxStrchr _tcschr
263 #define wxStrcmp _tcscmp
264 #define wxStrcoll _tcscoll
265 #define wxStrcpy _tcscpy
266 #define wxStrcspn _tcscspn
267 #define wxStrftime _tcsftime
268 #define wxStricmp _tcsicmp
269 #define wxStrnicmp _tcsnicmp
270 #define wxStrlen_ _tcslen // used in wxStrlen inline function
271 #define wxStrncat _tcsncat
272 #define wxStrncmp _tcsncmp
273 #define wxStrncpy _tcsncpy
274 #define wxStrpbrk _tcspbrk
275 #define wxStrrchr _tcsrchr
276 #define wxStrspn _tcsspn
277 #define wxStrstr _tcsstr
278 #define wxStrtod _tcstod
279 #define wxStrtol _tcstol
280 #define wxStrtoul _tcstoul
281 #define wxStrxfrm _tcsxfrm
284 #define wxFgetc _fgettc
285 #define wxFgetchar _fgettchar
286 #define wxFgets _fgetts
287 #define wxFopen _tfopen
288 #define wxFputc _fputtc
289 #define wxFputchar _fputtchar
290 #define wxFprintf _ftprintf
291 #define wxFputs _fputts
292 #define wxFreopen _tfreopen
293 #define wxFscanf _ftscanf
294 #define wxGetc _gettc
295 #define wxGetchar _gettchar
296 #define wxGets _getts
297 #define wxPerror _tperror
298 #define wxPrintf _tprintf
299 #define wxPutc _puttc
300 #define wxPutchar _puttchar
301 #define wxPuts _putts
302 #define wxScanf _tscanf
303 #define wxSprintf _stprintf
304 #define wxSscanf _stscanf
305 #define wxTmpnam _ttmpnam
306 #define wxUngetc _tungetc
307 #define wxVfprintf _vftprintf
308 #define wxVprintf _vtprintf
309 #define wxVsscanf _vstscanf
310 #define wxVsprintf _vstprintf
312 // special case: not all TCHAR-aware compilers have those
313 #if defined(__VISUALC__) || \
314 (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
315 #define wxVsnprintf_ _vsntprintf
316 #define wxSnprintf_ _sntprintf
319 // special case: these functions are missing under Win9x with Unicows so we
320 // have to implement them ourselves
321 #if wxUSE_UNICODE_MSLU
322 #define wxRemove wxMSLU__tremove
323 #define wxRename wxMSLU__trename
325 #define wxRemove _tremove
326 #define wxRename _trename
329 // stdlib.h functions
332 // #define wxAtof _tttof -- notice that there is no such thing (why?)
333 #define wxGetenv _tgetenv
334 #define wxSystem _tsystem
337 #define wxAsctime _tasctime
338 #define wxCtime _tctime
339 #else // !TCHAR-aware compilers
343 // this is probably glibc-specific
344 #if defined(__WCHAR_TYPE__)
345 // ctype.h functions (wctype.h)
346 #define wxIsalnum iswalnum
347 #define wxIsalpha iswalpha
348 #define wxIsctrl iswcntrl
349 #define wxIsdigit iswdigit
350 #define wxIsgraph iswgraph
351 #define wxIslower iswlower
352 #define wxIsprint iswprint
353 #define wxIspunct iswpunct
354 #define wxIsspace iswspace
355 #define wxIsupper iswupper
356 #define wxIsxdigit iswxdigit
358 #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
359 // /usr/include/wctype.h incorrectly declares translations
360 // tables which provokes tons of compile-time warnings -- try
362 #define wxTolower(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
363 #define wxToupper(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
365 #define wxTolower towlower
366 #define wxToupper towupper
369 // string.h functions (wchar.h)
370 #define wxStrcat wcscat
371 #define wxStrchr wcschr
372 #define wxStrcmp wcscmp
373 #define wxStrcoll wcscoll
374 #define wxStrcpy wcscpy
375 #define wxStrcspn wcscspn
376 #define wxStrlen_ wcslen // used in wxStrlen inline function
377 #define wxStrncat wcsncat
378 #define wxStrncmp wcsncmp
379 #define wxStrncpy wcsncpy
380 #define wxStrpbrk wcspbrk
381 #define wxStrrchr wcsrchr
382 #define wxStrspn wcsspn
383 #define wxStrstr wcsstr
384 #define wxStrtod wcstod
385 #define wxStrtok wcstok
386 #define wxStrtol wcstol
387 #define wxStrtoul wcstoul
388 #define wxStrxfrm wcsxfrm
390 #define wxFgetc fgetwc
391 #define wxFgetchar fgetwchar
392 #define wxFgets fgetws
393 #define wxFputc fputwc
394 #define wxFputchar fputwchar
396 #define wxGetchar getwchar
398 #define wxUngetc ungetwc
402 #define wxPutchar wputchar
404 #define wxFputs fputws
406 #define wxNEED_FPUTWC
410 int wxFputs(const wxChar
*ch
, FILE *stream
);
411 int wxPutc(wxChar ch
, FILE *stream
);
413 #define wxPuts(ws) wxFputs(ws, stdout)
414 #define wxPutchar(wch) wxPutc(wch, stdout)
417 // we need %s to %ls conversion for printf and scanf etc
418 #define wxNEED_PRINTF_CONVERSION
420 // glibc doesn't have wide char equivalents of the other stuff so
421 // use our own versions
422 #define wxNEED_WX_STDIO_H
423 #define wxNEED_WX_STDLIB_H
424 #define wxNEED_WX_TIME_H
426 #error "Please define wide character functions for your environment"
433 #define wxIsalnum isalnum
434 #define wxIsalpha isalpha
435 #define wxIsctrl isctrl
436 #define wxIsdigit isdigit
437 #define wxIsgraph isgraph
438 #define wxIslower islower
439 #define wxIsprint isprint
440 #define wxIspunct ispunct
441 #define wxIsspace isspace
442 #define wxIsupper isupper
443 #define wxIsxdigit isxdigit
444 #define wxTolower tolower
445 #define wxToupper toupper
448 #define wxSetlocale setlocale
450 // string.h functions
451 #define wxStrcat strcat
452 #define wxStrchr strchr
453 #define wxStrcmp strcmp
454 #define wxStrcoll strcoll
455 #define wxStrcpy strcpy
456 #define wxStrcspn strcspn
457 #if !defined(__MWERKS__) || !defined(__WXMAC__)
458 #define wxStrdup strdup
460 // wxStricmp and wxStrnicmp are defined below
461 #define wxStrlen_ strlen // used in wxStrlen inline function
462 #define wxStrncat strncat
463 #define wxStrncmp strncmp
464 #define wxStrncpy strncpy
465 #define wxStrpbrk strpbrk
466 #define wxStrrchr strrchr
467 #define wxStrspn strspn
468 #define wxStrstr strstr
469 #define wxStrtod strtod
471 #define wxStrtok(str, sep, last) strtok_r(str, sep, last)
473 #define wxStrtok(str, sep, last) strtok(str, sep)
475 #define wxStrtol strtol
476 #define wxStrtoul strtoul
477 #define wxStrxfrm strxfrm
480 #define wxFopen fopen
481 #define wxFreopen freopen
482 #define wxPerror perror
483 #define wxRemove remove
484 #define wxRename rename
485 #define wxTmpnam tmpnam
487 #define wxFgetc fgetc
488 #define wxFgetchar fgetchar
489 #define wxFgets fgets
490 #define wxFputc fputc
491 #define wxFputchar fputchar
492 #define wxFprintf fprintf
493 #define wxFscanf fscanf
495 #define wxGetchar getchar
497 #define wxPrintf printf
499 #define wxPutchar putchar
501 #define wxScanf scanf
502 #define wxSprintf sprintf
503 #define wxSscanf sscanf
504 #define wxUngetc ungetc
505 #define wxVfprintf vfprintf
506 #define wxVprintf vprintf
507 #define wxVsscanf vsscanf
508 #define wxVsprintf vsprintf
510 // stdlib.h functions
514 #define wxGetenv getenv
515 #define wxSystem system
518 #define wxAsctime asctime
519 #define wxCtime ctime
520 #define wxStrftime strftime
521 #endif // Unicode/ASCII
522 #endif // TCHAR-aware compilers/the others
524 // ----------------------------------------------------------------------------
525 // various special cases
526 // ----------------------------------------------------------------------------
528 // define wxStricmp and wxStrnicmp for various compilers
530 // note that in Unicode mode we definitely are going to need our own version
531 #if !defined(wxStricmp) && !wxUSE_UNICODE
532 #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
533 defined(__SALFORDC__) || defined(__VISAGECPP__) || \
534 defined(__EMX__) || defined(__DJGPP__)
535 #define wxStricmp stricmp
536 #define wxStrnicmp strnicmp
537 #elif defined(__SC__) || defined(__VISUALC__) || \
538 (defined(__MWERKS__) && defined(__INTEL__))
539 #define wxStricmp _stricmp
540 #define wxStrnicmp _strnicmp
541 #elif defined(__UNIX__) || defined(__GNUWIN32__)
542 #define wxStricmp strcasecmp
543 #define wxStrnicmp strncasecmp
544 // #else -- use wxWindows implementation
546 #endif // !defined(wxStricmp)
548 // checks whether the passed in pointer is NULL and if the string is empty
549 inline bool wxIsEmpty(const wxChar
*p
) { return !p
|| !*p
; }
551 // safe version of strlen() (returns 0 if passed NULL pointer)
552 inline size_t wxStrlen(const wxChar
*psz
) { return psz
? wxStrlen_(psz
) : 0; }
554 // define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
555 // it's used in wx/buffer.h)
558 #define wxWcslen wcslen
560 inline size_t wxWcslen(const wchar_t *s
)
569 #endif // wxUSE_WCHAR_T
571 WXDLLEXPORT
bool wxOKlibc(); // for internal use
573 // ----------------------------------------------------------------------------
574 // printf() family saga
575 // ----------------------------------------------------------------------------
578 First of all, we always want to define safe snprintf() function to be used
579 instead of sprintf(). Some compilers already have it (or rather vsnprintf()
580 which we really need...), otherwise we implement it using our own printf()
583 We define function with a trailing underscore here because the real one is a
584 wrapper around it as explained below
588 #if defined(HAVE_VSWPRINTF)
589 #define wxVsnprintf_ vswprintf
592 // all versions of CodeWarrior supported by wxWindows apparently have
594 #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
595 // assume we have snprintf() too if we have vsnprintf()
596 #define wxVsnprintf_ vsnprintf
597 #define wxSnprintf_ snprintf
600 #endif // wxVsnprintf_ not defined yet
603 // no [v]snprintf(), cook our own
604 WXDLLEXPORT
int wxSnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
,
605 ...) ATTRIBUTE_PRINTF_3
;
606 WXDLLEXPORT
int wxVsnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
,
611 In Unicode mode we need to have all standard functions such as wprintf() and
612 so on but not all systems have them so use our own implementations in this
615 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
616 #define wxNEED_WPRINTF
620 More Unicode complications: although both ANSI C and C++ define a number of
621 wide character functions such as wprintf(), not all environments have them.
622 Worse, those which do have different behaviours: under Windows, %s format
623 specifier changes its meaning in Unicode build and expects a Unicode string
624 while under Unix/POSIX it still means an ASCII string even for wprintf() and
625 %ls has to be used for wide strings.
627 We choose to always emulate Windows behaviour as more useful for us so even
628 if we have wprintf() we still must wrap it in a non trivial wxPrintf().
630 However, if we don't have any vswprintf() at all we don't need to redefine
631 anything as our own wxVsnprintf_() already behaves as needed.
634 #undef wxNEED_PRINTF_CONVERSION
637 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
638 // we need to implement all wide character printf and scanf functions
639 // either because we don't have them at all or because they don't have the
642 #include <stdio.h> // for FILE
644 int wxScanf( const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
645 int wxSscanf( const wxChar
*str
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
646 int wxFscanf( FILE *stream
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
647 int wxVsscanf( const wxChar
*str
, const wxChar
*format
, va_list ap
);
648 int wxPrintf( const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
649 int wxSprintf( wxChar
*str
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
650 int wxFprintf( FILE *stream
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
651 int wxVfprintf( FILE *stream
, const wxChar
*format
, va_list ap
);
652 int wxVprintf( const wxChar
*format
, va_list ap
);
653 int wxVsprintf( wxChar
*str
, const wxChar
*format
, va_list ap
);
654 #endif // wxNEED_PRINTF_CONVERSION
656 // these 2 can be simply mapped to the versions with underscore at the end
657 // if we don't have to do the conversion
658 #ifdef wxNEED_PRINTF_CONVERSION
659 int wxSnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_4
;
660 int wxVsnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, va_list ap
);
662 #define wxSnprintf wxSnprintf_
663 #define wxVsnprintf wxVsnprintf_
666 // ----------------------------------------------------------------------------
667 // various functions which might not be available in libc and for which we
668 // provide our own replacements in wxchar.cpp
669 // ----------------------------------------------------------------------------
673 // VZ: note that this is never defined currently
674 #ifdef wxNEED_WX_CTYPE_H
675 WXDLLEXPORT
int wxIsalnum(wxChar ch
);
676 WXDLLEXPORT
int wxIsalpha(wxChar ch
);
677 WXDLLEXPORT
int wxIsctrl(wxChar ch
);
678 WXDLLEXPORT
int wxIsdigit(wxChar ch
);
679 WXDLLEXPORT
int wxIsgraph(wxChar ch
);
680 WXDLLEXPORT
int wxIslower(wxChar ch
);
681 WXDLLEXPORT
int wxIsprint(wxChar ch
);
682 WXDLLEXPORT
int wxIspunct(wxChar ch
);
683 WXDLLEXPORT
int wxIsspace(wxChar ch
);
684 WXDLLEXPORT
int wxIsupper(wxChar ch
);
685 WXDLLEXPORT
int wxIsxdigit(wxChar ch
);
686 WXDLLEXPORT
int wxTolower(wxChar ch
);
687 WXDLLEXPORT
int wxToupper(wxChar ch
);
688 #endif // wxNEED_WX_CTYPE_H
690 // under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
691 // the file parsing -- this may be true for 5.0 as well, update #ifdef then
692 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
694 #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
698 // string.h functions
700 // VZ: this is never defined neither currently
701 #ifdef wxNEED_WX_STRING_H
702 WXDLLEXPORT wxChar
* wxStrcat(wxChar
*dest
, const wxChar
*src
);
703 WXDLLEXPORT
const wxChar
* wxStrchr(const wxChar
*s
, wxChar c
);
704 WXDLLEXPORT wxChar
* wxStrchr(wxChar
*s
, wxChar c
)
705 { return (wxChar
*)wxStrchr((const wxChar
*)s
, c
); }
706 WXDLLEXPORT
int wxStrcmp(const wxChar
*s1
, const wxChar
*s2
);
707 WXDLLEXPORT
int wxStrcoll(const wxChar
*s1
, const wxChar
*s2
);
708 WXDLLEXPORT wxChar
* wxStrcpy(wxChar
*dest
, const wxChar
*src
);
709 WXDLLEXPORT
size_t wxStrcspn(const wxChar
*s
, const wxChar
*reject
);
710 WXDLLEXPORT
size_t wxStrlen(const wxChar
*s
);
711 WXDLLEXPORT wxChar
* wxStrncat(wxChar
*dest
, const wxChar
*src
, size_t n
);
712 WXDLLEXPORT
int wxStrncmp(const wxChar
*s1
, const wxChar
*s2
, size_t n
);
713 WXDLLEXPORT wxChar
* wxStrncpy(wxChar
*dest
, const wxChar
*src
, size_t n
);
714 WXDLLEXPORT
const wxChar
* wxStrpbrk(const wxChar
*s
, const wxChar
*accept
);
715 WXDLLEXPORT wxChar
* wxStrpbrk(wxChar
*s
, const wxChar
*accept
)
716 { return (wxChar
*)wxStrpbrk((const wxChar
*)s
, accept
); }
717 WXDLLEXPORT
const wxChar
* wxStrrchr(const wxChar
*s
, wxChar c
);
718 WXDLLEXPORT wxChar
* wxStrrchr(wxChar
*s
, wxChar c
)
719 { return (wxChar
*)wxStrrchr((const wxChar
*)s
, c
); }
720 WXDLLEXPORT
size_t wxStrspn(const wxChar
*s
, const wxChar
*accept
);
721 WXDLLEXPORT
const wxChar
* wxStrstr(const wxChar
*haystack
, const wxChar
*needle
);
722 WXDLLEXPORT wxChar
*wxStrstr(wxChar
*haystack
, const wxChar
*needle
)
723 { return (wxChar
*)wxStrstr((const wxChar
*)haystack
, needle
); }
724 WXDLLEXPORT
double wxStrtod(const wxChar
*nptr
, wxChar
**endptr
);
725 WXDLLEXPORT
long int wxStrtol(const wxChar
*nptr
, wxChar
**endptr
, int base
);
726 WXDLLEXPORT
unsigned long int wxStrtoul(const wxChar
*nptr
, wxChar
**endptr
, int base
);
727 WXDLLEXPORT
size_t wxStrxfrm(wxChar
*dest
, const wxChar
*src
, size_t n
);
728 #endif // wxNEED_WX_STRING_H
731 WXDLLEXPORT wxChar
* wxStrdup(const wxChar
*psz
);
735 WXDLLEXPORT
int wxStricmp(const wxChar
*psz1
, const wxChar
*psz2
);
739 WXDLLEXPORT
int wxStrnicmp(const wxChar
*psz1
, const wxChar
*psz2
, size_t len
);
743 WXDLLEXPORT wxChar
* wxStrtok(wxChar
*psz
, const wxChar
*delim
, wxChar
**save_ptr
);
747 class WXDLLEXPORT wxWCharBuffer
;
748 WXDLLEXPORT wxWCharBuffer
wxSetlocale(int category
, const wxChar
*locale
);
752 #ifdef wxNEED_WX_STDIO_H
754 WXDLLEXPORT
FILE * wxFopen(const wxChar
*path
, const wxChar
*mode
);
755 WXDLLEXPORT
FILE * wxFreopen(const wxChar
*path
, const wxChar
*mode
, FILE *stream
);
756 WXDLLEXPORT
int wxRemove(const wxChar
*path
);
757 WXDLLEXPORT
int wxRename(const wxChar
*oldpath
, const wxChar
*newpath
);
759 // *printf() family is handled separately
760 #endif // wxNEED_WX_STDIO_H
763 // stdlib.h functions
765 WXDLLEXPORT
double wxAtof(const wxChar
*psz
);
768 #ifdef wxNEED_WX_STDLIB_H
769 WXDLLEXPORT
int wxAtoi(const wxChar
*psz
);
770 WXDLLEXPORT
long wxAtol(const wxChar
*psz
);
771 WXDLLEXPORT wxChar
* wxGetenv(const wxChar
*name
);
772 WXDLLEXPORT
int wxSystem(const wxChar
*psz
);
777 #ifdef wxNEED_WX_TIME_H
778 WXDLLEXPORT
size_t wxStrftime(wxChar
*s
, size_t max
,
779 const wxChar
*fmt
, const struct tm
*tm
);
780 #endif // wxNEED_WX_TIME_H
782 // ----------------------------------------------------------------------------
783 // multibyte to wide char conversion functions and macros
784 // ----------------------------------------------------------------------------
787 // multibyte<->widechar conversion
788 WXDLLEXPORT
size_t wxMB2WC(wchar_t *buf
, const char *psz
, size_t n
);
789 WXDLLEXPORT
size_t wxWC2MB(char *buf
, const wchar_t *psz
, size_t n
);
792 #define wxMB2WX wxMB2WC
793 #define wxWX2MB wxWC2MB
794 #define wxWC2WX wxStrncpy
795 #define wxWX2WC wxStrncpy
797 #define wxMB2WX wxStrncpy
798 #define wxWX2MB wxStrncpy
799 #define wxWC2WX wxWC2MB
800 #define wxWX2WC wxMB2WC
802 #else // !wxUSE_UNICODE
803 // No wxUSE_WCHAR_T: we have to do something (JACS)
804 #define wxMB2WC wxStrncpy
805 #define wxWC2MB wxStrncpy
806 #define wxMB2WX wxStrncpy
807 #define wxWX2MB wxStrncpy
808 #define wxWC2WX wxWC2MB
809 #define wxWX2WC wxMB2WC
812 #endif //_WX_WXCHAR_H_
projects / wxWidgets.git / blob