projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added code for checking if the current locale is UTF-8 at runtime
[wxWidgets.git] / src / common / wxcrt.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/wxcrt.cpp
3 // Purpose: wxChar CRT wrappers implementation
4 // Author: Ove Kaven
5 // Modified by: Ron Lee, Francesco Montorsi
6 // Created: 09/04/99
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWidgets copyright
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // headers, declarations, constants
14 // ===========================================================================
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #include "wx/wxchar.h"
24
25 #define _ISOC9X_SOURCE 1 // to get vsscanf()
26 #define _BSD_SOURCE 1 // to still get strdup()
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #ifndef __WXWINCE__
33 #include <time.h>
34 #include <locale.h>
35 #else
36 #include "wx/msw/wince/time.h"
37 #endif
38
39 #ifndef WX_PRECOMP
40 #include "wx/string.h"
41 #include "wx/hash.h"
42 #include "wx/utils.h" // for wxMin and wxMax
43 #include "wx/log.h"
44 #endif
45
46 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
47 #include <windef.h>
48 #include <winbase.h>
49 #include <winnls.h>
50 #include <winnt.h>
51 #endif
52
53 #ifndef wxStrtoll
54 #ifdef __WXWINCE__
55 // there is no errno.h under CE apparently
56 #define wxSET_ERRNO(value)
57 #else
58 #include <errno.h>
59
60 #define wxSET_ERRNO(value) errno = value
61 #endif
62 #endif
63
64 #if defined(__MWERKS__) && __MSL__ >= 0x6000
65 namespace std {}
66 using namespace std ;
67 #endif
68
69 #if wxUSE_WCHAR_T
70 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
71 {
72 // assume that we have mbsrtowcs() too if we have wcsrtombs()
73 #ifdef HAVE_WCSRTOMBS
74 mbstate_t mbstate;
75 memset(&mbstate, 0, sizeof(mbstate_t));
76 #endif
77
78 if (buf) {
79 if (!n || !*psz) {
80 if (n) *buf = wxT('\0');
81 return 0;
82 }
83 #ifdef HAVE_WCSRTOMBS
84 return mbsrtowcs(buf, &psz, n, &mbstate);
85 #else
86 return wxMbstowcs(buf, psz, n);
87 #endif
88 }
89
90 // note that we rely on common (and required by Unix98 but unfortunately not
91 // C99) extension which allows to call mbs(r)towcs() with NULL output pointer
92 // to just get the size of the needed buffer -- this is needed as otherwise
93 // we have no idea about how much space we need and if the CRT doesn't
94 // support it (the only currently known example being Metrowerks, see
95 // wx/wxchar.h) we don't use its mbstowcs() at all
96 #ifdef HAVE_WCSRTOMBS
97 return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
98 #else
99 return wxMbstowcs((wchar_t *) NULL, psz, 0);
100 #endif
101 }
102
103 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
104 {
105 #ifdef HAVE_WCSRTOMBS
106 mbstate_t mbstate;
107 memset(&mbstate, 0, sizeof(mbstate_t));
108 #endif
109
110 if (buf) {
111 if (!n || !*pwz) {
112 // glibc2.1 chokes on null input
113 if (n) *buf = '\0';
114 return 0;
115 }
116 #ifdef HAVE_WCSRTOMBS
117 return wcsrtombs(buf, &pwz, n, &mbstate);
118 #else
119 return wxWcstombs(buf, pwz, n);
120 #endif
121 }
122
123 #ifdef HAVE_WCSRTOMBS
124 return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
125 #else
126 return wxWcstombs((char *) NULL, pwz, 0);
127 #endif
128 }
129 #endif // wxUSE_WCHAR_T
130
131 bool WXDLLEXPORT wxOKlibc()
132 {
133 #if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
134 // glibc 2.0 uses UTF-8 even when it shouldn't
135 wchar_t res = 0;
136 if ((MB_CUR_MAX == 2) &&
137 (wxMB2WC(&res, "\xdd\xa5", 1) == 1) &&
138 (res==0x765)) {
139 // this is UTF-8 allright, check whether that's what we want
140 char *cur_locale = setlocale(LC_CTYPE, NULL);
141 if ((strlen(cur_locale) < 4) ||
142 (strcasecmp(cur_locale + strlen(cur_locale) - 4, "utf8")) ||
143 (strcasecmp(cur_locale + strlen(cur_locale) - 5, "utf-8"))) {
144 // nope, don't use libc conversion
145 return false;
146 }
147 }
148 #endif
149 return true;
150 }
151
152 // ============================================================================
153 // printf() functions business
154 // ============================================================================
155
156 // special test mode: define all functions below even if we don't really need
157 // them to be able to test them
158 #ifdef wxTEST_PRINTF
159 #undef wxFprintf
160 #undef wxPrintf
161 #undef wxSprintf
162 #undef wxVfprintf
163 #undef wxVsprintf
164 #undef wxVprintf
165 #undef wxVsnprintf_
166 #undef wxSnprintf_
167
168 #define wxNEED_WPRINTF
169
170 int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr );
171 #endif
172
173 #if !defined(wxSnprintf_)
174 int WXDLLEXPORT wxDoSnprintf_(wxChar *buf, size_t len, const wxChar *format, ...)
175 {
176 va_list argptr;
177 va_start(argptr, format);
178
179 int iLen = wxVsnprintf_(buf, len, format, argptr);
180
181 va_end(argptr);
182
183 return iLen;
184 }
185 #endif // wxSnprintf_
186
187 #if defined(__DMC__)
188 /* Digital Mars adds count to _stprintf (C99) so convert */
189 #if wxUSE_UNICODE
190 int wxDoSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... )
191 {
192 va_list arglist;
193
194 va_start( arglist, format );
195 int iLen = swprintf ( s, -1, format, arglist );
196 va_end( arglist );
197 return iLen ;
198 }
199
200 #endif // wxUSE_UNICODE
201
202 #endif //__DMC__
203
204 // ----------------------------------------------------------------------------
205 // implement the standard IO functions for wide char if libc doesn't have them
206 // ----------------------------------------------------------------------------
207
208 #ifdef wxNEED_FPUTS
209 int wxFputs(const wchar_t *ws, FILE *stream)
210 {
211 wxCharBuffer buf(wxConvLibc.cWC2MB(ws));
212 if ( !buf )
213 return -1;
214
215 // counting the number of wide characters written isn't worth the trouble,
216 // simply distinguish between ok and error
217 return fputs(buf, stream) == -1 ? -1 : 0;
218 }
219 #endif // wxNEED_FPUTS
220
221 #ifdef wxNEED_PUTS
222 int wxPuts(const wxChar *ws)
223 {
224 int rc = wxFputs(ws, stdout);
225 if ( rc != -1 )
226 {
227 if ( wxFputs(L"\n", stdout) == -1 )
228 return -1;
229
230 rc++;
231 }
232
233 return rc;
234 }
235 #endif // wxNEED_PUTS
236
237 #ifdef wxNEED_PUTC
238 int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
239 {
240 wchar_t ws[2] = { wc, L'\0' };
241
242 return wxFputs(ws, stream);
243 }
244 #endif // wxNEED_PUTC
245
246 // NB: we only implement va_list functions here, the ones taking ... are
247 // defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
248 // the definitions there to avoid duplicating them here
249 #ifdef wxNEED_WPRINTF
250
251 // TODO: implement the scanf() functions
252 int vwscanf(const wxChar *format, va_list argptr)
253 {
254 wxFAIL_MSG( _T("TODO") );
255
256 return -1;
257 }
258
259 int vswscanf(const wxChar *ws, const wxChar *format, va_list argptr)
260 {
261 // The best we can do without proper Unicode support in glibc is to
262 // convert the strings into MB representation and run ANSI version
263 // of the function. This doesn't work with %c and %s because of difference
264 // in size of char and wchar_t, though.
265
266 wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
267 _T("incomplete vswscanf implementation doesn't allow %s") );
268 wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
269 _T("incomplete vswscanf implementation doesn't allow %c") );
270
271 va_list argcopy;
272 wxVaCopy(argcopy, argptr);
273 return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argcopy);
274 }
275
276 int vfwscanf(FILE *stream, const wxChar *format, va_list argptr)
277 {
278 wxFAIL_MSG( _T("TODO") );
279
280 return -1;
281 }
282
283 #define vswprintf wxVsnprintf_
284
285 int vfwprintf(FILE *stream, const wxChar *format, va_list argptr)
286 {
287 wxString s;
288 int rc = s.PrintfV(format, argptr);
289
290 if ( rc != -1 )
291 {
292 // we can't do much better without Unicode support in libc...
293 if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )
294 return -1;
295 }
296
297 return rc;
298 }
299
300 int vwprintf(const wxChar *format, va_list argptr)
301 {
302 return wxVfprintf(stdout, format, argptr);
303 }
304
305 #endif // wxNEED_WPRINTF
306
307 #ifdef wxNEED_PRINTF_CONVERSION
308
309 // ----------------------------------------------------------------------------
310 // wxFormatConverter: class doing the "%s" -> "%ls" conversion
311 // ----------------------------------------------------------------------------
312
313 /*
314 Here are the gory details. We want to follow the Windows/MS conventions,
315 that is to have
316
317 In ANSI mode:
318
319 format specifier results in
320 -----------------------------------
321 %c, %hc, %hC char
322 %lc, %C, %lC wchar_t
323
324 In Unicode mode:
325
326 format specifier results in
327 -----------------------------------
328 %hc, %C, %hC char
329 %c, %lc, %lC wchar_t
330
331
332 while on POSIX systems we have %C identical to %lc and %c always means char
333 (in any mode) while %lc always means wchar_t,
334
335 So to use native functions in order to get our semantics we must do the
336 following translations in Unicode mode (nothing to do in ANSI mode):
337
338 wxWidgets specifier POSIX specifier
339 ----------------------------------------
340
341 %hc, %C, %hC %c
342 %c %lc
343
344
345 And, of course, the same should be done for %s as well.
346 */
347
348 class wxFormatConverter
349 {
350 public:
351 wxFormatConverter(const wxChar *format);
352
353 // notice that we only translated the string if m_fmtOrig == NULL (as set
354 // by CopyAllBefore()), otherwise we should simply use the original format
355 operator const wxChar *() const
356 { return m_fmtOrig ? m_fmtOrig : m_fmt.c_str(); }
357
358 private:
359 // copy another character to the translated format: this function does the
360 // copy if we are translating but doesn't do anything at all if we don't,
361 // so we don't create the translated format string at all unless we really
362 // need to (i.e. InsertFmtChar() is called)
363 wxChar CopyFmtChar(wxChar ch)
364 {
365 if ( !m_fmtOrig )
366 {
367 // we're translating, do copy
368 m_fmt += ch;
369 }
370 else
371 {
372 // simply increase the count which should be copied by
373 // CopyAllBefore() later if needed
374 m_nCopied++;
375 }
376
377 return ch;
378 }
379
380 // insert an extra character
381 void InsertFmtChar(wxChar ch)
382 {
383 if ( m_fmtOrig )
384 {
385 // so far we haven't translated anything yet
386 CopyAllBefore();
387 }
388
389 m_fmt += ch;
390 }
391
392 void CopyAllBefore()
393 {
394 wxASSERT_MSG( m_fmtOrig && m_fmt.empty(), _T("logic error") );
395
396 m_fmt = wxString(m_fmtOrig, m_nCopied);
397
398 // we won't need it any longer
399 m_fmtOrig = NULL;
400 }
401
402 static bool IsFlagChar(wxChar ch)
403 {
404 return ch == _T('-') || ch == _T('+') ||
405 ch == _T('0') || ch == _T(' ') || ch == _T('#');
406 }
407
408 void SkipDigits(const wxChar **ptpc)
409 {
410 while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
411 CopyFmtChar(*(*ptpc)++);
412 }
413
414 // the translated format
415 wxString m_fmt;
416
417 // the original format
418 const wxChar *m_fmtOrig;
419
420 // the number of characters already copied
421 size_t m_nCopied;
422 };
423
424 wxFormatConverter::wxFormatConverter(const wxChar *format)
425 {
426 m_fmtOrig = format;
427 m_nCopied = 0;
428
429 while ( *format )
430 {
431 if ( CopyFmtChar(*format++) == _T('%') )
432 {
433 // skip any flags
434 while ( IsFlagChar(*format) )
435 CopyFmtChar(*format++);
436
437 // and possible width
438 if ( *format == _T('*') )
439 CopyFmtChar(*format++);
440 else
441 SkipDigits(&format);
442
443 // precision?
444 if ( *format == _T('.') )
445 {
446 CopyFmtChar(*format++);
447 if ( *format == _T('*') )
448 CopyFmtChar(*format++);
449 else
450 SkipDigits(&format);
451 }
452
453 // next we can have a size modifier
454 enum
455 {
456 Default,
457 Short,
458 Long
459 } size;
460
461 switch ( *format )
462 {
463 case _T('h'):
464 size = Short;
465 format++;
466 break;
467
468 case _T('l'):
469 // "ll" has a different meaning!
470 if ( format[1] != _T('l') )
471 {
472 size = Long;
473 format++;
474 break;
475 }
476 //else: fall through
477
478 default:
479 size = Default;
480 }
481
482 // and finally we should have the type
483 switch ( *format )
484 {
485 case _T('C'):
486 case _T('S'):
487 // %C and %hC -> %c and %lC -> %lc
488 if ( size == Long )
489 CopyFmtChar(_T('l'));
490
491 InsertFmtChar(*format++ == _T('C') ? _T('c') : _T('s'));
492 break;
493
494 case _T('c'):
495 case _T('s'):
496 // %c -> %lc but %hc stays %hc and %lc is still %lc
497 if ( size == Default)
498 InsertFmtChar(_T('l'));
499 // fall through
500
501 default:
502 // nothing special to do
503 if ( size != Default )
504 CopyFmtChar(*(format - 1));
505 CopyFmtChar(*format++);
506 }
507 }
508 }
509 }
510
511 #else // !wxNEED_PRINTF_CONVERSION
512 // no conversion necessary
513 #define wxFormatConverter(x) (x)
514 #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
515
516 #ifdef __WXDEBUG__
517 // For testing the format converter
518 wxString wxConvertFormat(const wxChar *format)
519 {
520 return wxString(wxFormatConverter(format));
521 }
522 #endif
523
524 // ----------------------------------------------------------------------------
525 // wxPrintf(), wxScanf() and relatives
526 // ----------------------------------------------------------------------------
527
528 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
529
530 int wxDoScanf( const wxChar *format, ... )
531 {
532 va_list argptr;
533 va_start(argptr, format);
534
535 int ret = vwscanf(wxFormatConverter(format), argptr );
536
537 va_end(argptr);
538
539 return ret;
540 }
541
542 int wxDoSscanf( const wxChar *str, const wxChar *format, ... )
543 {
544 va_list argptr;
545 va_start(argptr, format);
546
547 int ret = vswscanf( str, wxFormatConverter(format), argptr );
548
549 va_end(argptr);
550
551 return ret;
552 }
553
554 int wxDoFscanf( FILE *stream, const wxChar *format, ... )
555 {
556 va_list argptr;
557 va_start(argptr, format);
558 int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
559
560 va_end(argptr);
561
562 return ret;
563 }
564
565 int wxDoPrintf( const wxChar *format, ... )
566 {
567 va_list argptr;
568 va_start(argptr, format);
569
570 int ret = vwprintf( wxFormatConverter(format), argptr );
571
572 va_end(argptr);
573
574 return ret;
575 }
576
577 #ifndef wxSnprintf
578 int wxDoSnprintf( wxChar *str, size_t size, const wxChar *format, ... )
579 {
580 va_list argptr;
581 va_start(argptr, format);
582
583 int ret = vswprintf( str, size, wxFormatConverter(format), argptr );
584
585 // VsnprintfTestCase reveals that glibc's implementation of vswprintf
586 // doesn't nul terminate on truncation.
587 str[size - 1] = 0;
588
589 va_end(argptr);
590
591 return ret;
592 }
593 #endif // wxSnprintf
594
595 int wxDoSprintf( wxChar *str, const wxChar *format, ... )
596 {
597 va_list argptr;
598 va_start(argptr, format);
599
600 // note that wxString::FormatV() uses wxVsnprintf(), not wxSprintf(), so
601 // it's safe to implement this one in terms of it
602 wxString s(wxString::FormatV(format, argptr));
603 wxStrcpy(str, s);
604
605 va_end(argptr);
606
607 return s.length();
608 }
609
610 int wxDoFprintf( FILE *stream, const wxChar *format, ... )
611 {
612 va_list argptr;
613 va_start( argptr, format );
614
615 int ret = vfwprintf( stream, wxFormatConverter(format), argptr );
616
617 va_end(argptr);
618
619 return ret;
620 }
621
622 int wxVsscanf( const wxChar *str, const wxChar *format, va_list argptr )
623 {
624 return vswscanf( str, wxFormatConverter(format), argptr );
625 }
626
627 int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr )
628 {
629 return vfwprintf( stream, wxFormatConverter(format), argptr );
630 }
631
632 int wxVprintf( const wxChar *format, va_list argptr )
633 {
634 return vwprintf( wxFormatConverter(format), argptr );
635 }
636
637 #ifndef wxVsnprintf
638 int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr )
639 {
640 return vswprintf( str, size, wxFormatConverter(format), argptr );
641 }
642 #endif // wxVsnprintf
643
644 int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
645 {
646 // same as for wxSprintf()
647 return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);
648 }
649
650 #endif // wxNEED_PRINTF_CONVERSION
651
652 #if wxUSE_WCHAR_T
653
654 // ----------------------------------------------------------------------------
655 // ctype.h stuff (currently unused)
656 // ----------------------------------------------------------------------------
657
658 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
659 inline WORD wxMSW_ctype(wxChar ch)
660 {
661 WORD ret;
662 GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, &ch, 1, &ret);
663 return ret;
664 }
665
666 WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
667 WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }
668 WXDLLEXPORT int wxIscntrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
669 WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
670 WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
671 WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }
672 WXDLLEXPORT int wxIsprint(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_SPACE|C1_PUNCT|C1_ALPHA); }
673 WXDLLEXPORT int wxIspunct(wxChar ch) { return wxMSW_ctype(ch) & C1_PUNCT; }
674 WXDLLEXPORT int wxIsspace(wxChar ch) { return wxMSW_ctype(ch) & C1_SPACE; }
675 WXDLLEXPORT int wxIsupper(wxChar ch) { return IsCharUpper(ch); }
676 WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_XDIGIT; }
677 WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
678 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
679 #endif
680
681 #ifdef wxNEED_WX_MBSTOWCS
682
683 WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
684 {
685 if (!out)
686 {
687 size_t outsize = 0;
688 while(*in++)
689 outsize++;
690 return outsize;
691 }
692
693 const char* origin = in;
694
695 while (outlen-- && *in)
696 {
697 *out++ = (wchar_t) *in++;
698 }
699
700 *out = '\0';
701
702 return in - origin;
703 }
704
705 WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
706 {
707 if (!out)
708 {
709 size_t outsize = 0;
710 while(*in++)
711 outsize++;
712 return outsize;
713 }
714
715 const wchar_t* origin = in;
716
717 while (outlen-- && *in)
718 {
719 *out++ = (char) *in++;
720 }
721
722 *out = '\0';
723
724 return in - origin;
725 }
726
727 #endif // wxNEED_WX_MBSTOWCS
728
729 #if defined(wxNEED_WX_CTYPE_H)
730
731 #include <CoreFoundation/CoreFoundation.h>
732
733 #define cfalnumset CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric)
734 #define cfalphaset CFCharacterSetGetPredefined(kCFCharacterSetLetter)
735 #define cfcntrlset CFCharacterSetGetPredefined(kCFCharacterSetControl)
736 #define cfdigitset CFCharacterSetGetPredefined(kCFCharacterSetDecimalDigit)
737 //CFCharacterSetRef cfgraphset = kCFCharacterSetControl && !' '
738 #define cflowerset CFCharacterSetGetPredefined(kCFCharacterSetLowercaseLetter)
739 //CFCharacterSetRef cfprintset = !kCFCharacterSetControl
740 #define cfpunctset CFCharacterSetGetPredefined(kCFCharacterSetPunctuation)
741 #define cfspaceset CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline)
742 #define cfupperset CFCharacterSetGetPredefined(kCFCharacterSetUppercaseLetter)
743
744 WXDLLEXPORT int wxIsalnum(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalnumset, ch); }
745 WXDLLEXPORT int wxIsalpha(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalphaset, ch); }
746 WXDLLEXPORT int wxIscntrl(wxChar ch) { return CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
747 WXDLLEXPORT int wxIsdigit(wxChar ch) { return CFCharacterSetIsCharacterMember(cfdigitset, ch); }
748 WXDLLEXPORT int wxIsgraph(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch) && ch != ' '; }
749 WXDLLEXPORT int wxIslower(wxChar ch) { return CFCharacterSetIsCharacterMember(cflowerset, ch); }
750 WXDLLEXPORT int wxIsprint(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
751 WXDLLEXPORT int wxIspunct(wxChar ch) { return CFCharacterSetIsCharacterMember(cfpunctset, ch); }
752 WXDLLEXPORT int wxIsspace(wxChar ch) { return CFCharacterSetIsCharacterMember(cfspaceset, ch); }
753 WXDLLEXPORT int wxIsupper(wxChar ch) { return CFCharacterSetIsCharacterMember(cfupperset, ch); }
754 WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxIsdigit(ch) || (ch>='a' && ch<='f') || (ch>='A' && ch<='F'); }
755 WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)tolower((char)(ch)); }
756 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)toupper((char)(ch)); }
757
758 #endif // wxNEED_WX_CTYPE_H
759
760 #ifndef wxStrdupA
761
762 WXDLLEXPORT char *wxStrdupA(const char *s)
763 {
764 return strcpy((char *)malloc(strlen(s) + 1), s);
765 }
766
767 #endif // wxStrdupA
768
769 #ifndef wxStrdupW
770
771 WXDLLEXPORT wchar_t * wxStrdupW(const wchar_t *pwz)
772 {
773 size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
774 wchar_t *ret = (wchar_t *) malloc(size);
775 memcpy(ret, pwz, size);
776 return ret;
777 }
778
779 #endif // wxStrdupW
780
781 #ifndef wxStricmp
782 int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
783 {
784 register wxChar c1, c2;
785 do {
786 c1 = wxTolower(*psz1++);
787 c2 = wxTolower(*psz2++);
788 } while ( c1 && (c1 == c2) );
789 return c1 - c2;
790 }
791 #endif
792
793 #ifndef wxStricmp
794 int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
795 {
796 // initialize the variables just to suppress stupid gcc warning
797 register wxChar c1 = 0, c2 = 0;
798 while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
799 if (n) {
800 if (c1 < c2) return -1;
801 if (c1 > c2) return 1;
802 }
803 return 0;
804 }
805 #endif
806
807 #ifndef wxSetlocale_
808 wxWCharBuffer wxSetlocale_(int category, const wxChar *locale)
809 {
810 char *localeOld = setlocale(category, wxConvLibc.cWX2MB(locale));
811
812 return wxWCharBuffer(wxConvLibc.cMB2WC(localeOld));
813 }
814
815 wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
816 {
817 wxWCharBuffer rv = wxSetlocale_(category, locale);
818 if ( rv )
819 wxUpdateLocaleIsUtf8();
820 return rv;
821 }
822 #else // defined(wxSetlocale_)
823 const wxChar *wxSetlocale(int category, const wxChar *locale)
824 {
825 const wxChar *rv = wxSetlocale_(category, locale);
826 if ( rv )
827 wxUpdateLocaleIsUtf8();
828 return rv;
829 }
830 #endif // wxSetlocale_ defined or not
831
832 #if wxUSE_WCHAR_T && !defined(HAVE_WCSLEN)
833 WXDLLEXPORT size_t wxWcslen(const wchar_t *s)
834 {
835 size_t n = 0;
836 while ( *s++ )
837 n++;
838
839 return n;
840 }
841 #endif
842
843 // ----------------------------------------------------------------------------
844 // string.h functions
845 // ----------------------------------------------------------------------------
846
847 #ifdef wxNEED_WX_STRING_H
848
849 // RN: These need to be c externed for the regex lib
850 #ifdef __cplusplus
851 extern "C" {
852 #endif
853
854 WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src)
855 {
856 wxChar *ret = dest;
857 while (*dest) dest++;
858 while ((*dest++ = *src++));
859 return ret;
860 }
861
862 WXDLLEXPORT const wxChar * wxStrchr(const wxChar *s, wxChar c)
863 {
864 // be careful here as the terminating NUL makes part of the string
865 while ( *s != c )
866 {
867 if ( !*s++ )
868 return NULL;
869 }
870
871 return s;
872 }
873
874 WXDLLEXPORT int wxStrcmp(const wxChar *s1, const wxChar *s2)
875 {
876 while ((*s1 == *s2) && *s1) s1++, s2++;
877 if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
878 if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
879 return 0;
880 }
881
882 WXDLLEXPORT wxChar * wxStrcpy(wxChar *dest, const wxChar *src)
883 {
884 wxChar *ret = dest;
885 while ((*dest++ = *src++));
886 return ret;
887 }
888
889 WXDLLEXPORT size_t wxStrlen_(const wxChar *s)
890 {
891 size_t n = 0;
892 while ( *s++ )
893 n++;
894
895 return n;
896 }
897
898
899 WXDLLEXPORT wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n)
900 {
901 wxChar *ret = dest;
902 while (*dest) dest++;
903 while (n && (*dest++ = *src++)) n--;
904 return ret;
905 }
906
907 WXDLLEXPORT int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n)
908 {
909 while (n && (*s1 == *s2) && *s1) n--, s1++, s2++;
910 if (n) {
911 if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
912 if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
913 }
914 return 0;
915 }
916
917 WXDLLEXPORT wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n)
918 {
919 wxChar *ret = dest;
920 while (n && (*dest++ = *src++)) n--;
921 while (n) *dest++=0, n--; // the docs specify padding with zeroes
922 return ret;
923 }
924
925 WXDLLEXPORT const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept)
926 {
927 while (*s && !wxStrchr(accept, *s))
928 s++;
929
930 return *s ? s : NULL;
931 }
932
933 WXDLLEXPORT const wxChar * wxStrrchr(const wxChar *s, wxChar c)
934 {
935 const wxChar *ret = NULL;
936 do
937 {
938 if ( *s == c )
939 ret = s;
940 s++;
941 }
942 while ( *s );
943
944 return ret;
945 }
946
947 WXDLLEXPORT size_t wxStrspn(const wxChar *s, const wxChar *accept)
948 {
949 size_t len = 0;
950 while (wxStrchr(accept, *s++)) len++;
951 return len;
952 }
953
954 WXDLLEXPORT const wxChar *wxStrstr(const wxChar *haystack, const wxChar *needle)
955 {
956 wxASSERT_MSG( needle != NULL, _T("NULL argument in wxStrstr") );
957
958 // VZ: this is not exactly the most efficient string search algorithm...
959
960 const size_t len = wxStrlen(needle);
961
962 while ( const wxChar *fnd = wxStrchr(haystack, *needle) )
963 {
964 if ( !wxStrncmp(fnd, needle, len) )
965 return fnd;
966
967 haystack = fnd + 1;
968 }
969
970 return NULL;
971 }
972
973 #ifdef __cplusplus
974 }
975 #endif
976
977 WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr)
978 {
979 const wxChar *start = nptr;
980
981 // FIXME: only correct for C locale
982 while (wxIsspace(*nptr)) nptr++;
983 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
984 while (wxIsdigit(*nptr)) nptr++;
985 if (*nptr == wxT('.')) {
986 nptr++;
987 while (wxIsdigit(*nptr)) nptr++;
988 }
989 if (*nptr == wxT('E') || *nptr == wxT('e')) {
990 nptr++;
991 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
992 while (wxIsdigit(*nptr)) nptr++;
993 }
994
995 wxString data(nptr, nptr-start);
996 wxWX2MBbuf dat = data.mb_str(wxConvLibc);
997 char *rdat = wxMBSTRINGCAST dat;
998 double ret = strtod(dat, &rdat);
999
1000 if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
1001
1002 return ret;
1003 }
1004
1005 WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
1006 {
1007 const wxChar *start = nptr;
1008
1009 // FIXME: only correct for C locale
1010 while (wxIsspace(*nptr)) nptr++;
1011 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
1012 if (((base == 0) || (base == 16)) &&
1013 (nptr[0] == wxT('0') && nptr[1] == wxT('x'))) {
1014 nptr += 2;
1015 base = 16;
1016 }
1017 else if ((base == 0) && (nptr[0] == wxT('0'))) base = 8;
1018 else if (base == 0) base = 10;
1019
1020 while ((wxIsdigit(*nptr) && (*nptr - wxT('0') < base)) ||
1021 (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
1022
1023 wxString data(start, nptr-start);
1024 wxWX2MBbuf dat = data.mb_str(wxConvLibc);
1025 char *rdat = wxMBSTRINGCAST dat;
1026 long int ret = strtol(dat, &rdat, base);
1027
1028 if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
1029
1030 return ret;
1031 }
1032
1033 WXDLLEXPORT unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base)
1034 {
1035 return (unsigned long int) wxStrtol(nptr, endptr, base);
1036 }
1037
1038 #endif // wxNEED_WX_STRING_H
1039
1040 #ifdef wxNEED_WX_STDIO_H
1041 WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
1042 {
1043 char mode_buffer[10];
1044 for (size_t i = 0; i < wxStrlen(mode)+1; i++)
1045 mode_buffer[i] = (char) mode[i];
1046
1047 return fopen( wxConvFile.cWX2MB(path), mode_buffer );
1048 }
1049
1050 WXDLLEXPORT FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream)
1051 {
1052 char mode_buffer[10];
1053 for (size_t i = 0; i < wxStrlen(mode)+1; i++)
1054 mode_buffer[i] = (char) mode[i];
1055
1056 return freopen( wxConvFile.cWX2MB(path), mode_buffer, stream );
1057 }
1058
1059 WXDLLEXPORT int wxRemove(const wxChar *path)
1060 {
1061 return remove( wxConvFile.cWX2MB(path) );
1062 }
1063
1064 WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
1065 {
1066 return rename( wxConvFile.cWX2MB(oldpath), wxConvFile.cWX2MB(newpath) );
1067 }
1068 #endif
1069
1070 #ifndef wxAtof
1071 double WXDLLEXPORT wxAtof(const wxChar *psz)
1072 {
1073 #ifdef __WXWINCE__
1074 double d;
1075 wxString str(psz);
1076 if (str.ToDouble(& d))
1077 return d;
1078
1079 return 0.0;
1080 #else
1081 return atof(wxConvLibc.cWX2MB(psz));
1082 #endif
1083 }
1084 #endif
1085
1086 #ifdef wxNEED_WX_STDLIB_H
1087 int WXDLLEXPORT wxAtoi(const wxChar *psz)
1088 {
1089 return atoi(wxConvLibc.cWX2MB(psz));
1090 }
1091
1092 long WXDLLEXPORT wxAtol(const wxChar *psz)
1093 {
1094 return atol(wxConvLibc.cWX2MB(psz));
1095 }
1096
1097 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
1098 {
1099 #if wxUSE_UNICODE
1100 // NB: buffer returned by getenv() is allowed to be overwritten next
1101 // time getenv() is called, so it is OK to use static string
1102 // buffer to hold the data.
1103 static wxWCharBuffer value((wxChar*)NULL);
1104 value = wxConvLibc.cMB2WX(getenv(wxConvLibc.cWX2MB(name)));
1105 return value.data();
1106 #else
1107 return getenv(name);
1108 #endif
1109 }
1110
1111 int WXDLLEXPORT wxSystem(const wxChar *psz)
1112 {
1113 return system(wxConvLibc.cWX2MB(psz));
1114 }
1115
1116 #endif // wxNEED_WX_STDLIB_H
1117
1118 #ifdef wxNEED_WX_TIME_H
1119 WXDLLEXPORT size_t
1120 wxStrftime(wxChar *s, size_t maxsize, const wxChar *fmt, const struct tm *tm)
1121 {
1122 if ( !maxsize )
1123 return 0;
1124
1125 wxCharBuffer buf(maxsize);
1126
1127 wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt));
1128 if ( !bufFmt )
1129 return 0;
1130
1131 size_t ret = strftime(buf.data(), maxsize, bufFmt, tm);
1132 if ( !ret )
1133 return 0;
1134
1135 wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf);
1136 if ( !wbuf )
1137 return 0;
1138
1139 wxStrncpy(s, wbuf, maxsize);
1140 return wxStrlen(s);
1141 }
1142 #endif // wxNEED_WX_TIME_H
1143
1144 #ifndef wxCtime
1145 WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
1146 {
1147 // normally the string is 26 chars but give one more in case some broken
1148 // DOS compiler decides to use "\r\n" instead of "\n" at the end
1149 static wxChar buf[27];
1150
1151 // ctime() is guaranteed to return a string containing only ASCII
1152 // characters, as its format is always the same for any locale
1153 wxStrncpy(buf, wxString::FromAscii(ctime(timep)), WXSIZEOF(buf));
1154 buf[WXSIZEOF(buf) - 1] = _T('\0');
1155
1156 return buf;
1157 }
1158 #endif // wxCtime
1159
1160 #endif // wxUSE_WCHAR_T
1161
1162 #ifndef wxStrtoll
1163 static wxULongLong_t wxStrtoullBase(const wxChar* nptr, wxChar** endptr, int base, wxChar* sign)
1164 {
1165 wxULongLong_t sum = 0;
1166 wxString wxstr(nptr);
1167 wxString::const_iterator i = wxstr.begin();
1168 wxString::const_iterator end = wxstr.end();
1169
1170 // Skip spaces
1171 while ( i != end && wxIsspace(*i) ) i++;
1172
1173 // Starts with sign?
1174 *sign = wxT(' ');
1175 if ( i != end )
1176 {
1177 wxChar c = *i;
1178 if ( c == wxT('+') || c == wxT('-') )
1179 {
1180 *sign = c;
1181 i++;
1182 }
1183 }
1184
1185 // Starts with 0x?
1186 if ( i != end && *i == wxT('0') )
1187 {
1188 i++;
1189 if ( i != end )
1190 {
1191 if ( *i == wxT('x') && (base == 16 || base == 0) )
1192 {
1193 base = 16;
1194 i++;
1195 }
1196 else
1197 {
1198 if ( endptr )
1199 *endptr = (wxChar*) nptr;
1200 wxSET_ERRNO(EINVAL);
1201 return sum;
1202 }
1203 }
1204 else
1205 i--;
1206 }
1207
1208 if ( base == 0 )
1209 base = 10;
1210
1211 for ( ; i != end; i++ )
1212 {
1213 unsigned int n;
1214
1215 wxChar c = *i;
1216 if ( c >= wxT('0') )
1217 {
1218 if ( c <= wxT('9') )
1219 n = c - wxT('0');
1220 else
1221 n = wxTolower(c) - wxT('a') + 10;
1222 }
1223 else
1224 break;
1225
1226 if ( n >= (unsigned int)base )
1227 // Invalid character (for this base)
1228 break;
1229
1230 wxULongLong_t prevsum = sum;
1231 sum = (sum * base) + n;
1232
1233 if ( sum < prevsum )
1234 {
1235 wxSET_ERRNO(ERANGE);
1236 break;
1237 }
1238 }
1239
1240 if ( endptr )
1241 {
1242 const wxChar& endref = *i;
1243 *endptr = &(wxChar&)endref;
1244 }
1245
1246 return sum;
1247 }
1248
1249 wxULongLong_t wxStrtoull(const wxChar* nptr, wxChar** endptr, int base)
1250 {
1251 wxChar sign;
1252 wxULongLong_t uval = wxStrtoullBase(nptr, endptr, base, &sign);
1253
1254 if ( sign == wxT('-') )
1255 {
1256 wxSET_ERRNO(ERANGE);
1257 uval = 0;
1258 }
1259
1260 return uval;
1261 }
1262
1263 wxLongLong_t wxStrtoll(const wxChar* nptr, wxChar** endptr, int base)
1264 {
1265 wxChar sign;
1266 wxULongLong_t uval = wxStrtoullBase(nptr, endptr, base, &sign);
1267 wxLongLong_t val = 0;
1268
1269 if ( sign == wxT('-') )
1270 {
1271 if ( uval <= wxULL(wxINT64_MAX+1) )
1272 {
1273 if ( uval == wxULL(wxINT64_MAX+1))
1274 val = -((wxLongLong_t)wxINT64_MAX) - 1;
1275 else
1276 val = -((wxLongLong_t)uval);
1277 }
1278 else
1279 {
1280 wxSET_ERRNO(ERANGE);
1281 }
1282 }
1283 else if ( uval <= wxINT64_MAX )
1284 {
1285 val = uval;
1286 }
1287 else
1288 {
1289 wxSET_ERRNO(ERANGE);
1290 }
1291
1292 return val;
1293 }
1294 #endif // wxStrtoll
1295
1296 // ----------------------------------------------------------------------------
1297 // functions which we may need even if !wxUSE_WCHAR_T
1298 // ----------------------------------------------------------------------------
1299
1300 #ifndef wxStrtok
1301
1302 WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
1303 {
1304 if (!psz)
1305 {
1306 psz = *save_ptr;
1307 if ( !psz )
1308 return NULL;
1309 }
1310
1311 psz += wxStrspn(psz, delim);
1312 if (!*psz)
1313 {
1314 *save_ptr = (wxChar *)NULL;
1315 return (wxChar *)NULL;
1316 }
1317
1318 wxChar *ret = psz;
1319 psz = wxStrpbrk(psz, delim);
1320 if (!psz)
1321 {
1322 *save_ptr = (wxChar*)NULL;
1323 }
1324 else
1325 {
1326 *psz = wxT('\0');
1327 *save_ptr = psz + 1;
1328 }
1329
1330 return ret;
1331 }
1332
1333 #endif // wxStrtok
1334
1335 // ----------------------------------------------------------------------------
1336 // missing C RTL functions
1337 // ----------------------------------------------------------------------------
1338
1339 #ifdef wxNEED_STRDUP
1340
1341 char *strdup(const char *s)
1342 {
1343 char *dest = (char*) malloc( strlen( s ) + 1 ) ;
1344 if ( dest )
1345 strcpy( dest , s ) ;
1346 return dest ;
1347 }
1348 #endif // wxNEED_STRDUP
1349
1350 #if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
1351
1352 void *calloc( size_t num, size_t size )
1353 {
1354 void** ptr = (void **)malloc(num * size);
1355 memset( ptr, 0, num * size);
1356 return ptr;
1357 }
1358
1359 #endif // __WXWINCE__ <= 211
1360
1361 #ifdef __WXWINCE__
1362
1363 int wxRemove(const wxChar *path)
1364 {
1365 return ::DeleteFile(path) == 0;
1366 }
1367
1368 #endif
1369
1370
1371 // ----------------------------------------------------------------------------
1372 // wxLocaleIsUtf8
1373 // ----------------------------------------------------------------------------
1374
1375 #if wxUSE_UNICODE_UTF8
1376
1377 #if !wxUSE_UTF8_LOCALE_ONLY
1378 bool wxLocaleIsUtf8 = false; // the safer setting if not known
1379 #endif
1380
1381 static bool wxIsLocaleUtf8()
1382 {
1383 // NB: we intentionally don't use wxLocale::GetSystemEncodingName(),
1384 // because a) it may be unavailable in some builds and b) has slightly
1385 // different semantics (default locale instead of current)
1386
1387 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
1388 // GNU libc provides current character set this way (this conforms to
1389 // Unix98)
1390 const char *charset = nl_langinfo(CODESET);
1391 if ( charset )
1392 {
1393 // "UTF-8" is used by modern glibc versions, but test other variants
1394 // as well, just in case:
1395 return strcmp(charset, "UTF-8") == 0 ||
1396 strcmp(charset, "utf-8") == 0 ||
1397 strcmp(charset, "UTF8") == 0 ||
1398 strcmp(charset, "utf8") == 0;
1399 }
1400 else // nl_langinfo() failed
1401 #endif
1402 {
1403 // we don't know what charset libc is using, so assume the worst
1404 // to be safe:
1405 return false;
1406 }
1407 }
1408
1409 void wxUpdateLocaleIsUtf8()
1410 {
1411 #if wxUSE_UTF8_LOCALE_ONLY
1412 if ( !wxIsLocaleUtf8() )
1413 {
1414 wxLogFatalError(_T("This program requires UTF-8 locale to run."));
1415 }
1416 #else // !wxUSE_UTF8_LOCALE_ONLY
1417 wxLocaleIsUtf8 = wxIsLocaleUtf8();
1418 #endif
1419 }
1420
1421 #endif // wxUSE_UTF8_LOCALE_ONLY
wxWidgets (Impactor)