1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxChar implementation
8 // Copyright: (c) wxWindows copyright
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
13 #pragma implementation "wxchar.h"
16 // ===========================================================================
17 // headers, declarations, constants
18 // ===========================================================================
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #define _ISOC9X_SOURCE 1 // to get vsscanf()
28 #define _BSD_SOURCE 1 // to still get strdup()
38 #include "wx/msw/wince/time.h"
43 #include "wx/wxchar.h"
44 #include "wx/string.h"
48 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
55 #if defined(__MWERKS__) && __MSL__ >= 0x6000
60 #include "wx/mac/private.h"
64 size_t WXDLLEXPORT
wxMB2WC(wchar_t *buf
, const char *psz
, size_t n
)
66 // assume that we have mbsrtowcs() too if we have wcsrtombs()
69 memset(&mbstate
, 0, sizeof(mbstate_t));
74 if (n
) *buf
= wxT('\0');
78 return mbsrtowcs(buf
, &psz
, n
, &mbstate
);
80 return mbstowcs(buf
, psz
, n
);
85 return mbsrtowcs((wchar_t *) NULL
, &psz
, 0, &mbstate
);
87 return mbstowcs((wchar_t *) NULL
, psz
, 0);
91 size_t WXDLLEXPORT
wxWC2MB(char *buf
, const wchar_t *pwz
, size_t n
)
95 memset(&mbstate
, 0, sizeof(mbstate_t));
100 // glibc2.1 chokes on null input
105 return wcsrtombs(buf
, &pwz
, n
, &mbstate
);
107 return wcstombs(buf
, pwz
, n
);
112 return wcsrtombs((char *) NULL
, &pwz
, 0, &mbstate
);
114 return wcstombs((char *) NULL
, pwz
, 0);
117 #endif // wxUSE_WCHAR_T
119 bool WXDLLEXPORT
wxOKlibc()
121 #if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
122 // glibc 2.0 uses UTF-8 even when it shouldn't
124 if ((MB_CUR_MAX
== 2) &&
125 (wxMB2WC(&res
, "\xdd\xa5", 1) == 1) &&
127 // this is UTF-8 allright, check whether that's what we want
128 char *cur_locale
= setlocale(LC_CTYPE
, NULL
);
129 if ((strlen(cur_locale
) < 4) ||
130 (strcasecmp(cur_locale
+ strlen(cur_locale
) - 4, "utf8")) ||
131 (strcasecmp(cur_locale
+ strlen(cur_locale
) - 5, "utf-8"))) {
132 // nope, don't use libc conversion
140 // ============================================================================
141 // printf() functions business
142 // ============================================================================
144 // special test mode: define all functions below even if we don't really need
145 // them to be able to test them
156 #define wxNEED_WPRINTF
158 int wxVfprintf( FILE *stream
, const wxChar
*format
, va_list argptr
);
161 // ----------------------------------------------------------------------------
162 // implement [v]snprintf() if the system doesn't provide a safe one
163 // ----------------------------------------------------------------------------
165 #if !defined(wxVsnprintf_)
166 int WXDLLEXPORT
wxVsnprintf_(wxChar
*buf
, size_t lenMax
,
167 const wxChar
*format
, va_list argptr
)
169 // buffer to avoid dynamic memory allocation each time for small strings
170 char szScratch
[1024];
172 // number of characters in the buffer so far, must be less than lenMax
175 for ( size_t n
= 0; ; n
++ )
177 const wxChar chCur
= format
[n
];
179 if ( chCur
== wxT('%') )
181 static char s_szFlags
[256] = "%";
183 bool adj_left
= FALSE
,
188 size_t min_width
= 0,
189 max_width
= wxSTRING_MAXLEN
;
194 if (in_prec && !prec_dot) \
196 s_szFlags[flagofs++] = '.'; \
200 #define APPEND_CH(ch) \
201 if ( lenCur == lenMax ) \
206 #define APPEND_STR(s) \
208 for ( const wxChar *p = s; *p; p++ ) \
215 const wxChar ch
= format
[++n
];
235 s_szFlags
[flagofs
++] = ch
;
241 s_szFlags
[flagofs
++] = ch
;
249 // dot will be auto-added to s_szFlags if non-negative
256 s_szFlags
[flagofs
++] = ch
;
262 s_szFlags
[flagofs
++] = ch
;
269 s_szFlags
[flagofs
++] = ch
;
275 s_szFlags
[flagofs
++] = ch
;
280 int len
= va_arg(argptr
, int);
291 adj_left
= !adj_left
;
292 s_szFlags
[flagofs
++] = '-';
297 flagofs
+= ::sprintf(s_szFlags
+flagofs
,"%d",len
);
301 case wxT('1'): case wxT('2'): case wxT('3'):
302 case wxT('4'): case wxT('5'): case wxT('6'):
303 case wxT('7'): case wxT('8'): case wxT('9'):
307 while ( (format
[n
] >= wxT('0')) &&
308 (format
[n
] <= wxT('9')) )
310 s_szFlags
[flagofs
++] = format
[n
];
311 len
= len
*10 + (format
[n
] - wxT('0'));
320 n
--; // the main loop pre-increments n again
331 s_szFlags
[flagofs
++] = ch
;
332 s_szFlags
[flagofs
] = '\0';
335 int val
= va_arg(argptr
, int);
336 ::sprintf(szScratch
, s_szFlags
, val
);
340 // NB: 'short int' value passed through '...'
341 // is promoted to 'int', so we have to get
342 // an int from stack even if we need a short
343 short int val
= (short int) va_arg(argptr
, int);
344 ::sprintf(szScratch
, s_szFlags
, val
);
348 long int val
= va_arg(argptr
, long int);
349 ::sprintf(szScratch
, s_szFlags
, val
);
354 long long int val
= va_arg(argptr
, long long int);
355 ::sprintf(szScratch
, s_szFlags
, val
);
357 long int val
= va_arg(argptr
, long int);
358 ::sprintf(szScratch
, s_szFlags
, val
);
359 #endif // long long/!long long
363 size_t val
= va_arg(argptr
, size_t);
364 ::sprintf(szScratch
, s_szFlags
, val
);
368 const wxMB2WXbuf tmp
=
369 wxConvLibc
.cMB2WX(szScratch
);
382 s_szFlags
[flagofs
++] = ch
;
383 s_szFlags
[flagofs
] = '\0';
386 long double val
= va_arg(argptr
, long double);
387 ::sprintf(szScratch
, s_szFlags
, val
);
391 double val
= va_arg(argptr
, double);
392 ::sprintf(szScratch
, s_szFlags
, val
);
396 const wxMB2WXbuf tmp
=
397 wxConvLibc
.cMB2WX(szScratch
);
406 void *val
= va_arg(argptr
, void *);
408 s_szFlags
[flagofs
++] = ch
;
409 s_szFlags
[flagofs
] = '\0';
410 ::sprintf(szScratch
, s_szFlags
, val
);
412 const wxMB2WXbuf tmp
=
413 wxConvLibc
.cMB2WX(szScratch
);
422 wxChar val
= va_arg(argptr
, int);
423 // we don't need to honor padding here, do we?
433 // wx extension: we'll let %hs mean non-Unicode
435 char *val
= va_arg(argptr
, char *);
437 // ASCII->Unicode constructor handles max_width
439 wxString
s(val
, wxConvLibc
, max_width
);
441 size_t len
= wxSTRING_MAXLEN
;
445 val
[len
] && (len
< max_width
);
451 wxString
s(val
, len
);
453 if (s
.Len() < min_width
)
454 s
.Pad(min_width
- s
.Len(), wxT(' '), adj_left
);
460 wxChar
*val
= va_arg(argptr
, wxChar
*);
461 size_t len
= wxSTRING_MAXLEN
;
465 val
[len
] && (len
< max_width
);
472 wxString
s(val
, len
);
473 if (s
.Len() < min_width
)
474 s
.Pad(min_width
- s
.Len(), wxT(' '), adj_left
);
484 int *val
= va_arg(argptr
, int *);
489 short int *val
= va_arg(argptr
, short int *);
494 long int *val
= va_arg(argptr
, long int *);
501 // bad format, leave unchanged
527 #endif // !wxVsnprintfA
529 #if !defined(wxSnprintf_)
530 int WXDLLEXPORT
wxSnprintf_(wxChar
*buf
, size_t len
, const wxChar
*format
, ...)
533 va_start(argptr
, format
);
535 int iLen
= wxVsnprintf_(buf
, len
, format
, argptr
);
541 #endif // wxSnprintf_
543 // ----------------------------------------------------------------------------
544 // implement the standard IO functions for wide char if libc doesn't have them
545 // ----------------------------------------------------------------------------
549 int wxFputs(const wchar_t *ws
, FILE *stream
)
551 // counting the number of wide characters written isn't worth the trouble,
552 // simply distinguish between ok and error
553 return fputs(wxConvLibc
.cWC2MB(ws
), stream
) == -1 ? -1 : 0;
556 int /* not wint_t */ wxPutc(wchar_t wc
, FILE *stream
)
558 wchar_t ws
[2] = { wc
, L
'\0' };
560 return wxFputs(ws
, stream
);
563 #endif // wxNEED_FPUTWC
565 // NB: we only implement va_list functions here, the ones taking ... are
566 // defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
567 // the definitions there to avoid duplicating them here
568 #ifdef wxNEED_WPRINTF
570 // TODO: implement the scanf() functions
571 int vwscanf(const wxChar
*format
, va_list argptr
)
573 wxFAIL_MSG( _T("TODO") );
578 int vswscanf(const wxChar
*ws
, const wxChar
*format
, va_list argptr
)
580 wxFAIL_MSG( _T("TODO") );
585 int vfwscanf(FILE *stream
, const wxChar
*format
, va_list argptr
)
587 wxFAIL_MSG( _T("TODO") );
592 #define vswprintf wxVsnprintf_
594 int vfwprintf(FILE *stream
, const wxChar
*format
, va_list argptr
)
597 int rc
= s
.PrintfV(format
, argptr
);
601 // we can't do much better without Unicode support in libc...
602 if ( fprintf(stream
, "%s", s
.mb_str()) == -1 )
609 int vwprintf(const wxChar
*format
, va_list argptr
)
611 return wxVfprintf(stdout
, format
, argptr
);
614 #endif // wxNEED_WPRINTF
616 #ifdef wxNEED_PRINTF_CONVERSION
618 // ----------------------------------------------------------------------------
619 // wxFormatConverter: class doing the "%s" -> "%ls" conversion
620 // ----------------------------------------------------------------------------
623 Here are the gory details. We want to follow the Windows/MS conventions,
628 format specifier results in
629 -----------------------------------
635 format specifier results in
636 -----------------------------------
641 while on POSIX systems we have %C identical to %lc and %c always means char
642 (in any mode) while %lc always means wchar_t,
644 So to use native functions in order to get our semantics we must do the
645 following translations in Unicode mode (nothing to do in ANSI mode):
647 wxWindows specifier POSIX specifier
648 ----------------------------------------
654 And, of course, the same should be done for %s as well.
657 class wxFormatConverter
660 wxFormatConverter(const wxChar
*format
);
662 // notice that we only translated the string if m_fmtOrig == NULL (as set
663 // by CopyAllBefore()), otherwise we should simply use the original format
664 operator const wxChar
*() const
665 { return m_fmtOrig
? m_fmtOrig
: m_fmt
.c_str(); }
668 // copy another character to the translated format: this function does the
669 // copy if we are translating but doesn't do anything at all if we don't,
670 // so we don't create the translated format string at all unless we really
671 // need to (i.e. InsertFmtChar() is called)
672 wxChar
CopyFmtChar(wxChar ch
)
676 // we're translating, do copy
681 // simply increase the count which should be copied by
682 // CopyAllBefore() later if needed
689 // insert an extra character
690 void InsertFmtChar(wxChar ch
)
694 // so far we haven't translated anything yet
703 wxASSERT_MSG( m_fmtOrig
&& m_fmt
.empty(), _T("logic error") );
705 m_fmt
= wxString(m_fmtOrig
, m_nCopied
);
707 // we won't need it any longer
711 static bool IsFlagChar(wxChar ch
)
713 return ch
== _T('-') || ch
== _T('+') ||
714 ch
== _T('0') || ch
== _T(' ') || ch
== _T('#');
717 void SkipDigits(const wxChar
**ppc
)
719 while ( **ppc
>= _T('0') && **ppc
<= _T('9') )
720 CopyFmtChar(*(*ppc
)++);
723 // the translated format
726 // the original format
727 const wxChar
*m_fmtOrig
;
729 // the number of characters already copied
733 wxFormatConverter::wxFormatConverter(const wxChar
*format
)
740 if ( CopyFmtChar(*format
++) == _T('%') )
743 while ( IsFlagChar(*format
) )
744 CopyFmtChar(*format
++);
746 // and possible width
747 if ( *format
== _T('*') )
748 CopyFmtChar(*format
++);
753 if ( *format
== _T('.') )
758 // next we can have a size modifier
774 // "ll" has a different meaning!
775 if ( format
[1] != _T('l') )
787 // and finally we should have the type
792 // %C and %hC -> %c and %lC -> %lc
794 CopyFmtChar(_T('l'));
796 InsertFmtChar(*format
++ == _T('C') ? _T('c') : _T('s'));
801 // %c -> %lc but %hc stays %hc and %lc is still %lc
805 InsertFmtChar(_T('l'));
809 CopyFmtChar(_T('h'));
818 // nothing special to do
819 CopyFmtChar(*format
++);
825 #else // !wxNEED_PRINTF_CONVERSION
826 // no conversion necessary
827 #define wxFormatConverter(x) (x)
828 #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
830 // ----------------------------------------------------------------------------
831 // wxPrintf(), wxScanf() and relatives
832 // ----------------------------------------------------------------------------
834 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
836 int wxScanf( const wxChar
*format
, ... )
839 va_start(argptr
, format
);
841 int ret
= vwscanf(wxFormatConverter(format
), argptr
);
848 int wxSscanf( const wxChar
*str
, const wxChar
*format
, ... )
851 va_start(argptr
, format
);
853 int ret
= vswscanf( str
, wxFormatConverter(format
), argptr
);
860 int wxFscanf( FILE *stream
, const wxChar
*format
, ... )
863 va_start(argptr
, format
);
864 int ret
= vfwscanf(stream
, wxFormatConverter(format
), argptr
);
871 int wxPrintf( const wxChar
*format
, ... )
874 va_start(argptr
, format
);
876 int ret
= vwprintf( wxFormatConverter(format
), argptr
);
884 int wxSnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, ... )
887 va_start(argptr
, format
);
889 int ret
= vswprintf( str
, size
, wxFormatConverter(format
), argptr
);
897 int wxSprintf( wxChar
*str
, const wxChar
*format
, ... )
900 va_start(argptr
, format
);
902 // callers of wxSprintf() deserve what they get
903 int ret
= vswprintf( str
, UINT_MAX
, wxFormatConverter(format
), argptr
);
910 int wxFprintf( FILE *stream
, const wxChar
*format
, ... )
913 va_start( argptr
, format
);
915 int ret
= vfwprintf( stream
, wxFormatConverter(format
), argptr
);
922 int wxVsscanf( const wxChar
*str
, const wxChar
*format
, va_list argptr
)
924 return vswscanf( str
, wxFormatConverter(format
), argptr
);
927 int wxVfprintf( FILE *stream
, const wxChar
*format
, va_list argptr
)
929 return vfwprintf( stream
, wxFormatConverter(format
), argptr
);
932 int wxVprintf( const wxChar
*format
, va_list argptr
)
934 return vwprintf( wxFormatConverter(format
), argptr
);
938 int wxVsnprintf( wxChar
*str
, size_t size
, const wxChar
*format
, va_list argptr
)
940 return vswprintf( str
, size
, wxFormatConverter(format
), argptr
);
942 #endif // wxVsnprintf
944 int wxVsprintf( wxChar
*str
, const wxChar
*format
, va_list argptr
)
946 // same as for wxSprintf()
947 return vswprintf(str
, UINT_MAX
, wxFormatConverter(format
), argptr
);
950 #endif // wxNEED_PRINTF_CONVERSION
954 // ----------------------------------------------------------------------------
955 // ctype.h stuff (currently unused)
956 // ----------------------------------------------------------------------------
958 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
959 inline WORD
wxMSW_ctype(wxChar ch
)
962 GetStringTypeEx(LOCALE_USER_DEFAULT
, CT_CTYPE1
, &ch
, 1, &ret
);
966 WXDLLEXPORT
int wxIsalnum(wxChar ch
) { return IsCharAlphaNumeric(ch
); }
967 WXDLLEXPORT
int wxIsalpha(wxChar ch
) { return IsCharAlpha(ch
); }
968 WXDLLEXPORT
int wxIsctrl(wxChar ch
) { return wxMSW_ctype(ch
) & C1_CNTRL
; }
969 WXDLLEXPORT
int wxIsdigit(wxChar ch
) { return wxMSW_ctype(ch
) & C1_DIGIT
; }
970 WXDLLEXPORT
int wxIsgraph(wxChar ch
) { return wxMSW_ctype(ch
) & (C1_DIGIT
|C1_PUNCT
|C1_ALPHA
); }
971 WXDLLEXPORT
int wxIslower(wxChar ch
) { return IsCharLower(ch
); }
972 WXDLLEXPORT
int wxIsprint(wxChar ch
) { return wxMSW_ctype(ch
) & (C1_DIGIT
|C1_SPACE
|C1_PUNCT
|C1_ALPHA
); }
973 WXDLLEXPORT
int wxIspunct(wxChar ch
) { return wxMSW_ctype(ch
) & C1_PUNCT
; }
974 WXDLLEXPORT
int wxIsspace(wxChar ch
) { return wxMSW_ctype(ch
) & C1_SPACE
; }
975 WXDLLEXPORT
int wxIsupper(wxChar ch
) { return IsCharUpper(ch
); }
976 WXDLLEXPORT
int wxIsxdigit(wxChar ch
) { return wxMSW_ctype(ch
) & C1_XDIGIT
; }
977 WXDLLEXPORT
int wxTolower(wxChar ch
) { return (wxChar
)CharLower((LPTSTR
)(ch
)); }
978 WXDLLEXPORT
int wxToupper(wxChar ch
) { return (wxChar
)CharUpper((LPTSTR
)(ch
)); }
983 WXDLLEXPORT
char *wxStrdupA(const char *s
)
985 return strcpy((char *)malloc(strlen(s
) + 1), s
);
992 WXDLLEXPORT
wchar_t * wxStrdupW(const wchar_t *pwz
)
994 size_t size
= (wxWcslen(pwz
) + 1) * sizeof(wchar_t);
995 wchar_t *ret
= (wchar_t *) malloc(size
);
996 memcpy(ret
, pwz
, size
);
1003 int WXDLLEXPORT
wxStricmp(const wxChar
*psz1
, const wxChar
*psz2
)
1005 register wxChar c1
, c2
;
1007 c1
= wxTolower(*psz1
++);
1008 c2
= wxTolower(*psz2
++);
1009 } while ( c1
&& (c1
== c2
) );
1015 int WXDLLEXPORT
wxStrnicmp(const wxChar
*s1
, const wxChar
*s2
, size_t n
)
1017 // initialize the variables just to suppress stupid gcc warning
1018 register wxChar c1
= 0, c2
= 0;
1019 while (n
&& ((c1
= wxTolower(*s1
)) == (c2
= wxTolower(*s2
)) ) && c1
) n
--, s1
++, s2
++;
1021 if (c1
< c2
) return -1;
1022 if (c1
> c2
) return 1;
1029 WXDLLEXPORT wxWCharBuffer
wxSetlocale(int category
, const wxChar
*locale
)
1031 char *localeOld
= setlocale(category
, wxConvLocal
.cWX2MB(locale
));
1033 return wxWCharBuffer(wxConvLocal
.cMB2WC(localeOld
));
1037 // ----------------------------------------------------------------------------
1038 // string.h functions
1039 // ----------------------------------------------------------------------------
1041 #ifdef wxNEED_WX_STRING_H
1042 WXDLLEXPORT wxChar
* wxStrcat(wxChar
*dest
, const wxChar
*src
)
1045 while (*dest
) dest
++;
1046 while ((*dest
++ = *src
++));
1050 WXDLLEXPORT
const wxChar
* wxStrchr(const wxChar
*s
, wxChar c
)
1052 // be careful here as the terminating NUL makes part of the string
1062 WXDLLEXPORT
int wxStrcmp(const wxChar
*s1
, const wxChar
*s2
)
1064 while ((*s1
== *s2
) && *s1
) s1
++, s2
++;
1065 if ((wxUChar
)*s1
< (wxUChar
)*s2
) return -1;
1066 if ((wxUChar
)*s1
> (wxUChar
)*s2
) return 1;
1070 WXDLLEXPORT wxChar
* wxStrcpy(wxChar
*dest
, const wxChar
*src
)
1073 while ((*dest
++ = *src
++));
1077 WXDLLEXPORT wxChar
* wxStrncat(wxChar
*dest
, const wxChar
*src
, size_t n
)
1080 while (*dest
) dest
++;
1081 while (n
&& (*dest
++ = *src
++)) n
--;
1085 WXDLLEXPORT
int wxStrncmp(const wxChar
*s1
, const wxChar
*s2
, size_t n
)
1087 while (n
&& (*s1
== *s2
) && *s1
) n
--, s1
++, s2
++;
1089 if ((wxUChar
)*s1
< (wxUChar
)*s2
) return -1;
1090 if ((wxUChar
)*s1
> (wxUChar
)*s2
) return 1;
1095 WXDLLEXPORT wxChar
* wxStrncpy(wxChar
*dest
, const wxChar
*src
, size_t n
)
1098 while (n
&& (*dest
++ = *src
++)) n
--;
1099 while (n
) *dest
++=0, n
--; // the docs specify padding with zeroes
1103 WXDLLEXPORT
const wxChar
* wxStrpbrk(const wxChar
*s
, const wxChar
*accept
)
1105 while (*s
&& !wxStrchr(accept
, *s
))
1108 return *s
? s
: NULL
;
1111 WXDLLEXPORT
const wxChar
* wxStrrchr(const wxChar
*s
, wxChar c
)
1113 const wxChar
*ret
= NULL
;
1125 WXDLLEXPORT
size_t wxStrspn(const wxChar
*s
, const wxChar
*accept
)
1128 while (wxStrchr(accept
, *s
++)) len
++;
1132 WXDLLEXPORT
const wxChar
*wxStrstr(const wxChar
*haystack
, const wxChar
*needle
)
1134 wxCHECK_RET( needle
, NULL
, _T("NULL argument in wxStrstr") );
1136 // VZ: this is not exactly the most efficient string search algorithm...
1138 const size_t len
= wxStrlen(needle
);
1140 while ( const wxChar
*fnd
= wxStrchr(haystack
, *needle
) )
1142 if ( !wxStrncmp(fnd
, needle
, len
) )
1151 WXDLLEXPORT
double wxStrtod(const wxChar
*nptr
, wxChar
**endptr
)
1153 const wxChar
*start
= nptr
;
1155 // FIXME: only correct for C locale
1156 while (wxIsspace(*nptr
)) nptr
++;
1157 if (*nptr
== wxT('+') || *nptr
== wxT('-')) nptr
++;
1158 while (wxIsdigit(*nptr
)) nptr
++;
1159 if (*nptr
== wxT('.')) {
1161 while (wxIsdigit(*nptr
)) nptr
++;
1163 if (*nptr
== wxT('E') || *nptr
== wxT('e')) {
1165 if (*nptr
== wxT('+') || *nptr
== wxT('-')) nptr
++;
1166 while (wxIsdigit(*nptr
)) nptr
++;
1169 wxString
data(nptr
, nptr
-start
);
1170 wxWX2MBbuf dat
= data
.mb_str(wxConvLocal
);
1171 char *rdat
= wxMBSTRINGCAST dat
;
1172 double ret
= strtod(dat
, &rdat
);
1174 if (endptr
) *endptr
= (wxChar
*)(start
+ (rdat
- (const char *)dat
));
1179 WXDLLEXPORT
long int wxStrtol(const wxChar
*nptr
, wxChar
**endptr
, int base
)
1181 const wxChar
*start
= nptr
;
1183 // FIXME: only correct for C locale
1184 while (wxIsspace(*nptr
)) nptr
++;
1185 if (*nptr
== wxT('+') || *nptr
== wxT('-')) nptr
++;
1186 if (((base
== 0) || (base
== 16)) &&
1187 (nptr
[0] == wxT('0') && nptr
[1] == wxT('x'))) {
1191 else if ((base
== 0) && (nptr
[0] == wxT('0'))) base
= 8;
1192 else if (base
== 0) base
= 10;
1194 while ((wxIsdigit(*nptr
) && (*nptr
- wxT('0') < base
)) ||
1195 (wxIsalpha(*nptr
) && (wxToupper(*nptr
) - wxT('A') + 10 < base
))) nptr
++;
1197 wxString
data(nptr
, nptr
-start
);
1198 wxWX2MBbuf dat
= data
.mb_str(wxConvLocal
);
1199 char *rdat
= wxMBSTRINGCAST dat
;
1200 long int ret
= strtol(dat
, &rdat
, base
);
1202 if (endptr
) *endptr
= (wxChar
*)(start
+ (rdat
- (const char *)dat
));
1206 #endif // wxNEED_WX_STRING_H
1208 #ifdef wxNEED_WX_STDIO_H
1209 WXDLLEXPORT
FILE * wxFopen(const wxChar
*path
, const wxChar
*mode
)
1211 char mode_buffer
[10];
1212 for (size_t i
= 0; i
< wxStrlen(mode
)+1; i
++)
1213 mode_buffer
[i
] = (char) mode
[i
];
1215 return fopen( wxConvFile
.cWX2MB(path
), mode_buffer
);
1218 WXDLLEXPORT
FILE * wxFreopen(const wxChar
*path
, const wxChar
*mode
, FILE *stream
)
1220 char mode_buffer
[10];
1221 for (size_t i
= 0; i
< wxStrlen(mode
)+1; i
++)
1222 mode_buffer
[i
] = (char) mode
[i
];
1224 return freopen( wxConvFile
.cWX2MB(path
), mode_buffer
, stream
);
1227 WXDLLEXPORT
int wxRemove(const wxChar
*path
)
1229 return remove( wxConvFile
.cWX2MB(path
) );
1232 WXDLLEXPORT
int wxRename(const wxChar
*oldpath
, const wxChar
*newpath
)
1234 return rename( wxConvFile
.cWX2MB(oldpath
), wxConvFile
.cWX2MB(newpath
) );
1239 double WXDLLEXPORT
wxAtof(const wxChar
*psz
)
1244 if (str
.ToDouble(& d
))
1249 return atof(wxConvLocal
.cWX2MB(psz
));
1254 #ifdef wxNEED_WX_STDLIB_H
1255 int WXDLLEXPORT
wxAtoi(const wxChar
*psz
)
1257 return atoi(wxConvLocal
.cWX2MB(psz
));
1260 long WXDLLEXPORT
wxAtol(const wxChar
*psz
)
1262 return atol(wxConvLocal
.cWX2MB(psz
));
1265 wxChar
* WXDLLEXPORT
wxGetenv(const wxChar
*name
)
1267 static wxHashTable env
;
1269 // check if we already have stored the converted env var
1270 wxObject
*data
= env
.Get(name
);
1273 // nope, retrieve it,
1275 wxCharBuffer buffer
= wxConvLocal
.cWX2MB(name
);
1276 // printf( "buffer %s\n", (const char*) buffer );
1277 const char *val
= getenv( (const char *)buffer
);
1279 const char *val
= getenv( name
);
1282 if (!val
) return (wxChar
*)NULL
;
1283 // printf( "home %s\n", val );
1287 data
= (wxObject
*)new wxString(val
, wxConvLocal
);
1289 data
= (wxObject
*)new wxString(val
);
1293 env
.Put(name
, data
);
1295 // return converted env var
1296 return (wxChar
*)((wxString
*)data
)->c_str();
1299 int WXDLLEXPORT
wxSystem(const wxChar
*psz
)
1301 return system(wxConvLocal
.cWX2MB(psz
));
1304 #endif // wxNEED_WX_STDLIB_H
1306 #ifdef wxNEED_WX_TIME_H
1307 WXDLLEXPORT
size_t wxStrftime(wxChar
*s
, size_t max
, const wxChar
*fmt
, const struct tm
*tm
)
1311 char *buf
= (char *)malloc(max
);
1312 size_t ret
= strftime(buf
, max
, wxConvLocal
.cWX2MB(fmt
), tm
);
1315 wxStrcpy(s
, wxConvLocal
.cMB2WX(buf
));
1326 #endif // wxNEED_WX_TIME_H
1328 #endif // wxUSE_WCHAR_T
1330 // ----------------------------------------------------------------------------
1331 // functions which we may need even if !wxUSE_WCHAR_T
1332 // ----------------------------------------------------------------------------
1336 WXDLLEXPORT wxChar
* wxStrtok(wxChar
*psz
, const wxChar
*delim
, wxChar
**save_ptr
)
1345 psz
+= wxStrspn(psz
, delim
);
1348 *save_ptr
= (wxChar
*)NULL
;
1349 return (wxChar
*)NULL
;
1353 psz
= wxStrpbrk(psz
, delim
);
1356 *save_ptr
= (wxChar
*)NULL
;
1361 *save_ptr
= psz
+ 1;
1369 // ----------------------------------------------------------------------------
1370 // missing C RTL functions
1371 // ----------------------------------------------------------------------------
1373 #if (defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)) || \
1374 defined(__WXWINCE__)
1375 char *strdup(const char *s
)
1377 char *dest
= (char*) malloc( strlen( s
) + 1 ) ;
1379 strcpy( dest
, s
) ;
1384 #if (defined(__MWERKS__) && !defined(__MACH__)) || (defined(__WXWINCE__) && _WIN32_WCE <= 211)
1386 int isascii( int c
)
1388 return ( c
>= 0 && c
< 128 );
1392 #if defined(__WXWINCE__)
1393 #if (_WIN32_WCE < 300)
1394 void *calloc( size_t num
, size_t size
)
1396 void** ptr
= (void **)malloc(num
* size
);
1397 memset( ptr
, 0, num
* size
);
1402 #if (_WIN32_WCE <= 211)