1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/wxcrt.cpp
3 // Purpose: wxChar CRT wrappers implementation
5 // Modified by: Ron Lee, Francesco Montorsi
8 // Copyright: (c) wxWidgets copyright
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
13 // headers, declarations, constants
14 // ===========================================================================
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
24 #include "wx/strconv.h" // wxMBConv::cWC2MB()
26 #define _ISOC9X_SOURCE 1 // to get vsscanf()
27 #define _BSD_SOURCE 1 // to still get strdup()
38 #include "wx/msw/wince/time.h"
40 #endif // !__WXPALMOS5__
43 #include "wx/string.h"
45 #include "wx/utils.h" // for wxMin and wxMax
49 #ifdef HAVE_LANGINFO_H
54 // there is no errno.h under CE apparently
55 #define wxSET_ERRNO(value)
59 #define wxSET_ERRNO(value) errno = value
62 #if defined(__MWERKS__) && __MSL__ >= 0x6000
67 #if defined(__DARWIN__)
68 #include "wx/osx/core/cfref.h"
69 #include <CoreFoundation/CFLocale.h>
70 #include "wx/osx/core/cfstring.h"
75 WXDLLIMPEXP_BASE
size_t wxMB2WC(wchar_t *buf
, const char *psz
, size_t n
)
77 // assume that we have mbsrtowcs() too if we have wcsrtombs()
80 memset(&mbstate
, 0, sizeof(mbstate_t));
85 if (n
) *buf
= wxT('\0');
89 return mbsrtowcs(buf
, &psz
, n
, &mbstate
);
91 return wxMbstowcs(buf
, psz
, n
);
95 // note that we rely on common (and required by Unix98 but unfortunately not
96 // C99) extension which allows to call mbs(r)towcs() with NULL output pointer
97 // to just get the size of the needed buffer -- this is needed as otherwise
98 // we have no idea about how much space we need and if the CRT doesn't
99 // support it (the only currently known example being Metrowerks, see
100 // wx/crt.h) we don't use its mbstowcs() at all
101 #ifdef HAVE_WCSRTOMBS
102 return mbsrtowcs((wchar_t *) NULL
, &psz
, 0, &mbstate
);
104 return wxMbstowcs((wchar_t *) NULL
, psz
, 0);
108 WXDLLIMPEXP_BASE
size_t wxWC2MB(char *buf
, const wchar_t *pwz
, size_t n
)
110 #ifdef HAVE_WCSRTOMBS
112 memset(&mbstate
, 0, sizeof(mbstate_t));
117 // glibc2.1 chokes on null input
121 #ifdef HAVE_WCSRTOMBS
122 return wcsrtombs(buf
, &pwz
, n
, &mbstate
);
124 return wxWcstombs(buf
, pwz
, n
);
128 #ifdef HAVE_WCSRTOMBS
129 return wcsrtombs((char *) NULL
, &pwz
, 0, &mbstate
);
131 return wxWcstombs((char *) NULL
, pwz
, 0);
134 #endif // wxUSE_WCHAR_T
136 char* wxSetlocale(int category
, const char *locale
)
139 // FIXME-CE: there is no setlocale() in CE CRT, use SetThreadLocale()?
140 wxUnusedVar(category
);
144 #else // !__WXWINCE__
147 if ( locale
!= NULL
&& locale
[0] == 0 )
149 // the attempt to use newlocale(LC_ALL_MASK, "", NULL);
150 // here in order to deduce the language along the environment vars rules
151 // lead to strange crashes later...
153 // we have to emulate the behaviour under OS X
154 wxCFRef
<CFLocaleRef
> userLocaleRef(CFLocaleCopyCurrent());
155 wxCFStringRef
str(wxCFRetain((CFStringRef
)CFLocaleGetValue(userLocaleRef
, kCFLocaleLanguageCode
)));
156 wxString langFull
= str
.AsString()+"_";
157 str
.reset(wxCFRetain((CFStringRef
)CFLocaleGetValue(userLocaleRef
, kCFLocaleCountryCode
)));
158 langFull
+= str
.AsString();
159 rv
= setlocale(category
, langFull
.c_str());
162 rv
= setlocale(category
, locale
);
164 char *rv
= setlocale(category
, locale
);
166 if ( locale
!= NULL
/* setting locale, not querying */ &&
167 rv
/* call was successful */ )
169 wxUpdateLocaleIsUtf8();
172 #endif // __WXWINCE__/!__WXWINCE__
175 // ============================================================================
176 // printf() functions business
177 // ============================================================================
179 // special test mode: define all functions below even if we don't really need
180 // them to be able to test them
190 #define wxNEED_WPRINTF
192 int wxCRT_VfprintfW( FILE *stream
, const wchar_t *format
, va_list argptr
);
196 /* Digital Mars adds count to _stprintf (C99) so convert */
197 int wxCRT_SprintfW (wchar_t * __RESTRICT s
, const wchar_t * __RESTRICT format
, ... )
201 va_start( arglist
, format
);
202 int iLen
= swprintf ( s
, -1, format
, arglist
);
208 // ----------------------------------------------------------------------------
209 // implement the standard IO functions for wide char if libc doesn't have them
210 // ----------------------------------------------------------------------------
213 int wxCRT_FputsW(const wchar_t *ws
, FILE *stream
)
215 wxCharBuffer
buf(wxConvLibc
.cWC2MB(ws
));
219 // counting the number of wide characters written isn't worth the trouble,
220 // simply distinguish between ok and error
221 return wxCRT_FputsA(buf
, stream
) == -1 ? -1 : 0;
223 #endif // !wxCRT_FputsW
226 int wxCRT_PutsW(const wchar_t *ws
)
228 int rc
= wxCRT_FputsW(ws
, stdout
);
231 if ( wxCRT_FputsW(L
"\n", stdout
) == -1 )
239 #endif // !wxCRT_PutsW
242 int /* not wint_t */ wxCRT_FputcW(wchar_t wc
, FILE *stream
)
244 wchar_t ws
[2] = { wc
, L
'\0' };
246 return wxCRT_FputsW(ws
, stream
);
248 #endif // !wxCRT_FputcW
250 // NB: we only implement va_list functions here, the ones taking ... are
251 // defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
252 // the definitions there to avoid duplicating them here
253 #ifdef wxNEED_WPRINTF
255 // TODO: implement the scanf() functions
256 static int vwscanf(const wchar_t *format
, va_list argptr
)
258 wxFAIL_MSG( _T("TODO") );
263 static int vfwscanf(FILE *stream
, const wchar_t *format
, va_list argptr
)
265 wxFAIL_MSG( _T("TODO") );
270 #define vswprintf wxCRT_VsnprintfW
272 static int vfwprintf(FILE *stream
, const wchar_t *format
, va_list argptr
)
275 int rc
= s
.PrintfV(format
, argptr
);
279 // we can't do much better without Unicode support in libc...
280 if ( fprintf(stream
, "%s", (const char*)s
.mb_str() ) == -1 )
287 static int vwprintf(const wchar_t *format
, va_list argptr
)
289 return wxCRT_VfprintfW(stdout
, format
, argptr
);
292 #endif // wxNEED_WPRINTF
294 #ifdef wxNEED_VSWSCANF
295 static int vswscanf(const wchar_t *ws
, const wchar_t *format
, va_list argptr
)
297 // The best we can do without proper Unicode support in glibc is to
298 // convert the strings into MB representation and run ANSI version
299 // of the function. This doesn't work with %c and %s because of difference
300 // in size of char and wchar_t, though.
302 wxCHECK_MSG( wxStrstr(format
, _T("%s")) == NULL
, -1,
303 _T("incomplete vswscanf implementation doesn't allow %s") );
304 wxCHECK_MSG( wxStrstr(format
, _T("%c")) == NULL
, -1,
305 _T("incomplete vswscanf implementation doesn't allow %c") );
307 return vsscanf(wx_static_cast(const char*, wxConvLibc
.cWX2MB(ws
)),
308 wxConvLibc
.cWX2MB(format
), argptr
);
312 // ----------------------------------------------------------------------------
313 // wxPrintf(), wxScanf() and relatives
314 // ----------------------------------------------------------------------------
316 // FIXME-UTF8: do format conversion using (modified) wxFormatConverter in
317 // template wrappers, not here; note that it will needed to
318 // translate all forms of string specifiers to %(l)s for wxPrintf(),
319 // but it only should do what it did in 2.8 for wxScanf()!
321 #ifndef wxCRT_PrintfW
322 int wxCRT_PrintfW( const wchar_t *format
, ... )
325 va_start(argptr
, format
);
327 int ret
= vwprintf( format
, argptr
);
335 #ifndef wxCRT_FprintfW
336 int wxCRT_FprintfW( FILE *stream
, const wchar_t *format
, ... )
339 va_start( argptr
, format
);
341 int ret
= vfwprintf( stream
, format
, argptr
);
349 #ifndef wxCRT_VfprintfW
350 int wxCRT_VfprintfW( FILE *stream
, const wchar_t *format
, va_list argptr
)
352 return vfwprintf( stream
, format
, argptr
);
356 #ifndef wxCRT_VprintfW
357 int wxCRT_VprintfW( const wchar_t *format
, va_list argptr
)
359 return vwprintf( format
, argptr
);
363 #ifndef wxCRT_VsprintfW
364 int wxCRT_VsprintfW( wchar_t *str
, const wchar_t *format
, va_list argptr
)
366 // same as for wxSprintf()
367 return vswprintf(str
, INT_MAX
/ 4, format
, argptr
);
372 int wxCRT_ScanfW(const wchar_t *format
, ...)
375 va_start(argptr
, format
);
378 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
379 int ret
= std::vwscanf(format
, argptr
);
381 int ret
= vwscanf(format
, argptr
);
384 int ret
= vwscanf(format
, argptr
);
393 #ifndef wxCRT_SscanfW
394 int wxCRT_SscanfW(const wchar_t *str
, const wchar_t *format
, ...)
397 va_start(argptr
, format
);
400 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
401 int ret
= std::vswscanf(str
, format
, argptr
);
403 int ret
= vswscanf(str
, format
, argptr
);
406 int ret
= vswscanf(str
, format
, argptr
);
415 #ifndef wxCRT_FscanfW
416 int wxCRT_FscanfW(FILE *stream
, const wchar_t *format
, ...)
419 va_start(argptr
, format
);
421 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
422 int ret
= std::vfwscanf(stream
, format
, argptr
);
424 int ret
= vfwscanf(stream
, format
, argptr
);
427 int ret
= vfwscanf(stream
, format
, argptr
);
436 #ifndef wxCRT_VsscanfW
437 int wxCRT_VsscanfW(const wchar_t *str
, const wchar_t *format
, va_list argptr
)
440 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
441 return std::vswscanf(str
, format
, argptr
);
443 return vswscanf(str
, format
, argptr
);
446 return vswscanf(str
, format
, argptr
);
452 // ----------------------------------------------------------------------------
453 // wrappers to printf and scanf function families
454 // ----------------------------------------------------------------------------
456 #if !wxUSE_UTF8_LOCALE_ONLY
457 int wxDoSprintfWchar(char *str
, const wxChar
*format
, ...)
460 va_start(argptr
, format
);
462 int rv
= wxVsprintf(str
, format
, argptr
);
467 #endif // !wxUSE_UTF8_LOCALE_ONLY
469 #if wxUSE_UNICODE_UTF8
470 int wxDoSprintfUtf8(char *str
, const char *format
, ...)
473 va_start(argptr
, format
);
475 int rv
= wxVsprintf(str
, format
, argptr
);
480 #endif // wxUSE_UNICODE_UTF8
484 #if !wxUSE_UTF8_LOCALE_ONLY
485 int wxDoSprintfWchar(wchar_t *str
, const wxChar
*format
, ...)
488 va_start(argptr
, format
);
490 int rv
= wxVsprintf(str
, format
, argptr
);
495 #endif // !wxUSE_UTF8_LOCALE_ONLY
497 #if wxUSE_UNICODE_UTF8
498 int wxDoSprintfUtf8(wchar_t *str
, const char *format
, ...)
501 va_start(argptr
, format
);
503 int rv
= wxVsprintf(str
, format
, argptr
);
508 #endif // wxUSE_UNICODE_UTF8
510 #endif // wxUSE_UNICODE
512 #if !wxUSE_UTF8_LOCALE_ONLY
513 int wxDoSnprintfWchar(char *str
, size_t size
, const wxChar
*format
, ...)
516 va_start(argptr
, format
);
518 int rv
= wxVsnprintf(str
, size
, format
, argptr
);
523 #endif // !wxUSE_UTF8_LOCALE_ONLY
525 #if wxUSE_UNICODE_UTF8
526 int wxDoSnprintfUtf8(char *str
, size_t size
, const char *format
, ...)
529 va_start(argptr
, format
);
531 int rv
= wxVsnprintf(str
, size
, format
, argptr
);
536 #endif // wxUSE_UNICODE_UTF8
540 #if !wxUSE_UTF8_LOCALE_ONLY
541 int wxDoSnprintfWchar(wchar_t *str
, size_t size
, const wxChar
*format
, ...)
544 va_start(argptr
, format
);
546 int rv
= wxVsnprintf(str
, size
, format
, argptr
);
551 #endif // !wxUSE_UTF8_LOCALE_ONLY
553 #if wxUSE_UNICODE_UTF8
554 int wxDoSnprintfUtf8(wchar_t *str
, size_t size
, const char *format
, ...)
557 va_start(argptr
, format
);
559 int rv
= wxVsnprintf(str
, size
, format
, argptr
);
564 #endif // wxUSE_UNICODE_UTF8
566 #endif // wxUSE_UNICODE
569 #ifdef HAVE_BROKEN_VSNPRINTF_DECL
570 #define vsnprintf wx_fixed_vsnprintf
578 #if !wxUSE_UTF8_LOCALE_ONLY
579 int ConvertStringToBuf(const wxString
& s
, char *out
, size_t outsize
)
581 const wxWX2WCbuf buf
= s
.wc_str();
583 size_t len
= wxConvLibc
.FromWChar(out
, outsize
, buf
);
584 if ( len
!= wxCONV_FAILED
)
587 return wxConvLibc
.FromWChar(NULL
, 0, buf
);
589 #endif // !wxUSE_UTF8_LOCALE_ONLY
591 #if wxUSE_UNICODE_UTF8
592 int ConvertStringToBuf(const wxString
& s
, wchar_t *out
, size_t outsize
)
594 const wxWX2WCbuf
buf(s
.wc_str());
595 size_t len
= s
.length(); // same as buf length for wchar_t*
598 memcpy(out
, buf
, (len
+1) * sizeof(wchar_t));
600 else // not enough space
602 memcpy(out
, buf
, (outsize
-1) * sizeof(wchar_t));
607 #endif // wxUSE_UNICODE_UTF8
609 } // anonymous namespace
612 static size_t PrintfViaString(T
*out
, size_t outsize
,
613 const wxString
& format
, va_list argptr
)
616 s
.PrintfV(format
, argptr
);
618 return ConvertStringToBuf(s
, out
, outsize
);
620 #endif // wxUSE_UNICODE
622 int wxVsprintf(char *str
, const wxString
& format
, va_list argptr
)
624 #if wxUSE_UTF8_LOCALE_ONLY
625 return wxCRT_VsprintfA(str
, format
.wx_str(), argptr
);
627 #if wxUSE_UNICODE_UTF8
628 if ( wxLocaleIsUtf8
)
629 return wxCRT_VsprintfA(str
, format
.wx_str(), argptr
);
633 return PrintfViaString(str
, wxNO_LEN
, format
, argptr
);
635 return wxCRT_VsprintfA(str
, format
.mb_str(), argptr
);
641 int wxVsprintf(wchar_t *str
, const wxString
& format
, va_list argptr
)
643 #if wxUSE_UNICODE_WCHAR
646 This fails with a bug similar to
647 http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=c++.beta&artnum=680
649 I don't see it being used in the wxWidgets sources at present (oct 2007) CE
651 #pragma message ( "warning ::::: wxVsprintf(wchar_t *str, const wxString& format, va_list argptr) not yet implemented" )
652 wxFAIL_MSG( _T("TODO") );
656 return wxCRT_VsprintfW(str
, format
.wc_str(), argptr
);
658 #else // wxUSE_UNICODE_UTF8
659 #if !wxUSE_UTF8_LOCALE_ONLY
660 if ( !wxLocaleIsUtf8
)
661 return wxCRT_VsprintfW(str
, format
.wc_str(), argptr
);
664 return PrintfViaString(str
, wxNO_LEN
, format
, argptr
);
665 #endif // wxUSE_UNICODE_UTF8
667 #endif // wxUSE_UNICODE
669 int wxVsnprintf(char *str
, size_t size
, const wxString
& format
, va_list argptr
)
672 #if wxUSE_UTF8_LOCALE_ONLY
673 rv
= wxCRT_VsnprintfA(str
, size
, format
.wx_str(), argptr
);
675 #if wxUSE_UNICODE_UTF8
676 if ( wxLocaleIsUtf8
)
677 rv
= wxCRT_VsnprintfA(str
, size
, format
.wx_str(), argptr
);
682 // NB: if this code is called, then wxString::PrintV() would use the
683 // wchar_t* version of wxVsnprintf(), so it's safe to use PrintV()
685 rv
= PrintfViaString(str
, size
, format
, argptr
);
688 rv
= wxCRT_VsnprintfA(str
, size
, format
.mb_str(), argptr
);
692 // VsnprintfTestCase reveals that glibc's implementation of vswprintf
693 // doesn't nul terminate on truncation.
700 int wxVsnprintf(wchar_t *str
, size_t size
, const wxString
& format
, va_list argptr
)
704 #if wxUSE_UNICODE_WCHAR
705 rv
= wxCRT_VsnprintfW(str
, size
, format
.wc_str(), argptr
);
706 #else // wxUSE_UNICODE_UTF8
707 #if !wxUSE_UTF8_LOCALE_ONLY
708 if ( !wxLocaleIsUtf8
)
709 rv
= wxCRT_VsnprintfW(str
, size
, format
.wc_str(), argptr
);
713 // NB: if this code is called, then wxString::PrintV() would use the
714 // char* version of wxVsnprintf(), so it's safe to use PrintV()
716 rv
= PrintfViaString(str
, size
, format
, argptr
);
718 #endif // wxUSE_UNICODE_UTF8
720 // VsnprintfTestCase reveals that glibc's implementation of vswprintf
721 // doesn't nul terminate on truncation.
726 #endif // wxUSE_UNICODE
730 // ----------------------------------------------------------------------------
731 // ctype.h stuff (currently unused)
732 // ----------------------------------------------------------------------------
734 #ifdef wxNEED_WX_MBSTOWCS
736 WXDLLIMPEXP_BASE
size_t wxMbstowcs (wchar_t * out
, const char * in
, size_t outlen
)
746 const char* origin
= in
;
748 while (outlen
-- && *in
)
750 *out
++ = (wchar_t) *in
++;
758 WXDLLIMPEXP_BASE
size_t wxWcstombs (char * out
, const wchar_t * in
, size_t outlen
)
768 const wchar_t* origin
= in
;
770 while (outlen
-- && *in
)
772 *out
++ = (char) *in
++;
780 #endif // wxNEED_WX_MBSTOWCS
782 #ifndef wxCRT_StrdupA
783 WXDLLIMPEXP_BASE
char *wxCRT_StrdupA(const char *s
)
785 return strcpy((char *)malloc(strlen(s
) + 1), s
);
787 #endif // wxCRT_StrdupA
789 #ifndef wxCRT_StrdupW
790 WXDLLIMPEXP_BASE
wchar_t * wxCRT_StrdupW(const wchar_t *pwz
)
792 size_t size
= (wxWcslen(pwz
) + 1) * sizeof(wchar_t);
793 wchar_t *ret
= (wchar_t *) malloc(size
);
794 memcpy(ret
, pwz
, size
);
797 #endif // wxCRT_StrdupW
799 #ifndef wxWCHAR_T_IS_WXCHAR16
800 WXDLLIMPEXP_BASE
size_t wxStrlen(const wxChar16
*s
)
804 while (*s
!=0) { ++i
; ++s
; };
808 WXDLLIMPEXP_BASE wxChar16
* wxStrdup(const wxChar16
* s
)
810 size_t size
= (wxStrlen(s
) + 1) * sizeof(wxChar16
);
811 wxChar16
*ret
= (wxChar16
*) malloc(size
);
812 memcpy(ret
, s
, size
);
817 #ifndef wxWCHAR_T_IS_WXCHAR32
818 WXDLLIMPEXP_BASE
size_t wxStrlen(const wxChar32
*s
)
822 while (*s
!=0) { ++i
; ++s
; };
826 WXDLLIMPEXP_BASE wxChar32
* wxStrdup(const wxChar32
* s
)
828 size_t size
= (wxStrlen(s
) + 1) * sizeof(wxChar32
);
829 wxChar32
*ret
= (wxChar32
*) malloc(size
);
830 memcpy(ret
, s
, size
);
835 #ifndef wxCRT_StricmpA
836 WXDLLIMPEXP_BASE
int wxCRT_StricmpA(const char *psz1
, const char *psz2
)
838 register char c1
, c2
;
840 c1
= wxTolower(*psz1
++);
841 c2
= wxTolower(*psz2
++);
842 } while ( c1
&& (c1
== c2
) );
845 #endif // !defined(wxCRT_StricmpA)
847 #ifndef wxCRT_StricmpW
848 WXDLLIMPEXP_BASE
int wxCRT_StricmpW(const wchar_t *psz1
, const wchar_t *psz2
)
850 register wchar_t c1
, c2
;
852 c1
= wxTolower(*psz1
++);
853 c2
= wxTolower(*psz2
++);
854 } while ( c1
&& (c1
== c2
) );
857 #endif // !defined(wxCRT_StricmpW)
859 #ifndef wxCRT_StrnicmpA
860 WXDLLIMPEXP_BASE
int wxCRT_StrnicmpA(const char *s1
, const char *s2
, size_t n
)
862 // initialize the variables just to suppress stupid gcc warning
863 register char c1
= 0, c2
= 0;
864 while (n
&& ((c1
= wxTolower(*s1
)) == (c2
= wxTolower(*s2
)) ) && c1
) n
--, s1
++, s2
++;
866 if (c1
< c2
) return -1;
867 if (c1
> c2
) return 1;
871 #endif // !defined(wxCRT_StrnicmpA)
873 #ifndef wxCRT_StrnicmpW
874 WXDLLIMPEXP_BASE
int wxCRT_StrnicmpW(const wchar_t *s1
, const wchar_t *s2
, size_t n
)
876 // initialize the variables just to suppress stupid gcc warning
877 register wchar_t c1
= 0, c2
= 0;
878 while (n
&& ((c1
= wxTolower(*s1
)) == (c2
= wxTolower(*s2
)) ) && c1
) n
--, s1
++, s2
++;
880 if (c1
< c2
) return -1;
881 if (c1
> c2
) return 1;
885 #endif // !defined(wxCRT_StrnicmpW)
887 // ----------------------------------------------------------------------------
888 // string.h functions
889 // ----------------------------------------------------------------------------
891 // this (and wxCRT_StrncmpW below) are extern "C" because they are needed
892 // by regex code, the rest isn't needed, so it's not declared as extern "C"
893 #ifndef wxCRT_StrlenW
894 extern "C" WXDLLIMPEXP_BASE
size_t wxCRT_StrlenW(const wchar_t *s
)
904 // ----------------------------------------------------------------------------
905 // stdlib.h functions
906 // ----------------------------------------------------------------------------
908 #ifndef wxCRT_GetenvW
909 WXDLLIMPEXP_BASE
wchar_t* wxCRT_GetenvW(const wchar_t *name
)
911 // NB: buffer returned by getenv() is allowed to be overwritten next
912 // time getenv() is called, so it is OK to use static string
913 // buffer to hold the data.
914 static wxWCharBuffer
value((wchar_t*)NULL
);
915 value
= wxConvLibc
.cMB2WC(getenv(wxConvLibc
.cWC2MB(name
)));
918 #endif // !wxCRT_GetenvW
920 #ifndef wxCRT_StrftimeW
921 WXDLLIMPEXP_BASE
size_t
922 wxCRT_StrftimeW(wchar_t *s
, size_t maxsize
, const wchar_t *fmt
, const struct tm
*tm
)
927 wxCharBuffer
buf(maxsize
);
929 wxCharBuffer
bufFmt(wxConvLibc
.cWX2MB(fmt
));
933 size_t ret
= strftime(buf
.data(), maxsize
, bufFmt
, tm
);
937 wxWCharBuffer wbuf
= wxConvLibc
.cMB2WX(buf
);
941 wxCRT_StrncpyW(s
, wbuf
, maxsize
);
942 return wxCRT_StrlenW(s
);
944 #endif // !wxCRT_StrftimeW
946 #endif // wxUSE_WCHAR_T
951 wxCRT_StrtoullBase(const T
* nptr
, T
** endptr
, int base
, T
* sign
)
953 wxULongLong_t sum
= 0;
954 wxString
wxstr(nptr
);
955 wxString::const_iterator i
= wxstr
.begin();
956 wxString::const_iterator end
= wxstr
.end();
959 while ( i
!= end
&& wxIsspace(*i
) ) ++i
;
966 if ( c
== wxT('+') || c
== wxT('-') )
974 if ( i
!= end
&& *i
== wxT('0') )
979 if ( *i
== wxT('x') && (base
== 16 || base
== 0) )
999 for ( ; i
!= end
; ++i
)
1009 n
= wxTolower(c
) - wxT('a') + 10;
1014 if ( n
>= (unsigned int)base
)
1015 // Invalid character (for this base)
1018 wxULongLong_t prevsum
= sum
;
1019 sum
= (sum
* base
) + n
;
1021 if ( sum
< prevsum
)
1023 wxSET_ERRNO(ERANGE
);
1030 *endptr
= (T
*)(nptr
+ (i
- wxstr
.begin()));
1036 template<typename T
>
1037 static wxULongLong_t
wxCRT_DoStrtoull(const T
* nptr
, T
** endptr
, int base
)
1040 wxULongLong_t uval
= ::wxCRT_StrtoullBase(nptr
, endptr
, base
, &sign
);
1042 if ( sign
== wxT('-') )
1044 wxSET_ERRNO(ERANGE
);
1051 template<typename T
>
1052 static wxLongLong_t
wxCRT_DoStrtoll(const T
* nptr
, T
** endptr
, int base
)
1055 wxULongLong_t uval
= ::wxCRT_StrtoullBase(nptr
, endptr
, base
, &sign
);
1056 wxLongLong_t val
= 0;
1058 if ( sign
== wxT('-') )
1060 if (uval
<= (wxULongLong_t
)wxINT64_MAX
+ 1)
1062 val
= -(wxLongLong_t
)uval
;
1066 wxSET_ERRNO(ERANGE
);
1069 else if ( uval
<= wxINT64_MAX
)
1075 wxSET_ERRNO(ERANGE
);
1081 #ifndef wxCRT_StrtollA
1082 wxLongLong_t
wxCRT_StrtollA(const char* nptr
, char** endptr
, int base
)
1083 { return wxCRT_DoStrtoll(nptr
, endptr
, base
); }
1085 #ifndef wxCRT_StrtollW
1086 wxLongLong_t
wxCRT_StrtollW(const wchar_t* nptr
, wchar_t** endptr
, int base
)
1087 { return wxCRT_DoStrtoll(nptr
, endptr
, base
); }
1090 #ifndef wxCRT_StrtoullA
1091 wxULongLong_t
wxCRT_StrtoullA(const char* nptr
, char** endptr
, int base
)
1092 { return wxCRT_DoStrtoull(nptr
, endptr
, base
); }
1094 #ifndef wxCRT_StrtoullW
1095 wxULongLong_t
wxCRT_StrtoullW(const wchar_t* nptr
, wchar_t** endptr
, int base
)
1096 { return wxCRT_DoStrtoull(nptr
, endptr
, base
); }
1099 #endif // wxLongLong_t
1101 // ----------------------------------------------------------------------------
1102 // functions which we may need even if !wxUSE_WCHAR_T
1103 // ----------------------------------------------------------------------------
1105 template<typename T
>
1106 static T
*wxCRT_DoStrtok(T
*psz
, const T
*delim
, T
**save_ptr
)
1115 psz
+= wxStrspn(psz
, delim
);
1118 *save_ptr
= (T
*)NULL
;
1123 psz
= wxStrpbrk(psz
, delim
);
1126 *save_ptr
= (T
*)NULL
;
1131 *save_ptr
= psz
+ 1;
1137 #ifndef wxCRT_StrtokA
1138 char *wxCRT_StrtokA(char *psz
, const char *delim
, char **save_ptr
)
1139 { return wxCRT_DoStrtok(psz
, delim
, save_ptr
); }
1141 #ifndef wxCRT_StrtokW
1142 wchar_t *wxCRT_StrtokW(wchar_t *psz
, const wchar_t *delim
, wchar_t **save_ptr
)
1143 { return wxCRT_DoStrtok(psz
, delim
, save_ptr
); }
1146 // ----------------------------------------------------------------------------
1147 // missing C RTL functions
1148 // ----------------------------------------------------------------------------
1150 #ifdef wxNEED_STRDUP
1152 char *strdup(const char *s
)
1154 char *dest
= (char*) malloc( strlen( s
) + 1 ) ;
1156 strcpy( dest
, s
) ;
1159 #endif // wxNEED_STRDUP
1161 #if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
1163 void *calloc( size_t num
, size_t size
)
1165 void** ptr
= (void **)malloc(num
* size
);
1166 memset( ptr
, 0, num
* size
);
1170 #endif // __WXWINCE__ <= 211
1172 // ============================================================================
1174 // ============================================================================
1176 #if wxUSE_UNICODE_UTF8
1178 #if !wxUSE_UTF8_LOCALE_ONLY
1179 bool wxLocaleIsUtf8
= false; // the safer setting if not known
1182 static bool wxIsLocaleUtf8()
1184 // NB: we intentionally don't use wxLocale::GetSystemEncodingName(),
1185 // because a) it may be unavailable in some builds and b) has slightly
1186 // different semantics (default locale instead of current)
1188 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
1189 // GNU libc provides current character set this way (this conforms to
1191 const char *charset
= nl_langinfo(CODESET
);
1194 // "UTF-8" is used by modern glibc versions, but test other variants
1195 // as well, just in case:
1196 if ( strcmp(charset
, "UTF-8") == 0 ||
1197 strcmp(charset
, "utf-8") == 0 ||
1198 strcmp(charset
, "UTF8") == 0 ||
1199 strcmp(charset
, "utf8") == 0 )
1204 #endif // HAVE_LANGINFO_H
1206 // check if we're running under the "C" locale: it is 7bit subset
1207 // of UTF-8, so it can be safely used with the UTF-8 build:
1208 const char *lc_ctype
= setlocale(LC_CTYPE
, NULL
);
1210 (strcmp(lc_ctype
, "C") == 0 || strcmp(lc_ctype
, "POSIX") == 0) )
1215 // we don't know what charset libc is using, so assume the worst
1220 void wxUpdateLocaleIsUtf8()
1222 #if wxUSE_UTF8_LOCALE_ONLY
1223 if ( !wxIsLocaleUtf8() )
1225 wxLogFatalError(_T("This program requires UTF-8 locale to run."));
1227 #else // !wxUSE_UTF8_LOCALE_ONLY
1228 wxLocaleIsUtf8
= wxIsLocaleUtf8();
1232 #endif // wxUSE_UNICODE_UTF8
1234 // ============================================================================
1235 // wx wrappers for CRT functions
1236 // ============================================================================
1238 #if wxUSE_UNICODE_WCHAR
1239 #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW) return_kw callW
1240 #elif wxUSE_UNICODE_UTF8 && !wxUSE_UTF8_LOCALE_ONLY
1241 #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW) \
1242 return_kw wxLocaleIsUtf8 ? callA : callW
1243 #else // ANSI or UTF8 only
1244 #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW) return_kw callA
1247 int wxPuts(const wxString
& s
)
1249 CALL_ANSI_OR_UNICODE(return,
1250 wxCRT_PutsA(s
.mb_str()),
1251 wxCRT_PutsW(s
.wc_str()));
1254 int wxFputs(const wxString
& s
, FILE *stream
)
1256 CALL_ANSI_OR_UNICODE(return,
1257 wxCRT_FputsA(s
.mb_str(), stream
),
1258 wxCRT_FputsW(s
.wc_str(), stream
));
1261 int wxFputc(const wxUniChar
& c
, FILE *stream
)
1263 #if !wxUSE_UNICODE // FIXME-UTF8: temporary, remove this with ANSI build
1264 return wxCRT_FputcA((char)c
, stream
);
1266 CALL_ANSI_OR_UNICODE(return,
1267 wxCRT_FputsA(c
.AsUTF8(), stream
),
1268 wxCRT_FputcW((wchar_t)c
, stream
));
1272 #ifdef wxCRT_PerrorA
1274 void wxPerror(const wxString
& s
)
1276 #ifdef wxCRT_PerrorW
1277 CALL_ANSI_OR_UNICODE(wxEMPTY_PARAMETER_VALUE
,
1278 wxCRT_PerrorA(s
.mb_str()),
1279 wxCRT_PerrorW(s
.wc_str()));
1281 wxCRT_PerrorA(s
.mb_str());
1285 #endif // wxCRT_PerrorA
1287 wchar_t *wxFgets(wchar_t *s
, int size
, FILE *stream
)
1289 wxCHECK_MSG( s
, NULL
, "empty buffer passed to wxFgets()" );
1291 wxCharBuffer
buf(size
- 1);
1292 // FIXME: this reads too little data if wxConvLibc uses UTF-8 ('size' wide
1293 // characters may be encoded by up to 'size'*4 bytes), but what
1295 if ( wxFgets(buf
.data(), size
, stream
) == NULL
)
1298 if ( wxConvLibc
.ToWChar(s
, size
, buf
, wxNO_LEN
) == wxCONV_FAILED
)
1304 // ----------------------------------------------------------------------------
1305 // wxScanf() and friends
1306 // ----------------------------------------------------------------------------
1308 #ifdef HAVE_VSSCANF // __VISUALC__ and __DMC__ see wx/crt.h
1309 int wxVsscanf(const char *str
, const char *format
, va_list ap
)
1310 { return wxCRT_VsscanfA(str
, format
, ap
); }
1311 int wxVsscanf(const wchar_t *str
, const wchar_t *format
, va_list ap
)
1312 { return wxCRT_VsscanfW(str
, format
, ap
); }
1313 int wxVsscanf(const wxCharBuffer
& str
, const char *format
, va_list ap
)
1314 { return wxCRT_VsscanfA(wx_static_cast(const char*, str
), format
, ap
); }
1315 int wxVsscanf(const wxWCharBuffer
& str
, const wchar_t *format
, va_list ap
)
1316 { return wxCRT_VsscanfW(str
, format
, ap
); }
1317 int wxVsscanf(const wxString
& str
, const char *format
, va_list ap
)
1318 { return wxCRT_VsscanfA(wx_static_cast(const char*, str
.mb_str()), format
, ap
); }
1319 int wxVsscanf(const wxString
& str
, const wchar_t *format
, va_list ap
)
1320 { return wxCRT_VsscanfW(str
.wc_str(), format
, ap
); }
1321 int wxVsscanf(const wxCStrData
& str
, const char *format
, va_list ap
)
1322 { return wxCRT_VsscanfA(wx_static_cast(const char*, str
.AsCharBuf()), format
, ap
); }
1323 int wxVsscanf(const wxCStrData
& str
, const wchar_t *format
, va_list ap
)
1324 { return wxCRT_VsscanfW(str
.AsWCharBuf(), format
, ap
); }
1325 #endif // HAVE_NO_VSSCANF