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 /////////////////////////////////////////////////////////////////////////////
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, override it
198 #if defined(__FreeBSD__) || defined(__DARWIN__)
202 // could already be defined by tchar.h (it's quasi standard)
208 #endif // ASCII/Unicode
209 #endif // !defined(_T)
211 // although global macros with such names are normally bad, we want to have
212 // another name for _T() which should be used to avoid confusion between _T()
213 // and _() in wxWindows sources
216 // Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs
218 #define __XFILE__(x) wxT(x)
219 #define __TFILE__ __XFILE__(__FILE__)
223 #define __XDATE__(x) wxT(x)
224 #define __TDATE__ __XDATE__(__DATE__)
228 #define __XTIME__(x) wxT(x)
229 #define __TTIME__ __XTIME__(__TIME__)
232 // ----------------------------------------------------------------------------
233 // define wxFoo() function for each standard foo() function whose signature
234 // (exceptionally including the return type) includes any mention of char:
235 // wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
236 // the same signature but with char replaced by wxChar which allows us to use
237 // it in Unicode build as well
238 // ----------------------------------------------------------------------------
240 #ifdef wxHAVE_TCHAR_SUPPORT
242 #define wxIsalnum _istalnum
243 #define wxIsalpha _istalpha
244 #define wxIsctrl _istctrl
245 #define wxIsdigit _istdigit
246 #define wxIsgraph _istgraph
247 #define wxIslower _istlower
248 #define wxIsprint _istprint
249 #define wxIspunct _istpunct
250 #define wxIsspace _istspace
251 #define wxIsupper _istupper
252 #define wxIsxdigit _istxdigit
253 #define wxTolower _totlower
254 #define wxToupper _totupper
257 #define wxSetlocale _tsetlocale
259 // string.h functions
260 #define wxStrcat _tcscat
261 #define wxStrchr _tcschr
262 #define wxStrcmp _tcscmp
263 #define wxStrcoll _tcscoll
264 #define wxStrcpy _tcscpy
265 #define wxStrcspn _tcscspn
266 #define wxStrftime _tcsftime
267 #define wxStricmp _tcsicmp
268 #define wxStrnicmp _tcsnicmp
269 #define wxStrlen_ _tcslen // used in wxStrlen inline function
270 #define wxStrncat _tcsncat
271 #define wxStrncmp _tcsncmp
272 #define wxStrncpy _tcsncpy
273 #define wxStrpbrk _tcspbrk
274 #define wxStrrchr _tcsrchr
275 #define wxStrspn _tcsspn
276 #define wxStrstr _tcsstr
277 #define wxStrtod _tcstod
278 #define wxStrtol _tcstol
279 #define wxStrtoul _tcstoul
280 #define wxStrxfrm _tcsxfrm
283 #define wxFgetc _fgettc
284 #define wxFgetchar _fgettchar
285 #define wxFgets _fgetts
286 #define wxFopen _tfopen
287 #define wxFputc _fputtc
288 #define wxFputchar _fputtchar
289 #define wxFprintf _ftprintf
290 #define wxFputs _fputts
291 #define wxFreopen _tfreopen
292 #define wxFscanf _ftscanf
293 #define wxGetc _gettc
294 #define wxGetchar _gettchar
295 #define wxGets _getts
296 #define wxPerror _tperror
297 #define wxPrintf _tprintf
298 #define wxPutc _puttc
299 #define wxPutchar _puttchar
300 #define wxPuts _putts
301 #define wxScanf _tscanf
302 #define wxSprintf _stprintf
303 #define wxSscanf _stscanf
304 #define wxTmpnam _ttmpnam
305 #define wxUngetc _tungetc
306 #define wxVfprintf _vftprintf
307 #define wxVprintf _vtprintf
308 #define wxVsscanf _vstscanf
309 #define wxVsprintf _vstprintf
311 // special case: these functions are missing under Win9x with Unicows so we
312 // have to implement them ourselves
313 #if wxUSE_UNICODE_MSLU
314 #define wxRemove wxMSLU__tremove
315 #define wxRename wxMSLU__trename
317 #define wxRemove _tremove
318 #define wxRename _trename
321 // stdlib.h functions
324 // #define wxAtof _tttof -- notice that there is no such thing (why?)
325 #define wxGetenv _tgetenv
326 #define wxSystem _tsystem
329 #define wxAsctime _tasctime
330 #define wxCtime _tctime
331 #else // !TCHAR-aware compilers
335 // this is probably glibc-specific
336 #if defined(__WCHAR_TYPE__)
337 // ctype.h functions (wctype.h)
338 #define wxIsalnum iswalnum
339 #define wxIsalpha iswalpha
340 #define wxIsctrl iswcntrl
341 #define wxIsdigit iswdigit
342 #define wxIsgraph iswgraph
343 #define wxIslower iswlower
344 #define wxIsprint iswprint
345 #define wxIspunct iswpunct
346 #define wxIsspace iswspace
347 #define wxIsupper iswupper
348 #define wxIsxdigit iswxdigit
350 #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
351 // /usr/include/wctype.h incorrectly declares translations
352 // tables which provokes tons of compile-time warnings -- try
354 #define wxTolower(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
355 #define wxToupper(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
357 #define wxTolower towlower
358 #define wxToupper towupper
361 // string.h functions (wchar.h)
362 #define wxStrcat wcscat
363 #define wxStrchr wcschr
364 #define wxStrcmp wcscmp
365 #define wxStrcoll wcscoll
366 #define wxStrcpy wcscpy
367 #define wxStrcspn wcscspn
368 #define wxStrlen_ wcslen // used in wxStrlen inline function
369 #define wxStrncat wcsncat
370 #define wxStrncmp wcsncmp
371 #define wxStrncpy wcsncpy
372 #define wxStrpbrk wcspbrk
373 #define wxStrrchr wcsrchr
374 #define wxStrspn wcsspn
375 #define wxStrstr wcsstr
376 #define wxStrtod wcstod
377 #define wxStrtok wcstok
378 #define wxStrtol wcstol
379 #define wxStrtoul wcstoul
380 #define wxStrxfrm wcsxfrm
382 #define wxFgetc fgetwc
383 #define wxFgetchar fgetwchar
384 #define wxFgets fgetws
385 #define wxFputc fputwc
386 #define wxFputchar fputwchar
388 #define wxGetchar getwchar
390 #define wxUngetc ungetwc
394 #define wxPutchar wputchar
396 #define wxFputs fputws
400 int wxFputs(const wxChar
*ch
, FILE *stream
);
401 int wxPutc(wxChar ch
, FILE *stream
);
403 #define wxPuts(ws) wxFputs(ws, stdout)
404 #define wxPutchar(wch) wxPutc(wch, stdout)
407 // we need %s to %ls conversion for printf and scanf etc
408 #define wxNEED_PRINTF_CONVERSION
410 // glibc doesn't have wide char equivalents of the other stuff so
411 // use our own versions
412 #define wxNEED_WX_STDIO_H
413 #define wxNEED_WX_STDLIB_H
414 #define wxNEED_WX_TIME_H
416 #error "Please define wide character functions for your environment"
423 #define wxIsalnum isalnum
424 #define wxIsalpha isalpha
425 #define wxIsctrl isctrl
426 #define wxIsdigit isdigit
427 #define wxIsgraph isgraph
428 #define wxIslower islower
429 #define wxIsprint isprint
430 #define wxIspunct ispunct
431 #define wxIsspace isspace
432 #define wxIsupper isupper
433 #define wxIsxdigit isxdigit
434 #define wxTolower tolower
435 #define wxToupper toupper
438 #define wxSetlocale setlocale
440 // string.h functions
441 #define wxStrcat strcat
442 #define wxStrchr strchr
443 #define wxStrcmp strcmp
444 #define wxStrcoll strcoll
445 #define wxStrcpy strcpy
446 #define wxStrcspn strcspn
447 #if !defined(__MWERKS__) || !defined(__WXMAC__)
448 #define wxStrdup strdup
450 // wxStricmp and wxStrnicmp are defined below
451 #define wxStrlen_ strlen // used in wxStrlen inline function
452 #define wxStrncat strncat
453 #define wxStrncmp strncmp
454 #define wxStrncpy strncpy
455 #define wxStrpbrk strpbrk
456 #define wxStrrchr strrchr
457 #define wxStrspn strspn
458 #define wxStrstr strstr
459 #define wxStrtod strtod
461 #define wxStrtok(str, sep, last) strtok_r(str, sep, last)
463 #define wxStrtok(str, sep, last) strtok(str, sep)
465 #define wxStrtol strtol
466 #define wxStrtoul strtoul
467 #define wxStrxfrm strxfrm
470 #define wxFopen fopen
471 #define wxFreopen freopen
472 #define wxPerror perror
473 #define wxRemove remove
474 #define wxRename rename
475 #define wxTmpnam tmpnam
477 #define wxFgetc fgetc
478 #define wxFgetchar fgetchar
479 #define wxFgets fgets
480 #define wxFputc fputc
481 #define wxFputchar fputchar
482 #define wxFprintf fprintf
483 #define wxFscanf fscanf
485 #define wxGetchar getchar
487 #define wxPrintf printf
489 #define wxPutchar putchar
491 #define wxScanf scanf
492 #define wxSprintf sprintf
493 #define wxSscanf sscanf
494 #define wxUngetc ungetc
495 #define wxVfprintf vfprintf
496 #define wxVprintf vprintf
497 #define wxVsscanf vsscanf
498 #define wxVsprintf vsprintf
500 // stdlib.h functions
504 #define wxGetenv getenv
505 #define wxSystem system
508 #define wxAsctime asctime
509 #define wxCtime ctime
510 #define wxStrftime strftime
511 #endif // Unicode/ASCII
512 #endif // TCHAR-aware compilers/the others
514 // ----------------------------------------------------------------------------
515 // various special cases
516 // ----------------------------------------------------------------------------
518 // define wxStricmp and wxStrnicmp for various compilers
520 // note that in Unicode mode we definitely are going to need our own version
521 #if !defined(wxStricmp) && !wxUSE_UNICODE
522 #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
523 defined(__SALFORDC__) || defined(__VISAGECPP__) || \
524 defined(__EMX__) || defined(__DJGPP__)
525 #define wxStricmp stricmp
526 #define wxStrnicmp strnicmp
527 #elif defined(__SC__) || defined(__VISUALC__) || \
528 (defined(__MWERKS__) && defined(__INTEL__))
529 #define wxStricmp _stricmp
530 #define wxStrnicmp _strnicmp
531 #elif defined(__UNIX__) || defined(__GNUWIN32__)
532 #define wxStricmp strcasecmp
533 #define wxStrnicmp strncasecmp
534 // #else -- use wxWindows implementation
536 #endif // !defined(wxStricmp)
538 // checks whether the passed in pointer is NULL and if the string is empty
539 inline bool wxIsEmpty(const wxChar
*p
) { return !p
|| !*p
; }
541 // safe version of strlen() (returns 0 if passed NULL pointer)
542 inline size_t wxStrlen(const wxChar
*psz
) { return psz
? wxStrlen_(psz
) : 0; }
544 // define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
545 // it's used in wx/buffer.h)
548 #define wxWcslen wcslen
550 inline size_t wxWcslen(const wchar_t *s
)
559 #endif // wxUSE_WCHAR_T
561 WXDLLEXPORT
bool wxOKlibc(); // for internal use
563 // ----------------------------------------------------------------------------
564 // printf() family saga
565 // ----------------------------------------------------------------------------
568 First of all, we always want to define safe snprintf() function to be used
569 instead of sprintf(). Some compilers already have it (or rather vsnprintf()
570 which we really need...), otherwise we implement it using our own printf()
573 We define function with a trailing underscore here because the real one is a
574 wrapper around it as explained below
576 #ifdef wxHAVE_TCHAR_SUPPORT
577 #define wxVsnprintf_ _vsntprintf
578 #define wxSnprintf_ _sntprintf
581 #if defined(HAVE_VSWPRINTF)
582 #define wxVsnprintf_ vswprintf
585 #if (defined(HAVE_VSNPRINTF) || defined(__WXMAC__))
586 // assume we have snprintf() too if we have vsnprintf()
587 #define wxVsnprintf_ vsnprintf
588 #define wxSnprintf_ snprintf
591 #endif // TCHAR/!TCHAR
594 // no [v]snprintf(), cook our own
595 WXDLLEXPORT
int wxSnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
,
596 ...) ATTRIBUTE_PRINTF_3
;
597 WXDLLEXPORT
int wxVsnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
,
602 In Unicode mode we need to have all standard functions such as wprintf() and
603 so on but not all systems have them so use our own implementations in this
606 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
607 #define wxNEED_WPRINTF
611 More Unicode complications: although both ANSI C and C++ define a number of
612 wide character functions such as wprintf(), not all environments have them.
613 Worse, those which do have different behaviours: under Windows, %s format
614 specifier changes its meaning in Unicode build and expects a Unicode string
615 while under Unix/POSIX it still means an ASCII string even for wprintf() and
616 %ls has to be used for wide strings.
618 We choose to always emulate Windows behaviour as more useful for us so even
619 if we have wprintf() we still must wrap it in a non trivial wxPrintf().
621 However, if we don't have any vswprintf() at all we don't need to redefine
622 anything as our own wxVsnprintf_() already behaves as needed.
625 #undef wxNEED_PRINTF_CONVERSION
628 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
629 // we need to implement all wide character printf and scanf functions
630 // either because we don't have them at all or because they don't have the
633 #include <stdio.h> // for FILE
635 int wxScanf( const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
636 int wxSscanf( const wxChar
*str
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
637 int wxFscanf( FILE *stream
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
638 int wxVsscanf( const wxChar
*str
, const wxChar
*format
, va_list ap
);
639 int wxPrintf( const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_2
;
640 int wxSprintf( wxChar
*str
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
641 int wxFprintf( FILE *stream
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_3
;
642 int wxVfprintf( FILE *stream
, const wxChar
*format
, va_list ap
);
643 int wxVprintf( const wxChar
*format
, va_list ap
);
644 int wxVsprintf( wxChar
*str
, const wxChar
*format
, va_list ap
);
646 // these 2 can be simply mapped to the versions with underscore at the end
647 // if we don't have to do the conversion
648 #ifdef wxNEED_PRINTF_CONVERSION
649 int wxSnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, ... ) ATTRIBUTE_PRINTF_4
;
650 int wxVsnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, va_list ap
);
652 #define wxSnprintf wxSnprintf_
653 #define wxVsnprintf wxVsnprintf_
655 #endif // wxNEED_PRINTF_CONVERSION
657 // ----------------------------------------------------------------------------
658 // various functions which might not be available in libc and for which we
659 // provide our own replacements in wxchar.cpp
660 // ----------------------------------------------------------------------------
664 // VZ: note that this is never defined currently
665 #ifdef wxNEED_WX_CTYPE_H
666 WXDLLEXPORT
int wxIsalnum(wxChar ch
);
667 WXDLLEXPORT
int wxIsalpha(wxChar ch
);
668 WXDLLEXPORT
int wxIsctrl(wxChar ch
);
669 WXDLLEXPORT
int wxIsdigit(wxChar ch
);
670 WXDLLEXPORT
int wxIsgraph(wxChar ch
);
671 WXDLLEXPORT
int wxIslower(wxChar ch
);
672 WXDLLEXPORT
int wxIsprint(wxChar ch
);
673 WXDLLEXPORT
int wxIspunct(wxChar ch
);
674 WXDLLEXPORT
int wxIsspace(wxChar ch
);
675 WXDLLEXPORT
int wxIsupper(wxChar ch
);
676 WXDLLEXPORT
int wxIsxdigit(wxChar ch
);
677 WXDLLEXPORT
int wxTolower(wxChar ch
);
678 WXDLLEXPORT
int wxToupper(wxChar ch
);
679 #endif // wxNEED_WX_CTYPE_H
681 // under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
682 // the file parsing -- this may be true for 5.0 as well, update #ifdef then
683 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
685 #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
689 // string.h functions
691 // VZ: this is never defined neither currently
692 #ifdef wxNEED_WX_STRING_H
693 WXDLLEXPORT wxChar
* wxStrcat(wxChar
*dest
, const wxChar
*src
);
694 WXDLLEXPORT
const wxChar
* wxStrchr(const wxChar
*s
, wxChar c
);
695 WXDLLEXPORT wxChar
* wxStrchr(wxChar
*s
, wxChar c
)
696 { return (wxChar
*)wxStrchr((const wxChar
*)s
, c
); }
697 WXDLLEXPORT
int wxStrcmp(const wxChar
*s1
, const wxChar
*s2
);
698 WXDLLEXPORT
int wxStrcoll(const wxChar
*s1
, const wxChar
*s2
);
699 WXDLLEXPORT wxChar
* wxStrcpy(wxChar
*dest
, const wxChar
*src
);
700 WXDLLEXPORT
size_t wxStrcspn(const wxChar
*s
, const wxChar
*reject
);
701 WXDLLEXPORT
size_t wxStrlen(const wxChar
*s
);
702 WXDLLEXPORT wxChar
* wxStrncat(wxChar
*dest
, const wxChar
*src
, size_t n
);
703 WXDLLEXPORT
int wxStrncmp(const wxChar
*s1
, const wxChar
*s2
, size_t n
);
704 WXDLLEXPORT wxChar
* wxStrncpy(wxChar
*dest
, const wxChar
*src
, size_t n
);
705 WXDLLEXPORT
const wxChar
* wxStrpbrk(const wxChar
*s
, const wxChar
*accept
);
706 WXDLLEXPORT wxChar
* wxStrpbrk(wxChar
*s
, const wxChar
*accept
)
707 { return (wxChar
*)wxStrpbrk((const wxChar
*)s
, accept
); }
708 WXDLLEXPORT
const wxChar
* wxStrrchr(const wxChar
*s
, wxChar c
);
709 WXDLLEXPORT wxChar
* wxStrrchr(wxChar
*s
, wxChar c
)
710 { return (wxChar
*)wxStrrchr((const wxChar
*)s
, c
); }
711 WXDLLEXPORT
size_t wxStrspn(const wxChar
*s
, const wxChar
*accept
);
712 WXDLLEXPORT
const wxChar
* wxStrstr(const wxChar
*haystack
, const wxChar
*needle
);
713 WXDLLEXPORT wxChar
*wxStrstr(wxChar
*haystack
, const wxChar
*needle
)
714 { return (wxChar
*)wxStrstr((const wxChar
*)haystack
, needle
); }
715 WXDLLEXPORT
double wxStrtod(const wxChar
*nptr
, wxChar
**endptr
);
716 WXDLLEXPORT
long int wxStrtol(const wxChar
*nptr
, wxChar
**endptr
, int base
);
717 WXDLLEXPORT
unsigned long int wxStrtoul(const wxChar
*nptr
, wxChar
**endptr
, int base
);
718 WXDLLEXPORT
size_t wxStrxfrm(wxChar
*dest
, const wxChar
*src
, size_t n
);
719 #endif // wxNEED_WX_STRING_H
722 WXDLLEXPORT wxChar
* wxStrdup(const wxChar
*psz
);
726 WXDLLEXPORT
int wxStricmp(const wxChar
*psz1
, const wxChar
*psz2
);
730 WXDLLEXPORT
int wxStrnicmp(const wxChar
*psz1
, const wxChar
*psz2
, size_t len
);
734 WXDLLEXPORT wxChar
* wxStrtok(wxChar
*psz
, const wxChar
*delim
, wxChar
**save_ptr
);
738 class WXDLLEXPORT wxWCharBuffer
;
739 WXDLLEXPORT wxWCharBuffer
wxSetlocale(int category
, const wxChar
*locale
);
743 #ifdef wxNEED_WX_STDIO_H
745 WXDLLEXPORT
FILE * wxFopen(const wxChar
*path
, const wxChar
*mode
);
746 WXDLLEXPORT
FILE * wxFreopen(const wxChar
*path
, const wxChar
*mode
, FILE *stream
);
747 WXDLLEXPORT
int wxRemove(const wxChar
*path
);
748 WXDLLEXPORT
int wxRename(const wxChar
*oldpath
, const wxChar
*newpath
);
750 // *printf() family is handled separately
751 #endif // wxNEED_WX_STDIO_H
754 // stdlib.h functions
756 WXDLLEXPORT
double wxAtof(const wxChar
*psz
);
759 #ifdef wxNEED_WX_STDLIB_H
760 WXDLLEXPORT
int wxAtoi(const wxChar
*psz
);
761 WXDLLEXPORT
long wxAtol(const wxChar
*psz
);
762 WXDLLEXPORT wxChar
* wxGetenv(const wxChar
*name
);
763 WXDLLEXPORT
int wxSystem(const wxChar
*psz
);
768 #ifdef wxNEED_WX_TIME_H
769 WXDLLEXPORT
size_t wxStrftime(wxChar
*s
, size_t max
,
770 const wxChar
*fmt
, const struct tm
*tm
);
771 #endif // wxNEED_WX_TIME_H
773 // ----------------------------------------------------------------------------
774 // multibyte to wide char conversion functions and macros
775 // ----------------------------------------------------------------------------
778 // multibyte<->widechar conversion
779 WXDLLEXPORT
size_t wxMB2WC(wchar_t *buf
, const char *psz
, size_t n
);
780 WXDLLEXPORT
size_t wxWC2MB(char *buf
, const wchar_t *psz
, size_t n
);
783 #define wxMB2WX wxMB2WC
784 #define wxWX2MB wxWC2MB
785 #define wxWC2WX wxStrncpy
786 #define wxWX2WC wxStrncpy
788 #define wxMB2WX wxStrncpy
789 #define wxWX2MB wxStrncpy
790 #define wxWC2WX wxWC2MB
791 #define wxWX2WC wxMB2WC
793 #else // !wxUSE_UNICODE
794 // No wxUSE_WCHAR_T: we have to do something (JACS)
795 #define wxMB2WC wxStrncpy
796 #define wxWC2MB wxStrncpy
797 #define wxMB2WX wxStrncpy
798 #define wxWX2MB wxStrncpy
799 #define wxWC2WX wxWC2MB
800 #define wxWX2WC wxMB2WC
803 #endif //_WX_WXCHAR_H_
projects / wxWidgets.git / blob