]> git.saurik.com Git - wxWidgets.git/blob - include/wx/wxchar.h
projects / wxWidgets.git / blob
? search:


c2c2605bf22d86dd224a5fc1b5a8c95488e7d81a
[wxWidgets.git] / include / wx / wxchar.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/wxchar.h
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
6 // Created: 1998/06/12
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998-2002 wxWindows dev team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_WXCHAR_H_
13 #define _WX_WXCHAR_H_
14
15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
16 #pragma interface "wxchar.h"
17 #endif
18
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 // ----------------------------------------------------------------------------
24
25 // set wxUSE_UNICODE to 1 if UNICODE or _UNICODE is defined
26 #if defined(_UNICODE) || defined(UNICODE)
27 #undef wxUSE_UNICODE
28 #define wxUSE_UNICODE 1
29 #else
30 #ifndef wxUSE_UNICODE
31 #define wxUSE_UNICODE 0
32 #endif
33 #endif // Unicode
34
35 // and vice versa: define UNICODE and _UNICODE if wxUSE_UNICODE is 1...
36 #if wxUSE_UNICODE
37 #ifndef _UNICODE
38 #define _UNICODE
39 #endif
40 #ifndef UNICODE
41 #define UNICODE
42 #endif
43 #endif // Unicode
44
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
53 #else
54 #define wxUSE_WCHAR_T 0
55 #endif
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
62 #else
63 // add additional compiler checks if this fails
64 #define wxUSE_WCHAR_T 1
65 #endif
66 #endif // !defined(wxUSE_WCHAR_T)
67
68 // Unicode support requires wchar_t
69 #if wxUSE_UNICODE && !wxUSE_WCHAR_T
70 #error "wchar_t must be available in Unicode build"
71 #endif // Unicode
72
73 // ----------------------------------------------------------------------------
74 // standard headers we need here
75 //
76 // NB: don't include any wxWindows headers here because almost of them include
77 // this one!
78 // ----------------------------------------------------------------------------
79
80 // Required for wxPrintf() etc
81 #include <stdarg.h>
82
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
88 #endif
89
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__)
94 #ifndef HAVE_WCHAR_H
95 #define HAVE_WCHAR_H
96 #endif
97 #endif
98
99 #if wxUSE_WCHAR_T
100 #ifdef HAVE_WCHAR_H
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
105 #ifdef __CYGWIN__
106 #include <sys/types.h>
107 extern "C" {
108 #endif // Cygwin
109 #include <wchar.h>
110 #ifdef __CYGWIN__
111 }
112 #endif // Cygwin
113 #elif defined(HAVE_WCSTR_H)
114 // old compilers have relevant declarations here
115 #include <wcstr.h>
116 #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
117 // include stdlib.h for wchar_t
118 #include <stdlib.h>
119 #endif // HAVE_WCHAR_H
120 #endif // wxUSE_WCHAR_T
121
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 // ----------------------------------------------------------------------------
127
128 // VC++ and BC++ starting with 5.2 have TCHAR support
129 #ifdef __VISUALC__
130 #define wxHAVE_TCHAR_SUPPORT
131 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
132 #define wxHAVE_TCHAR_SUPPORT
133 #include <ctype.h>
134 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
135 #define wxHAVE_TCHAR_SUPPORT
136 #include <stddef.h>
137 #include <string.h>
138 #include <ctype.h>
139 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
140 // VZ: the old VisualAge definitions were completely wrong and had no
141 // chance at all to work in Unicode build anyhow so let's pretend that
142 // VisualAge does _not_ support TCHAR for the moment (as indicated by
143 // "0 &&" above) until someone really has time to delve into Unicode
144 // issues under OS/2
145
146 // VisualAge 4.0+ supports TCHAR
147 #define wxHAVE_TCHAR_SUPPORT
148 #endif // compilers with (good) TCHAR support
149
150 #ifdef __MWERKS__
151 #define HAVE_WPRINTF
152 #endif
153
154 #ifdef wxHAVE_TCHAR_SUPPORT
155 // get TCHAR definition if we've got it
156 #include <tchar.h>
157
158 // we surely do have wchar_t if we have TCHAR
159 #ifndef wxUSE_WCHAR_T
160 #define wxUSE_WCHAR_T 1
161 #endif // !defined(wxUSE_WCHAR_T)
162
163 // and we also do have wcslen()
164 #ifndef HAVE_WCSLEN
165 #define HAVE_WCSLEN
166 #endif
167 #endif // wxHAVE_TCHAR_SUPPORT
168
169 // ----------------------------------------------------------------------------
170 // define wxChar type
171 // ----------------------------------------------------------------------------
172
173 // TODO: define wxCharInt to be equal to either int or wint_t?
174
175 #if !wxUSE_UNICODE
176 typedef char wxChar;
177 typedef signed char wxSChar;
178 typedef unsigned char wxUChar;
179 #else // Unicode
180 // VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as
181 // signed/unsigned version of it which (a) makes sense to me (unlike
182 // char wchar_t is always unsigned) and (b) was how the previous
183 // definitions worked so keep it like this
184
185 // GNU libc has __WCHAR_TYPE__ which requires special treatment, see
186 // comment below
187 #if !defined(__WCHAR_TYPE__) || \
188 (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
189 // standard case
190 typedef wchar_t wxChar;
191 typedef wchar_t wxSChar;
192 typedef wchar_t wxUChar;
193 #else // __WCHAR_TYPE__ and gcc < 2.96
194 // VS: wxWindows used to define wxChar as __WCHAR_TYPE__ here. However,
195 // this doesn't work with new GCC 3.x compilers because wchar_t is
196 // C++'s builtin type in the new standard. OTOH, old compilers (GCC
197 // 2.x) won't accept new definition of wx{S,U}Char, therefore we
198 // have to define wxChar conditionally depending on detected
199 // compiler & compiler version.
200 // with old definition of wxChar.
201 typedef __WCHAR_TYPE__ wxChar;
202 typedef __WCHAR_TYPE__ wxSChar;
203 typedef __WCHAR_TYPE__ wxUChar;
204 #endif // __WCHAR_TYPE__
205 #endif // ASCII/Unicode
206
207 // ----------------------------------------------------------------------------
208 // define _T() and related macros
209 // ----------------------------------------------------------------------------
210
211 // BSD systems define _T() to be something different in ctype.h, override it
212 #if defined(__FreeBSD__) || defined(__DARWIN__)
213 #include <ctype.h>
214 #undef _T
215 #endif
216
217 // could already be defined by tchar.h (it's quasi standard)
218 #ifndef _T
219 #if !wxUSE_UNICODE
220 #define _T(x) x
221 #else // Unicode
222 #define _T(x) L ## x
223 #endif // ASCII/Unicode
224 #endif // !defined(_T)
225
226 // although global macros with such names are normally bad, we want to have
227 // another name for _T() which should be used to avoid confusion between _T()
228 // and _() in wxWindows sources
229 #define wxT(x) _T(x)
230
231 // Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs
232 #ifndef __TFILE__
233 #define __XFILE__(x) wxT(x)
234 #define __TFILE__ __XFILE__(__FILE__)
235 #endif
236
237 #ifndef __TDATE__
238 #define __XDATE__(x) wxT(x)
239 #define __TDATE__ __XDATE__(__DATE__)
240 #endif
241
242 #ifndef __TTIME__
243 #define __XTIME__(x) wxT(x)
244 #define __TTIME__ __XTIME__(__TIME__)
245 #endif
246
247 // ----------------------------------------------------------------------------
248 // define wxFoo() function for each standard foo() function whose signature
249 // (exceptionally including the return type) includes any mention of char:
250 // wxFoo() is going to be a Unicode-friendly version of foo(), i.e. will have
251 // the same signature but with char replaced by wxChar which allows us to use
252 // it in Unicode build as well
253 // ----------------------------------------------------------------------------
254
255 #ifdef wxHAVE_TCHAR_SUPPORT
256 #include <ctype.h>
257
258 // ctype.h functions
259 #define wxIsalnum _istalnum
260 #define wxIsalpha _istalpha
261 #define wxIsctrl _istctrl
262 #define wxIsdigit _istdigit
263 #define wxIsgraph _istgraph
264 #define wxIslower _istlower
265 #define wxIsprint _istprint
266 #define wxIspunct _istpunct
267 #define wxIsspace _istspace
268 #define wxIsupper _istupper
269 #define wxIsxdigit _istxdigit
270 #define wxTolower _totlower
271 #define wxToupper _totupper
272
273 // locale.h functons
274 #define wxSetlocale _tsetlocale
275
276 // string.h functions
277 #define wxStrcat _tcscat
278 #define wxStrchr _tcschr
279 #define wxStrcmp _tcscmp
280 #define wxStrcoll _tcscoll
281 #define wxStrcpy _tcscpy
282 #define wxStrcspn _tcscspn
283 #define wxStrdupW _wcsdup // notice the 'W'!
284 #define wxStrftime _tcsftime
285 #define wxStricmp _tcsicmp
286 #define wxStrnicmp _tcsnicmp
287 #define wxStrlen_ _tcslen // used in wxStrlen inline function
288 #define wxStrncat _tcsncat
289 #define wxStrncmp _tcsncmp
290 #define wxStrncpy _tcsncpy
291 #define wxStrpbrk _tcspbrk
292 #define wxStrrchr _tcsrchr
293 #define wxStrspn _tcsspn
294 #define wxStrstr _tcsstr
295 #define wxStrtod _tcstod
296 #define wxStrtol _tcstol
297 #define wxStrtoul _tcstoul
298 #define wxStrxfrm _tcsxfrm
299
300 // stdio.h functions
301 #define wxFgetc _fgettc
302 #define wxFgetchar _fgettchar
303 #define wxFgets _fgetts
304 #define wxFopen _tfopen
305 #define wxFputc _fputtc
306 #define wxFputchar _fputtchar
307 #define wxFprintf _ftprintf
308 #define wxFputs _fputts
309 #define wxFreopen _tfreopen
310 #define wxFscanf _ftscanf
311 #define wxGetc _gettc
312 #define wxGetchar _gettchar
313 #define wxGets _getts
314 #define wxPerror _tperror
315 #define wxPrintf _tprintf
316 #define wxPutc _puttc
317 #define wxPutchar _puttchar
318 #define wxPuts _putts
319 #define wxScanf _tscanf
320 #define wxSprintf _stprintf
321 #define wxSscanf _stscanf
322 #define wxTmpnam _ttmpnam
323 #define wxUngetc _tungetc
324 #define wxVfprintf _vftprintf
325 #define wxVprintf _vtprintf
326 #define wxVsscanf _vstscanf
327 #define wxVsprintf _vstprintf
328
329 // special case: not all TCHAR-aware compilers have those
330 #if defined(__VISUALC__) || \
331 (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
332 #define wxVsnprintf_ _vsntprintf
333 #define wxSnprintf_ _sntprintf
334 #endif
335
336 // special case: these functions are missing under Win9x with Unicows so we
337 // have to implement them ourselves
338 #if wxUSE_UNICODE_MSLU
339 #define wxRemove wxMSLU__tremove
340 #define wxRename wxMSLU__trename
341 #else
342 #ifdef __WXWINCE__
343 #define wxRemove DeleteFile
344 #else
345 #define wxRemove _tremove
346 #define wxRename _trename
347 #endif
348 #endif
349
350 // stdlib.h functions
351 #define wxAtoi _ttoi
352 #define wxAtol _ttol
353 // #define wxAtof _tttof -- notice that there is no such thing (why?)
354 #define wxGetenv _tgetenv
355 #define wxSystem _tsystem
356
357 // time.h functions
358 #define wxAsctime _tasctime
359 #define wxCtime _tctime
360 #else // !TCHAR-aware compilers
361 #if wxUSE_UNICODE
362 #include <wctype.h>
363
364 // this is probably glibc-specific
365 #if defined(__WCHAR_TYPE__)
366 // ctype.h functions (wctype.h)
367 #define wxIsalnum iswalnum
368 #define wxIsalpha iswalpha
369 #define wxIsctrl iswcntrl
370 #define wxIsdigit iswdigit
371 #define wxIsgraph iswgraph
372 #define wxIslower iswlower
373 #define wxIsprint iswprint
374 #define wxIspunct iswpunct
375 #define wxIsspace iswspace
376 #define wxIsupper iswupper
377 #define wxIsxdigit iswxdigit
378
379 #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
380 // /usr/include/wctype.h incorrectly declares translations
381 // tables which provokes tons of compile-time warnings -- try
382 // to correct this
383 #define wxTolower(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
384 #define wxToupper(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
385 #else // !glibc 2.0
386 #define wxTolower towlower
387 #define wxToupper towupper
388 #endif // gcc/!gcc
389
390 // string.h functions (wchar.h)
391 #define wxStrcat wcscat
392 #define wxStrchr wcschr
393 #define wxStrcmp wcscmp
394 #define wxStrcoll wcscoll
395 #define wxStrcpy wcscpy
396 #define wxStrcspn wcscspn
397 #define wxStrlen_ wxWcslen // wxStrlen_() is used in wxStrlen()
398 #define wxStrncat wcsncat
399 #define wxStrncmp wcsncmp
400 #define wxStrncpy wcsncpy
401 #define wxStrpbrk wcspbrk
402 #define wxStrrchr wcsrchr
403 #define wxStrspn wcsspn
404 #define wxStrstr wcsstr
405 #define wxStrtod wcstod
406 #define wxStrtol wcstol
407 #define wxStrtoul wcstoul
408 #define wxStrxfrm wcsxfrm
409
410 #define wxFgetc fgetwc
411 #define wxFgetchar fgetwchar
412 #define wxFgets fgetws
413 #define wxFputc fputwc
414 #define wxFputchar fputwchar
415 #define wxGetc getwc
416 #define wxGetchar getwchar
417 #define wxGets getws
418 #define wxUngetc ungetwc
419
420 #ifdef HAVE_FPUTWC
421 #define wxPutc wputc
422 #define wxPutchar wputchar
423 #define wxPuts putws
424 #define wxFputs fputws
425 #else
426 #define wxNEED_FPUTWC
427
428 #include <stdio.h>
429
430 int wxFputs(const wxChar *ch, FILE *stream);
431 int wxPutc(wxChar ch, FILE *stream);
432
433 #define wxPuts(ws) wxFputs(ws, stdout)
434 #define wxPutchar(wch) wxPutc(wch, stdout)
435 #endif
436
437 // we need %s to %ls conversion for printf and scanf etc
438 #define wxNEED_PRINTF_CONVERSION
439
440 // glibc doesn't have wide char equivalents of the other stuff so
441 // use our own versions
442 #define wxNEED_WX_STDIO_H
443 #define wxNEED_WX_STDLIB_H
444 #define wxNEED_WX_TIME_H
445 #elif defined(__MWERKS__) && ( defined(macintosh) || defined(__MACH__) )
446 // ctype.h functions (wctype.h)
447 #define wxIsalnum iswalnum
448 #define wxIsalpha iswalpha
449 #define wxIsctrl iswcntrl
450 #define wxIsdigit iswdigit
451 #define wxIsgraph iswgraph
452 #define wxIslower iswlower
453 #define wxIsprint iswprint
454 #define wxIspunct iswpunct
455 #define wxIsspace iswspace
456 #define wxIsupper iswupper
457 #define wxIsxdigit iswxdigit
458 #define wxTolower towlower
459 #define wxToupper towupper
460
461 // string.h functions (wchar.h)
462 #define wxStrcat wcscat
463 #define wxStrchr wcschr
464 #define wxStrcmp wcscmp
465 #define wxStrcoll wcscoll
466 #define wxStrcpy wcscpy
467 #define wxStrcspn wcscspn
468 #define wxStrlen_ wxWcslen // wxStrlen_() is used in wxStrlen()
469 #define wxStrncat wcsncat
470 #define wxStrncmp wcsncmp
471 #define wxStrncpy wcsncpy
472 #define wxStrpbrk wcspbrk
473 #define wxStrrchr wcsrchr
474 #define wxStrspn wcsspn
475 #define wxStrstr wcsstr
476 #define wxStrtod wcstod
477 #define wxStrtol wcstol
478 #define wxStrtoul wcstoul
479 #define wxStrxfrm wcsxfrm
480
481 #define wxFgetc fgetwc
482 #define wxFgetchar fgetwchar
483 #define wxFgets fgetws
484 #define wxFputc fputwc
485 #define wxFputchar fputwchar
486 #define wxGetc getwc
487 #define wxGetchar getwchar
488 #define wxGets getws
489 #define wxUngetc ungetwc
490
491 #define wxNEED_PRINTF_CONVERSION
492
493 #define wxPutc putwc
494 #define wxPutchar putwchar
495 #define wxFputs fputws
496
497 // stdio.h functions
498
499 #define wxNEED_WX_STDIO_H
500
501 // stdlib.h functions
502 #define wxAtof watof
503 #define wxAtoi watoi
504 #define wxAtol watol
505 #define wxGetenv(a) ((wxChar*)NULL)
506 #define wxSystem(a) ((int)NULL)
507
508 // time.h functions
509 #define wxAsctime wasciitime
510 #define wxCtime wctime
511 // #define wxStrftime wcsftime
512
513 /*
514 #define wxNEED_FPUTWC
515
516 #include <stdio.h>
517
518 int wxFputs(const wxChar *ch, FILE *stream);
519 int wxPutc(wxChar ch, FILE *stream);
520
521 #define wxPuts(ws) wxFputs(ws, stdout)
522 #define wxPutchar(wch) wxPutc(wch, stdout)
523
524 // we need %s to %ls conversion for printf and scanf etc
525 #define wxNEED_PRINTF_CONVERSION
526 // glibc doesn't have wide char equivalents of the other stuff so
527 // use our own versions
528 #define wxNEED_WX_STDIO_H
529 #define wxNEED_WX_STDLIB_H
530 */
531 #define wxNEED_WX_TIME_H
532 #else // !metrowerks for apple
533 #error "Please define wide character functions for your environment"
534 #endif
535 #else // ASCII
536 #include <ctype.h>
537 #include <string.h>
538
539 // ctype.h functions
540 #define wxIsalnum isalnum
541 #define wxIsalpha isalpha
542 #define wxIsctrl isctrl
543 #define wxIsdigit isdigit
544 #define wxIsgraph isgraph
545 #define wxIslower islower
546 #define wxIsprint isprint
547 #define wxIspunct ispunct
548 #define wxIsspace isspace
549 #define wxIsupper isupper
550 #define wxIsxdigit isxdigit
551 #define wxTolower tolower
552 #define wxToupper toupper
553
554 // locale.h functons
555 #define wxSetlocale setlocale
556
557 // string.h functions
558 #define wxStrcat strcat
559 #define wxStrchr strchr
560 #define wxStrcmp strcmp
561 #define wxStrcoll strcoll
562 #define wxStrcpy strcpy
563 #define wxStrcspn strcspn
564
565 // wxStricmp and wxStrnicmp are defined below
566 #define wxStrlen_ strlen // used in wxStrlen inline function
567 #define wxStrncat strncat
568 #define wxStrncmp strncmp
569 #define wxStrncpy strncpy
570 #define wxStrpbrk strpbrk
571 #define wxStrrchr strrchr
572 #define wxStrspn strspn
573 #define wxStrstr strstr
574 #define wxStrtod strtod
575 #ifdef HAVE_STRTOK_R
576 #define wxStrtok(str, sep, last) strtok_r(str, sep, last)
577 #endif
578 #define wxStrtol strtol
579 #define wxStrtoul strtoul
580 #define wxStrxfrm strxfrm
581
582 // stdio.h functions
583 #define wxFopen fopen
584 #define wxFreopen freopen
585 #define wxRemove remove
586 #define wxRename rename
587
588 #define wxPerror perror
589 #define wxTmpnam tmpnam
590
591 #define wxFgetc fgetc
592 #define wxFgetchar fgetchar
593 #define wxFgets fgets
594 #define wxFputc fputc
595 #define wxFputchar fputchar
596 #define wxFprintf fprintf
597 #define wxFscanf fscanf
598 #define wxGetc getc
599 #define wxGetchar getchar
600 #define wxGets gets
601 #define wxPrintf printf
602 #define wxPutc putc
603 #define wxPutchar putchar
604 #define wxPuts puts
605 #define wxScanf scanf
606 #define wxSprintf sprintf
607 #define wxSscanf sscanf
608 #define wxUngetc ungetc
609 #define wxVfprintf vfprintf
610 #define wxVprintf vprintf
611 #define wxVsscanf vsscanf
612 #define wxVsprintf vsprintf
613
614 // stdlib.h functions
615 #define wxAtof atof
616 #define wxAtoi atoi
617 #define wxAtol atol
618 #define wxGetenv getenv
619 #define wxSystem system
620
621 // time.h functions
622 #define wxAsctime asctime
623 #define wxCtime ctime
624 #define wxStrftime strftime
625 #endif // Unicode/ASCII
626 #endif // TCHAR-aware compilers/the others
627
628 // ----------------------------------------------------------------------------
629 // various special cases
630 // ----------------------------------------------------------------------------
631
632 // define wxStricmp and wxStrnicmp for various compilers
633 //
634 // note that in Unicode mode we definitely are going to need our own version
635 #if !defined(wxStricmp) && !wxUSE_UNICODE
636 #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
637 defined(__SALFORDC__) || defined(__VISAGECPP__) || \
638 defined(__EMX__) || defined(__DJGPP__)
639 #define wxStricmp stricmp
640 #define wxStrnicmp strnicmp
641 #elif defined(__SYMANTEC__) || defined(__VISUALC__) || \
642 (defined(__MWERKS__) && defined(__INTEL__))
643 #define wxStricmp _stricmp
644 #define wxStrnicmp _strnicmp
645 #elif defined(__UNIX__) || defined(__GNUWIN32__)
646 #define wxStricmp strcasecmp
647 #define wxStrnicmp strncasecmp
648 // #else -- use wxWindows implementation
649 #endif
650 #endif // !defined(wxStricmp)
651
652 // define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
653 // it's used in wx/buffer.h -- and also might be used just below by wxStrlen()
654 // when wxStrlen_() is #define'd as wxWcslen so do it before defining wxStrlen)
655 #if wxUSE_WCHAR_T
656 #ifdef HAVE_WCSLEN
657 #define wxWcslen wcslen
658 #else
659 inline size_t wxWcslen(const wchar_t *s)
660 {
661 size_t n = 0;
662 while ( *s++ )
663 n++;
664
665 return n;
666 }
667 #endif
668 #endif // wxUSE_WCHAR_T
669
670 // checks whether the passed in pointer is NULL and if the string is empty
671 inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }
672
673 // safe version of strlen() (returns 0 if passed NULL pointer)
674 inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }
675
676 // each of strdup() and wcsdup() may or may not be available but we need both
677 // of them anyhow for wx/buffer.h so we define the missing one(s) in
678 // wxchar.cpp and so we should always have both wxStrdupA and wxStrdupW
679 // defined -- if this is somehow not the case in some situations, please
680 // correct that and not the lines here
681 #if wxUSE_UNICODE
682 #define wxStrdup wxStrdupW
683 #else
684 #define wxStrdup wxStrdupA
685 #endif
686
687 WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
688
689 // ----------------------------------------------------------------------------
690 // printf() family saga
691 // ----------------------------------------------------------------------------
692
693 /*
694 For some systems vsnprintf() exists in the system libraries but not in the
695 headers, so we need to declare it ourselves to be able to use it.
696 */
697 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
698 extern "C"
699 int vsnprintf(char *str, size_t size, const char *format, va_list ap);
700 #endif // !HAVE_VSNPRINTF_DECL
701
702 /*
703 First of all, we always want to define safe snprintf() function to be used
704 instead of sprintf(). Some compilers already have it (or rather vsnprintf()
705 which we really need...), otherwise we implement it using our own printf()
706 code.
707
708 We define function with a trailing underscore here because the real one is a
709 wrapper around it as explained below
710 */
711 #ifndef wxVsnprintf_
712 #if wxUSE_UNICODE
713 #if defined(__MWERKS__)
714 #define HAVE_WCSRTOMBS 1
715 #define HAVE_VSWPRINTF 1
716 #endif
717 #if defined(HAVE__VSNWPRINTF)
718 #define wxVsnprintf_ _vsnwprintf
719 /* MinGW?MSVCRT has the wrong vswprintf */
720 #elif defined(HAVE_VSWPRINTF) && !defined(__MINGW32__)
721 #define wxVsnprintf_ vswprintf
722 #endif
723 #else // ASCII
724 // all versions of CodeWarrior supported by wxWindows apparently have
725 // vsnprintf()
726 #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
727 // assume we have snprintf() too if we have vsnprintf()
728 #define wxVsnprintf_ vsnprintf
729 #define wxSnprintf_ snprintf
730 #endif
731 #endif
732 #endif // wxVsnprintf_ not defined yet
733
734 #ifndef wxSnprintf_
735 // no [v]snprintf(), cook our own
736 WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
737 ...) ATTRIBUTE_PRINTF_3;
738 #endif
739 #ifndef wxVsnprintf_
740 WXDLLIMPEXP_BASE int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format,
741 va_list argptr);
742 #endif
743
744 /*
745 In Unicode mode we need to have all standard functions such as wprintf() and
746 so on but not all systems have them so use our own implementations in this
747 case.
748 */
749 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
750 #define wxNEED_WPRINTF
751 #endif
752
753 /*
754 More Unicode complications: although both ANSI C and C++ define a number of
755 wide character functions such as wprintf(), not all environments have them.
756 Worse, those which do have different behaviours: under Windows, %s format
757 specifier changes its meaning in Unicode build and expects a Unicode string
758 while under Unix/POSIX it still means an ASCII string even for wprintf() and
759 %ls has to be used for wide strings.
760
761 We choose to always emulate Windows behaviour as more useful for us so even
762 if we have wprintf() we still must wrap it in a non trivial wxPrintf().
763
764 However, if we don't have any vswprintf() at all we don't need to redefine
765 anything as our own wxVsnprintf_() already behaves as needed.
766 */
767 #ifndef wxVsnprintf_
768 #undef wxNEED_PRINTF_CONVERSION
769 #endif
770
771 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
772 // we need to implement all wide character printf and scanf functions
773 // either because we don't have them at all or because they don't have the
774 // semantics we need
775
776 #include <stdio.h> // for FILE
777
778 int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
779 int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
780 int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
781 int wxVsscanf( const wxChar *str, const wxChar *format, va_list ap );
782 int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
783 int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
784 int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
785 int wxVfprintf( FILE *stream, const wxChar *format, va_list ap );
786 int wxVprintf( const wxChar *format, va_list ap );
787 int wxVsprintf( wxChar *str, const wxChar *format, va_list ap );
788 #endif // wxNEED_PRINTF_CONVERSION
789
790 // these 2 can be simply mapped to the versions with underscore at the end
791 // if we don't have to do the conversion
792 #ifdef wxNEED_PRINTF_CONVERSION
793 int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
794 int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap );
795 #else
796 #define wxSnprintf wxSnprintf_
797 #define wxVsnprintf wxVsnprintf_
798 #endif
799
800 // ----------------------------------------------------------------------------
801 // various functions which might not be available in libc and for which we
802 // provide our own replacements in wxchar.cpp
803 // ----------------------------------------------------------------------------
804
805 // ctype.h functions
806 //
807 // VZ: note that this is never defined currently
808 #ifdef wxNEED_WX_CTYPE_H
809 WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
810 WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
811 WXDLLIMPEXP_BASE int wxIsctrl(wxChar ch);
812 WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
813 WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
814 WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
815 WXDLLIMPEXP_BASE int wxIsprint(wxChar ch);
816 WXDLLIMPEXP_BASE int wxIspunct(wxChar ch);
817 WXDLLIMPEXP_BASE int wxIsspace(wxChar ch);
818 WXDLLIMPEXP_BASE int wxIsupper(wxChar ch);
819 WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
820 WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
821 WXDLLIMPEXP_BASE int wxToupper(wxChar ch);
822 #endif // wxNEED_WX_CTYPE_H
823
824 // under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
825 // the file parsing -- this may be true for 5.0 as well, update #ifdef then
826 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
827 #undef wxIsspace
828 #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
829 #endif // VC++
830
831
832 // string.h functions
833 //
834 // VZ: this is never defined neither currently
835 #ifdef wxNEED_WX_STRING_H
836 WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
837 WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
838 WXDLLIMPEXP_BASE wxChar * wxStrchr(wxChar *s, wxChar c)
839 { return (wxChar *)wxStrchr((const wxChar *)s, c); }
840 WXDLLIMPEXP_BASE int wxStrcmp(const wxChar *s1, const wxChar *s2);
841 WXDLLIMPEXP_BASE int wxStrcoll(const wxChar *s1, const wxChar *s2);
842 WXDLLIMPEXP_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
843 WXDLLIMPEXP_BASE size_t wxStrcspn(const wxChar *s, const wxChar *reject);
844 WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar *s);
845 WXDLLIMPEXP_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
846 WXDLLIMPEXP_BASE int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
847 WXDLLIMPEXP_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
848 WXDLLIMPEXP_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
849 WXDLLIMPEXP_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
850 { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
851 WXDLLIMPEXP_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
852 WXDLLIMPEXP_BASE wxChar * wxStrrchr(wxChar *s, wxChar c)
853 { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
854 WXDLLIMPEXP_BASE size_t wxStrspn(const wxChar *s, const wxChar *accept);
855 WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
856 WXDLLIMPEXP_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
857 { return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
858 WXDLLIMPEXP_BASE double wxStrtod(const wxChar *nptr, wxChar **endptr);
859 WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
860 WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
861 WXDLLIMPEXP_BASE size_t wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
862 #endif // wxNEED_WX_STRING_H
863
864 #ifndef wxStrdupA
865 WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
866 #endif
867
868 #ifndef wxStrdupW
869 WXDLLIMPEXP_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
870 #endif
871
872 #ifndef wxStricmp
873 WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
874 #endif
875
876 #ifndef wxStrnicmp
877 WXDLLIMPEXP_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len);
878 #endif
879
880 #ifndef wxStrtok
881 WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
882 #endif
883
884 #ifndef wxSetlocale
885 class WXDLLIMPEXP_BASE wxWCharBuffer;
886 WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
887 #endif
888
889 // stdio.h functions
890 #ifdef wxNEED_WX_STDIO_H
891 #include <stdio.h>
892 WXDLLIMPEXP_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode);
893 WXDLLIMPEXP_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
894 WXDLLIMPEXP_BASE int wxRemove(const wxChar *path);
895 WXDLLIMPEXP_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath);
896
897 // *printf() family is handled separately
898 #endif // wxNEED_WX_STDIO_H
899
900
901 // stdlib.h functions
902 #ifndef wxAtof
903 WXDLLIMPEXP_BASE double wxAtof(const wxChar *psz);
904 #endif
905
906 #ifdef wxNEED_WX_STDLIB_H
907 WXDLLIMPEXP_BASE int wxAtoi(const wxChar *psz);
908 WXDLLIMPEXP_BASE long wxAtol(const wxChar *psz);
909 WXDLLIMPEXP_BASE wxChar * wxGetenv(const wxChar *name);
910 WXDLLIMPEXP_BASE int wxSystem(const wxChar *psz);
911 #endif
912
913
914 // time.h functions
915 #ifdef wxNEED_WX_TIME_H
916 #if defined(__MWERKS__) && defined(macintosh)
917 #include <time.h>
918 #endif
919 WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
920 const wxChar *fmt, const struct tm *tm);
921 #endif // wxNEED_WX_TIME_H
922
923 // missing functions in WinCE
924 #ifdef __WXWINCE__
925 WXDLLIMPEXP_BASE char* strdup(const char* s);
926 WXDLLIMPEXP_BASE void *calloc( size_t num, size_t size );
927
928 #if _WIN32_WCE <= 211
929 WXDLLIMPEXP_BASE int isspace(int c);
930 WXDLLIMPEXP_BASE int isascii( int c );
931 #endif
932 #endif
933
934 // ----------------------------------------------------------------------------
935 // multibyte to wide char conversion functions and macros
936 // ----------------------------------------------------------------------------
937
938 #if wxUSE_WCHAR_T
939 // multibyte<->widechar conversion
940 WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
941 WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
942
943 #if wxUSE_UNICODE
944 #define wxMB2WX wxMB2WC
945 #define wxWX2MB wxWC2MB
946 #define wxWC2WX wxStrncpy
947 #define wxWX2WC wxStrncpy
948 #else
949 #define wxMB2WX wxStrncpy
950 #define wxWX2MB wxStrncpy
951 #define wxWC2WX wxWC2MB
952 #define wxWX2WC wxMB2WC
953 #endif
954 #else // !wxUSE_UNICODE
955 // No wxUSE_WCHAR_T: we have to do something (JACS)
956 #define wxMB2WC wxStrncpy
957 #define wxWC2MB wxStrncpy
958 #define wxMB2WX wxStrncpy
959 #define wxWX2MB wxStrncpy
960 #define wxWC2WX wxWC2MB
961 #define wxWX2WC wxMB2WC
962 #endif
963
964 #endif //_WX_WXCHAR_H_
965
wxWidgets (Impactor)