]> git.saurik.com Git - wxWidgets.git/blob - include/wx/wxchar.h
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
STL-ification patch for wxMSW and wxGTK.
[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(__APPLE__)
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 #define wxRemove _tremove
343 #define wxRename _trename
344 #endif
345
346 // stdlib.h functions
347 #define wxAtoi _ttoi
348 #define wxAtol _ttol
349 // #define wxAtof _tttof -- notice that there is no such thing (why?)
350 #define wxGetenv _tgetenv
351 #define wxSystem _tsystem
352
353 // time.h functions
354 #define wxAsctime _tasctime
355 #define wxCtime _tctime
356 #else // !TCHAR-aware compilers
357 #if wxUSE_UNICODE
358 #include <wctype.h>
359
360 // this is probably glibc-specific
361 #if defined(__WCHAR_TYPE__)
362 // ctype.h functions (wctype.h)
363 #define wxIsalnum iswalnum
364 #define wxIsalpha iswalpha
365 #define wxIsctrl iswcntrl
366 #define wxIsdigit iswdigit
367 #define wxIsgraph iswgraph
368 #define wxIslower iswlower
369 #define wxIsprint iswprint
370 #define wxIspunct iswpunct
371 #define wxIsspace iswspace
372 #define wxIsupper iswupper
373 #define wxIsxdigit iswxdigit
374
375 #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0)
376 // /usr/include/wctype.h incorrectly declares translations
377 // tables which provokes tons of compile-time warnings -- try
378 // to correct this
379 #define wxTolower(wc) towctrans((wc), (wctrans_t)__ctype_tolower)
380 #define wxToupper(wc) towctrans((wc), (wctrans_t)__ctype_toupper)
381 #else // !glibc 2.0
382 #define wxTolower towlower
383 #define wxToupper towupper
384 #endif // gcc/!gcc
385
386 // string.h functions (wchar.h)
387 #define wxStrcat wcscat
388 #define wxStrchr wcschr
389 #define wxStrcmp wcscmp
390 #define wxStrcoll wcscoll
391 #define wxStrcpy wcscpy
392 #define wxStrcspn wcscspn
393 #define wxStrlen_ wxWcslen // wxStrlen_() is used in wxStrlen()
394 #define wxStrncat wcsncat
395 #define wxStrncmp wcsncmp
396 #define wxStrncpy wcsncpy
397 #define wxStrpbrk wcspbrk
398 #define wxStrrchr wcsrchr
399 #define wxStrspn wcsspn
400 #define wxStrstr wcsstr
401 #define wxStrtod wcstod
402 #define wxStrtol wcstol
403 #define wxStrtoul wcstoul
404 #define wxStrxfrm wcsxfrm
405
406 #define wxFgetc fgetwc
407 #define wxFgetchar fgetwchar
408 #define wxFgets fgetws
409 #define wxFputc fputwc
410 #define wxFputchar fputwchar
411 #define wxGetc getwc
412 #define wxGetchar getwchar
413 #define wxGets getws
414 #define wxUngetc ungetwc
415
416 #ifdef HAVE_FPUTWC
417 #define wxPutc wputc
418 #define wxPutchar wputchar
419 #define wxPuts putws
420 #define wxFputs fputws
421 #else
422 #define wxNEED_FPUTWC
423
424 #include <stdio.h>
425
426 int wxFputs(const wxChar *ch, FILE *stream);
427 int wxPutc(wxChar ch, FILE *stream);
428
429 #define wxPuts(ws) wxFputs(ws, stdout)
430 #define wxPutchar(wch) wxPutc(wch, stdout)
431 #endif
432
433 // we need %s to %ls conversion for printf and scanf etc
434 #define wxNEED_PRINTF_CONVERSION
435
436 // glibc doesn't have wide char equivalents of the other stuff so
437 // use our own versions
438 #define wxNEED_WX_STDIO_H
439 #define wxNEED_WX_STDLIB_H
440 #define wxNEED_WX_TIME_H
441 #elif defined(__MWERKS__) && ( defined(macintosh) || defined(__MACH__) )
442 // ctype.h functions (wctype.h)
443 #define wxIsalnum iswalnum
444 #define wxIsalpha iswalpha
445 #define wxIsctrl iswcntrl
446 #define wxIsdigit iswdigit
447 #define wxIsgraph iswgraph
448 #define wxIslower iswlower
449 #define wxIsprint iswprint
450 #define wxIspunct iswpunct
451 #define wxIsspace iswspace
452 #define wxIsupper iswupper
453 #define wxIsxdigit iswxdigit
454 #define wxTolower towlower
455 #define wxToupper towupper
456
457 // string.h functions (wchar.h)
458 #define wxStrcat wcscat
459 #define wxStrchr wcschr
460 #define wxStrcmp wcscmp
461 #define wxStrcoll wcscoll
462 #define wxStrcpy wcscpy
463 #define wxStrcspn wcscspn
464 #define wxStrlen_ wxWcslen // wxStrlen_() is used in wxStrlen()
465 #define wxStrncat wcsncat
466 #define wxStrncmp wcsncmp
467 #define wxStrncpy wcsncpy
468 #define wxStrpbrk wcspbrk
469 #define wxStrrchr wcsrchr
470 #define wxStrspn wcsspn
471 #define wxStrstr wcsstr
472 #define wxStrtod wcstod
473 #define wxStrtol wcstol
474 #define wxStrtoul wcstoul
475 #define wxStrxfrm wcsxfrm
476
477 #define wxFgetc fgetwc
478 #define wxFgetchar fgetwchar
479 #define wxFgets fgetws
480 #define wxFputc fputwc
481 #define wxFputchar fputwchar
482 #define wxGetc getwc
483 #define wxGetchar getwchar
484 #define wxGets getws
485 #define wxUngetc ungetwc
486
487 #define wxNEED_PRINTF_CONVERSION
488
489 #define wxPutc putwc
490 #define wxPutchar putwchar
491 #define wxFputs fputws
492
493 // stdio.h functions
494
495 #define wxNEED_WX_STDIO_H
496
497 // stdlib.h functions
498 #define wxAtof watof
499 #define wxAtoi watoi
500 #define wxAtol watol
501 #define wxGetenv(a) ((wxChar*)NULL)
502 #define wxSystem(a) ((int)NULL)
503
504 // time.h functions
505 #define wxAsctime wasciitime
506 #define wxCtime wctime
507 #define wxStrftime wcsftime
508
509 /*
510 #define wxNEED_FPUTWC
511
512 #include <stdio.h>
513
514 int wxFputs(const wxChar *ch, FILE *stream);
515 int wxPutc(wxChar ch, FILE *stream);
516
517 #define wxPuts(ws) wxFputs(ws, stdout)
518 #define wxPutchar(wch) wxPutc(wch, stdout)
519
520 // we need %s to %ls conversion for printf and scanf etc
521 #define wxNEED_PRINTF_CONVERSION
522 // glibc doesn't have wide char equivalents of the other stuff so
523 // use our own versions
524 #define wxNEED_WX_STDIO_H
525 #define wxNEED_WX_STDLIB_H
526 #define wxNEED_WX_TIME_H
527 */
528 #else // !metrowerks for apple
529 #error "Please define wide character functions for your environment"
530 #endif
531 #else // ASCII
532 #include <ctype.h>
533 #include <string.h>
534
535 // ctype.h functions
536 #define wxIsalnum isalnum
537 #define wxIsalpha isalpha
538 #define wxIsctrl isctrl
539 #define wxIsdigit isdigit
540 #define wxIsgraph isgraph
541 #define wxIslower islower
542 #define wxIsprint isprint
543 #define wxIspunct ispunct
544 #define wxIsspace isspace
545 #define wxIsupper isupper
546 #define wxIsxdigit isxdigit
547 #define wxTolower tolower
548 #define wxToupper toupper
549
550 // locale.h functons
551 #define wxSetlocale setlocale
552
553 // string.h functions
554 #define wxStrcat strcat
555 #define wxStrchr strchr
556 #define wxStrcmp strcmp
557 #define wxStrcoll strcoll
558 #define wxStrcpy strcpy
559 #define wxStrcspn strcspn
560
561 // wxStricmp and wxStrnicmp are defined below
562 #define wxStrlen_ strlen // used in wxStrlen inline function
563 #define wxStrncat strncat
564 #define wxStrncmp strncmp
565 #define wxStrncpy strncpy
566 #define wxStrpbrk strpbrk
567 #define wxStrrchr strrchr
568 #define wxStrspn strspn
569 #define wxStrstr strstr
570 #define wxStrtod strtod
571 #ifdef HAVE_STRTOK_R
572 #define wxStrtok(str, sep, last) strtok_r(str, sep, last)
573 #endif
574 #define wxStrtol strtol
575 #define wxStrtoul strtoul
576 #define wxStrxfrm strxfrm
577
578 // stdio.h functions
579 #if defined(__WXMAC__) && !defined(__DARWIN__)
580 #include <stdio.h>
581 WXDLLIMPEXP_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode);
582 WXDLLIMPEXP_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
583 WXDLLIMPEXP_BASE int wxRemove(const wxChar *path);
584 WXDLLIMPEXP_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath);
585 #else
586 #define wxFopen fopen
587 #define wxFreopen freopen
588 #define wxRemove remove
589 #define wxRename rename
590 #endif
591 #define wxPerror perror
592 #define wxTmpnam tmpnam
593
594 #define wxFgetc fgetc
595 #define wxFgetchar fgetchar
596 #define wxFgets fgets
597 #define wxFputc fputc
598 #define wxFputchar fputchar
599 #define wxFprintf fprintf
600 #define wxFscanf fscanf
601 #define wxGetc getc
602 #define wxGetchar getchar
603 #define wxGets gets
604 #define wxPrintf printf
605 #define wxPutc putc
606 #define wxPutchar putchar
607 #define wxPuts puts
608 #define wxScanf scanf
609 #define wxSprintf sprintf
610 #define wxSscanf sscanf
611 #define wxUngetc ungetc
612 #define wxVfprintf vfprintf
613 #define wxVprintf vprintf
614 #define wxVsscanf vsscanf
615 #define wxVsprintf vsprintf
616
617 // stdlib.h functions
618 #define wxAtof atof
619 #define wxAtoi atoi
620 #define wxAtol atol
621 #define wxGetenv getenv
622 #define wxSystem system
623
624 // time.h functions
625 #define wxAsctime asctime
626 #define wxCtime ctime
627 #define wxStrftime strftime
628 #endif // Unicode/ASCII
629 #endif // TCHAR-aware compilers/the others
630
631 // ----------------------------------------------------------------------------
632 // various special cases
633 // ----------------------------------------------------------------------------
634
635 // define wxStricmp and wxStrnicmp for various compilers
636 //
637 // note that in Unicode mode we definitely are going to need our own version
638 #if !defined(wxStricmp) && !wxUSE_UNICODE
639 #if defined(__BORLANDC__) || defined(__WATCOMC__) || \
640 defined(__SALFORDC__) || defined(__VISAGECPP__) || \
641 defined(__EMX__) || defined(__DJGPP__)
642 #define wxStricmp stricmp
643 #define wxStrnicmp strnicmp
644 #elif defined(__SYMANTEC__) || defined(__VISUALC__) || \
645 (defined(__MWERKS__) && defined(__INTEL__))
646 #define wxStricmp _stricmp
647 #define wxStrnicmp _strnicmp
648 #elif defined(__UNIX__) || defined(__GNUWIN32__)
649 #define wxStricmp strcasecmp
650 #define wxStrnicmp strncasecmp
651 // #else -- use wxWindows implementation
652 #endif
653 #endif // !defined(wxStricmp)
654
655 // define wxWcslen() which should be always available if wxUSE_WCHAR_T == 1 (as
656 // it's used in wx/buffer.h -- and also might be used just below by wxStrlen()
657 // when wxStrlen_() is #define'd as wxWcslen so do it before defining wxStrlen)
658 #if wxUSE_WCHAR_T
659 #ifdef HAVE_WCSLEN
660 #define wxWcslen wcslen
661 #else
662 inline size_t wxWcslen(const wchar_t *s)
663 {
664 size_t n = 0;
665 while ( *s++ )
666 n++;
667
668 return n;
669 }
670 #endif
671 #endif // wxUSE_WCHAR_T
672
673 // checks whether the passed in pointer is NULL and if the string is empty
674 inline bool wxIsEmpty(const wxChar *p) { return !p || !*p; }
675
676 // safe version of strlen() (returns 0 if passed NULL pointer)
677 inline size_t wxStrlen(const wxChar *psz) { return psz ? wxStrlen_(psz) : 0; }
678
679 // each of strdup() and wcsdup() may or may not be available but we need both
680 // of them anyhow for wx/buffer.h so we define the missing one(s) in
681 // wxchar.cpp and so we should always have both wxStrdupA and wxStrdupW
682 // defined -- if this is somehow not the case in some situations, please
683 // correct that and not the lines here
684 #if wxUSE_UNICODE
685 #define wxStrdup wxStrdupW
686 #else
687 #define wxStrdup wxStrdupA
688 #endif
689
690 WXDLLIMPEXP_BASE bool wxOKlibc(); // for internal use
691
692 // ----------------------------------------------------------------------------
693 // printf() family saga
694 // ----------------------------------------------------------------------------
695
696 /*
697 For some systems vsnprintf() exists in the system libraries but not in the
698 headers, so we need to declare it ourselves to be able to use it.
699 */
700 #if defined(HAVE_VSNPRINTF) && !defined(HAVE_VSNPRINTF_DECL)
701 extern "C"
702 int vsnprintf(char *str, size_t size, const char *format, va_list ap);
703 #endif // !HAVE_VSNPRINTF_DECL
704
705 /*
706 First of all, we always want to define safe snprintf() function to be used
707 instead of sprintf(). Some compilers already have it (or rather vsnprintf()
708 which we really need...), otherwise we implement it using our own printf()
709 code.
710
711 We define function with a trailing underscore here because the real one is a
712 wrapper around it as explained below
713 */
714 #ifndef wxVsnprintf_
715 #if wxUSE_UNICODE
716 #if defined(__MWERKS__)
717 #define HAVE_WCSRTOMBS 1
718 #define HAVE_VSWPRINTF 1
719 #endif
720 #if defined(HAVE__VSNWPRINTF)
721 #define wxVsnprintf_ _vsnwprintf
722 /* MinGW?MSVCRT has the wrong vswprintf */
723 #elif defined(HAVE_VSWPRINTF) && !defined(__MINGW32__)
724 #define wxVsnprintf_ vswprintf
725 #endif
726 #else // ASCII
727 // all versions of CodeWarrior supported by wxWindows apparently have
728 // vsnprintf()
729 #if defined(HAVE_VSNPRINTF) || defined(__MWERKS__)
730 // assume we have snprintf() too if we have vsnprintf()
731 #define wxVsnprintf_ vsnprintf
732 #define wxSnprintf_ snprintf
733 #endif
734 #endif
735 #endif // wxVsnprintf_ not defined yet
736
737 #ifndef wxSnprintf_
738 // no [v]snprintf(), cook our own
739 WXDLLIMPEXP_BASE int wxSnprintf_(wxChar *buf, size_t len, const wxChar *format,
740 ...) ATTRIBUTE_PRINTF_3;
741 #endif
742 #ifndef wxVsnprintf_
743 WXDLLIMPEXP_BASE int wxVsnprintf_(wxChar *buf, size_t len, const wxChar *format,
744 va_list argptr);
745 #endif
746
747 /*
748 In Unicode mode we need to have all standard functions such as wprintf() and
749 so on but not all systems have them so use our own implementations in this
750 case.
751 */
752 #if wxUSE_UNICODE && !defined(wxHAVE_TCHAR_SUPPORT) && !defined(HAVE_WPRINTF)
753 #define wxNEED_WPRINTF
754 #endif
755
756 /*
757 More Unicode complications: although both ANSI C and C++ define a number of
758 wide character functions such as wprintf(), not all environments have them.
759 Worse, those which do have different behaviours: under Windows, %s format
760 specifier changes its meaning in Unicode build and expects a Unicode string
761 while under Unix/POSIX it still means an ASCII string even for wprintf() and
762 %ls has to be used for wide strings.
763
764 We choose to always emulate Windows behaviour as more useful for us so even
765 if we have wprintf() we still must wrap it in a non trivial wxPrintf().
766
767 However, if we don't have any vswprintf() at all we don't need to redefine
768 anything as our own wxVsnprintf_() already behaves as needed.
769 */
770 #ifndef wxVsnprintf_
771 #undef wxNEED_PRINTF_CONVERSION
772 #endif
773
774 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
775 // we need to implement all wide character printf and scanf functions
776 // either because we don't have them at all or because they don't have the
777 // semantics we need
778
779 #include <stdio.h> // for FILE
780
781 int wxScanf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
782 int wxSscanf( const wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
783 int wxFscanf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
784 int wxVsscanf( const wxChar *str, const wxChar *format, va_list ap );
785 int wxPrintf( const wxChar *format, ... ) ATTRIBUTE_PRINTF_1;
786 int wxSprintf( wxChar *str, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
787 int wxFprintf( FILE *stream, const wxChar *format, ... ) ATTRIBUTE_PRINTF_2;
788 int wxVfprintf( FILE *stream, const wxChar *format, va_list ap );
789 int wxVprintf( const wxChar *format, va_list ap );
790 int wxVsprintf( wxChar *str, const wxChar *format, va_list ap );
791 #endif // wxNEED_PRINTF_CONVERSION
792
793 // these 2 can be simply mapped to the versions with underscore at the end
794 // if we don't have to do the conversion
795 #ifdef wxNEED_PRINTF_CONVERSION
796 int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... ) ATTRIBUTE_PRINTF_3;
797 int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list ap );
798 #else
799 #define wxSnprintf wxSnprintf_
800 #define wxVsnprintf wxVsnprintf_
801 #endif
802
803 // ----------------------------------------------------------------------------
804 // various functions which might not be available in libc and for which we
805 // provide our own replacements in wxchar.cpp
806 // ----------------------------------------------------------------------------
807
808 // ctype.h functions
809 //
810 // VZ: note that this is never defined currently
811 #ifdef wxNEED_WX_CTYPE_H
812 WXDLLIMPEXP_BASE int wxIsalnum(wxChar ch);
813 WXDLLIMPEXP_BASE int wxIsalpha(wxChar ch);
814 WXDLLIMPEXP_BASE int wxIsctrl(wxChar ch);
815 WXDLLIMPEXP_BASE int wxIsdigit(wxChar ch);
816 WXDLLIMPEXP_BASE int wxIsgraph(wxChar ch);
817 WXDLLIMPEXP_BASE int wxIslower(wxChar ch);
818 WXDLLIMPEXP_BASE int wxIsprint(wxChar ch);
819 WXDLLIMPEXP_BASE int wxIspunct(wxChar ch);
820 WXDLLIMPEXP_BASE int wxIsspace(wxChar ch);
821 WXDLLIMPEXP_BASE int wxIsupper(wxChar ch);
822 WXDLLIMPEXP_BASE int wxIsxdigit(wxChar ch);
823 WXDLLIMPEXP_BASE int wxTolower(wxChar ch);
824 WXDLLIMPEXP_BASE int wxToupper(wxChar ch);
825 #endif // wxNEED_WX_CTYPE_H
826
827 // under VC++ 6.0 isspace() returns 1 for 8 bit chars which completely breaks
828 // the file parsing -- this may be true for 5.0 as well, update #ifdef then
829 #if defined(__VISUALC__) && (__VISUALC__ >= 1200) && !wxUSE_UNICODE
830 #undef wxIsspace
831 #define wxIsspace(c) ((((unsigned)c) < 128) && isspace(c))
832 #endif // VC++
833
834
835 // string.h functions
836 //
837 // VZ: this is never defined neither currently
838 #ifdef wxNEED_WX_STRING_H
839 WXDLLIMPEXP_BASE wxChar * wxStrcat(wxChar *dest, const wxChar *src);
840 WXDLLIMPEXP_BASE const wxChar * wxStrchr(const wxChar *s, wxChar c);
841 WXDLLIMPEXP_BASE wxChar * wxStrchr(wxChar *s, wxChar c)
842 { return (wxChar *)wxStrchr((const wxChar *)s, c); }
843 WXDLLIMPEXP_BASE int wxStrcmp(const wxChar *s1, const wxChar *s2);
844 WXDLLIMPEXP_BASE int wxStrcoll(const wxChar *s1, const wxChar *s2);
845 WXDLLIMPEXP_BASE wxChar * wxStrcpy(wxChar *dest, const wxChar *src);
846 WXDLLIMPEXP_BASE size_t wxStrcspn(const wxChar *s, const wxChar *reject);
847 WXDLLIMPEXP_BASE size_t wxStrlen(const wxChar *s);
848 WXDLLIMPEXP_BASE wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n);
849 WXDLLIMPEXP_BASE int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n);
850 WXDLLIMPEXP_BASE wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n);
851 WXDLLIMPEXP_BASE const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept);
852 WXDLLIMPEXP_BASE wxChar * wxStrpbrk(wxChar *s, const wxChar *accept)
853 { return (wxChar *)wxStrpbrk((const wxChar *)s, accept); }
854 WXDLLIMPEXP_BASE const wxChar * wxStrrchr(const wxChar *s, wxChar c);
855 WXDLLIMPEXP_BASE wxChar * wxStrrchr(wxChar *s, wxChar c)
856 { return (wxChar *)wxStrrchr((const wxChar *)s, c); }
857 WXDLLIMPEXP_BASE size_t wxStrspn(const wxChar *s, const wxChar *accept);
858 WXDLLIMPEXP_BASE const wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle);
859 WXDLLIMPEXP_BASE wxChar *wxStrstr(wxChar *haystack, const wxChar *needle)
860 { return (wxChar *)wxStrstr((const wxChar *)haystack, needle); }
861 WXDLLIMPEXP_BASE double wxStrtod(const wxChar *nptr, wxChar **endptr);
862 WXDLLIMPEXP_BASE long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base);
863 WXDLLIMPEXP_BASE unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base);
864 WXDLLIMPEXP_BASE size_t wxStrxfrm(wxChar *dest, const wxChar *src, size_t n);
865 #endif // wxNEED_WX_STRING_H
866
867 #ifndef wxStrdupA
868 WXDLLIMPEXP_BASE char *wxStrdupA(const char *psz);
869 #endif
870
871 #ifndef wxStrdupW
872 WXDLLIMPEXP_BASE wchar_t *wxStrdupW(const wchar_t *pwz);
873 #endif
874
875 #ifndef wxStricmp
876 WXDLLIMPEXP_BASE int wxStricmp(const wxChar *psz1, const wxChar *psz2);
877 #endif
878
879 #ifndef wxStrnicmp
880 WXDLLIMPEXP_BASE int wxStrnicmp(const wxChar *psz1, const wxChar *psz2, size_t len);
881 #endif
882
883 #ifndef wxStrtok
884 WXDLLIMPEXP_BASE wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr);
885 #endif
886
887 #ifndef wxSetlocale
888 class WXDLLIMPEXP_BASE wxWCharBuffer;
889 WXDLLIMPEXP_BASE wxWCharBuffer wxSetlocale(int category, const wxChar *locale);
890 #endif
891
892 // stdio.h functions
893 #ifdef wxNEED_WX_STDIO_H
894 #include <stdio.h>
895 WXDLLIMPEXP_BASE FILE * wxFopen(const wxChar *path, const wxChar *mode);
896 WXDLLIMPEXP_BASE FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream);
897 WXDLLIMPEXP_BASE int wxRemove(const wxChar *path);
898 WXDLLIMPEXP_BASE int wxRename(const wxChar *oldpath, const wxChar *newpath);
899
900 // *printf() family is handled separately
901 #endif // wxNEED_WX_STDIO_H
902
903
904 // stdlib.h functions
905 #ifndef wxAtof
906 WXDLLIMPEXP_BASE double wxAtof(const wxChar *psz);
907 #endif
908
909 #ifdef wxNEED_WX_STDLIB_H
910 WXDLLIMPEXP_BASE int wxAtoi(const wxChar *psz);
911 WXDLLIMPEXP_BASE long wxAtol(const wxChar *psz);
912 WXDLLIMPEXP_BASE wxChar * wxGetenv(const wxChar *name);
913 WXDLLIMPEXP_BASE int wxSystem(const wxChar *psz);
914 #endif
915
916
917 // time.h functions
918 #ifdef wxNEED_WX_TIME_H
919 #if defined(__MWERKS__) && defined(macintosh)
920 #include <time.h>
921 #endif
922 WXDLLIMPEXP_BASE size_t wxStrftime(wxChar *s, size_t max,
923 const wxChar *fmt, const struct tm *tm);
924 #endif // wxNEED_WX_TIME_H
925
926 // ----------------------------------------------------------------------------
927 // multibyte to wide char conversion functions and macros
928 // ----------------------------------------------------------------------------
929
930 #if wxUSE_WCHAR_T
931 // multibyte<->widechar conversion
932 WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n);
933 WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *psz, size_t n);
934
935 #if wxUSE_UNICODE
936 #define wxMB2WX wxMB2WC
937 #define wxWX2MB wxWC2MB
938 #define wxWC2WX wxStrncpy
939 #define wxWX2WC wxStrncpy
940 #else
941 #define wxMB2WX wxStrncpy
942 #define wxWX2MB wxStrncpy
943 #define wxWC2WX wxWC2MB
944 #define wxWX2WC wxMB2WC
945 #endif
946 #else // !wxUSE_UNICODE
947 // No wxUSE_WCHAR_T: we have to do something (JACS)
948 #define wxMB2WC wxStrncpy
949 #define wxWC2MB wxStrncpy
950 #define wxMB2WX wxStrncpy
951 #define wxWX2MB wxStrncpy
952 #define wxWC2WX wxWC2MB
953 #define wxWX2WC wxMB2WC
954 #endif
955
956 #endif //_WX_WXCHAR_H_
957
wxWidgets (Impactor)