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