]> git.saurik.com Git - wxWidgets.git/blob - src/common/wxchar.cpp
Some fixes for wxURLDataObject when wxUSE_UNICODE==1
[wxWidgets.git] / src / common / wxchar.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wxchar.cpp
3 // Purpose: wxChar implementation
4 // Author: Ove Kåven
5 // Modified by:
6 // Created: 09/04/99
7 // RCS-ID: $Id$
8 // Copyright: (c) wxWindows copyright
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifdef __GNUG__
13 #pragma implementation "wxchar.h"
14 #endif
15
16 // ===========================================================================
17 // headers, declarations, constants
18 // ===========================================================================
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #define _ISOC9X_SOURCE 1 // to get vsscanf()
28 #define _BSD_SOURCE 1 // to still get strdup()
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <locale.h>
34 #include <time.h>
35
36 #ifndef WX_PRECOMP
37 #include "wx/defs.h"
38 #include "wx/wxchar.h"
39 #include "wx/string.h"
40 #include "wx/hash.h"
41 #endif
42
43 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
44 #include <windef.h>
45 #include <winbase.h>
46 #include <winnls.h>
47 #include <winnt.h>
48 #endif
49
50 #if wxUSE_WCHAR_T
51 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
52 {
53 if (buf) {
54 if (!n || !*psz) {
55 if (n) *buf = wxT('\0');
56 return 0;
57 }
58 return mbstowcs(buf, psz, n);
59 }
60
61 // assume that we have mbsrtowcs() too if we have wcsrtombs()
62 #ifdef HAVE_WCSRTOMBS
63 mbstate_t mbstate;
64 return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
65 #else // !GNU libc
66 return mbstowcs((wchar_t *) NULL, psz, 0);
67 #endif // GNU
68 }
69
70 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
71 {
72 if (buf) {
73 if (!n || !*pwz) {
74 // glibc2.1 chokes on null input
75 if (n) *buf = '\0';
76 return 0;
77 }
78 return wcstombs(buf, pwz, n);
79 }
80
81 #if HAVE_WCSRTOMBS
82 mbstate_t mbstate;
83 return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
84 #else // !GNU libc
85 return wcstombs((char *) NULL, pwz, 0);
86 #endif // GNU
87 }
88 #endif // wxUSE_WCHAR_T
89
90 bool WXDLLEXPORT wxOKlibc()
91 {
92 #if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__)
93 // glibc 2.0 uses UTF-8 even when it shouldn't
94 wchar_t res = 0;
95 if ((MB_CUR_MAX == 2) &&
96 (wxMB2WC(&res, "\xdd\xa5", 1) == 1) &&
97 (res==0x765)) {
98 // this is UTF-8 allright, check whether that's what we want
99 char *cur_locale = setlocale(LC_CTYPE, NULL);
100 if ((strlen(cur_locale) < 4) ||
101 (strcasecmp(cur_locale + strlen(cur_locale) - 4, "utf8")) ||
102 (strcasecmp(cur_locale + strlen(cur_locale) - 5, "utf-8"))) {
103 // nope, don't use libc conversion
104 return FALSE;
105 }
106 }
107 #endif
108 return TRUE;
109 }
110
111 #ifndef HAVE_WCSLEN
112 size_t WXDLLEXPORT wcslen(const wchar_t *s)
113 {
114 size_t len = 0;
115 while (s[len]) len++;
116 return len;
117 }
118 #endif
119
120 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
121 inline WORD wxMSW_ctype(wxChar ch)
122 {
123 WORD ret;
124 GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, &ch, 1, &ret);
125 return ret;
126 }
127
128 WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
129 WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }
130 WXDLLEXPORT int wxIsctrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
131 WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
132 WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
133 WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }
134 WXDLLEXPORT int wxIsprint(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_SPACE|C1_PUNCT|C1_ALPHA); }
135 WXDLLEXPORT int wxIspunct(wxChar ch) { return wxMSW_ctype(ch) & C1_PUNCT; }
136 WXDLLEXPORT int wxIsspace(wxChar ch) { return wxMSW_ctype(ch) & C1_SPACE; }
137 WXDLLEXPORT int wxIsupper(wxChar ch) { return IsCharUpper(ch); }
138 WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_XDIGIT; }
139 WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
140 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
141 #endif
142
143 #ifndef wxStrdup
144 WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz)
145 {
146 size_t size = (wxStrlen(psz) + 1) * sizeof(wxChar);
147 wxChar *ret = (wxChar *) malloc(size);
148 memcpy(ret, psz, size);
149 return ret;
150 }
151 #endif
152
153 #ifndef wxStricmp
154 int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
155 {
156 register wxChar c1, c2;
157 do {
158 c1 = wxTolower(*psz1++);
159 c2 = wxTolower(*psz2++);
160 } while ( c1 && (c1 == c2) );
161 return c1 - c2;
162 }
163 #endif
164
165 #ifndef wxStricmp
166 int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
167 {
168 register wxChar c1, c2;
169 while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
170 if (n) {
171 if (c1 < c2) return -1;
172 if (c1 > c2) return 1;
173 }
174 return 0;
175 }
176 #endif
177
178 #ifndef wxStrtok
179 WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
180 {
181 if (!psz) psz = *save_ptr;
182 psz += wxStrspn(psz, delim);
183 if (!*psz) {
184 *save_ptr = (wxChar *)NULL;
185 return (wxChar *)NULL;
186 }
187 wxChar *ret = psz;
188 psz = wxStrpbrk(psz, delim);
189 if (!psz) *save_ptr = (wxChar*)NULL;
190 else {
191 *psz = wxT('\0');
192 *save_ptr = psz + 1;
193 }
194 return ret;
195 }
196 #endif
197
198 #ifndef wxSetlocale
199 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
200 {
201 char *localeOld = setlocale(category, wxConvLibc.cWX2MB(locale));
202
203 return wxWCharBuffer(wxConvLibc.cMB2WC(localeOld));
204 }
205 #endif
206
207 #ifdef wxNEED_WX_STRING_H
208 WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src)
209 {
210 wxChar *ret = dest;
211 while (*dest) dest++;
212 while ((*dest++ = *src++));
213 return ret;
214 }
215
216 WXDLLEXPORT wxChar * wxStrchr(const wxChar *s, wxChar c)
217 {
218 while (*s && *s != c) s++;
219 return (*s) ? (wxChar *)s : (wxChar *)NULL;
220 }
221
222 WXDLLEXPORT int wxStrcmp(const wxChar *s1, const wxChar *s2)
223 {
224 while ((*s1 == *s2) && *s1) s1++, s2++;
225 if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
226 if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
227 return 0;
228 }
229
230 WXDLLEXPORT wxChar * wxStrcpy(wxChar *dest, const wxChar *src)
231 {
232 wxChar *ret = dest;
233 while ((*dest++ = *src++));
234 return ret;
235 }
236
237 WXDLLEXPORT wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n)
238 {
239 wxChar *ret = dest;
240 while (*dest) dest++;
241 while (n && (*dest++ = *src++)) n--;
242 return ret;
243 }
244
245 WXDLLEXPORT int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n)
246 {
247 while (n && (*s1 == *s2) && *s1) n--, s1++, s2++;
248 if (n) {
249 if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
250 if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
251 }
252 return 0;
253 }
254
255 WXDLLEXPORT wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n)
256 {
257 wxChar *ret = dest;
258 while (n && (*dest++ = *src++)) n--;
259 while (n) *dest++=0, n--; // the docs specify padding with zeroes
260 return ret;
261 }
262
263 WXDLLEXPORT wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept)
264 {
265 while (*s && !wxStrchr(accept, *s)) s++;
266 return (*s) ? (wxChar *)s : (wxChar *)NULL;
267 }
268
269 WXDLLEXPORT wxChar * wxStrrchr(const wxChar *s, wxChar c)
270 {
271 wxChar *ret = (wxChar *)NULL;
272 while (*s) {
273 if (*s == c) ret = (wxChar *)s;
274 s++;
275 }
276 return ret;
277 }
278
279 WXDLLEXPORT size_t wxStrspn(const wxChar *s, const wxChar *accept)
280 {
281 size_t len = 0;
282 while (wxStrchr(accept, *s++)) len++;
283 return len;
284 }
285
286 WXDLLEXPORT wxChar * wxStrstr(const wxChar *haystack, const wxChar *needle)
287 {
288 wxChar *fnd;
289 while ((fnd = wxStrchr(haystack, *needle))) {
290 if (!wxStrcmp(fnd, needle)) return fnd;
291 haystack = fnd + 1;
292 }
293 return (wxChar *)NULL;
294 }
295
296 WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr)
297 {
298 const wxChar *start = nptr;
299
300 // FIXME: only correct for C locale
301 while (wxIsspace(*nptr)) nptr++;
302 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
303 while (wxIsdigit(*nptr)) nptr++;
304 if (*nptr == wxT('.')) {
305 nptr++;
306 while (wxIsdigit(*nptr)) nptr++;
307 }
308 if (*nptr == wxT('E') || *nptr == wxT('e')) {
309 nptr++;
310 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
311 while (wxIsdigit(*nptr)) nptr++;
312 }
313
314 wxString data(nptr, nptr-start);
315 wxWX2MBbuf dat = data.mb_str(wxConvLibc);
316 char *rdat = wxMBSTRINGCAST dat;
317 double ret = strtod(dat, &rdat);
318
319 if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
320
321 return ret;
322 }
323
324 WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
325 {
326 const wxChar *start = nptr;
327
328 // FIXME: only correct for C locale
329 while (wxIsspace(*nptr)) nptr++;
330 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
331 if (((base == 0) || (base == 16)) &&
332 (nptr[0] == wxT('0') && nptr[1] == wxT('x'))) {
333 nptr += 2;
334 base = 16;
335 }
336 else if ((base == 0) && (nptr[0] == wxT('0'))) base = 8;
337 else if (base == 0) base = 10;
338
339 while ((wxIsdigit(*nptr) && (*nptr - wxT('0') < base)) ||
340 (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
341
342 wxString data(nptr, nptr-start);
343 wxWX2MBbuf dat = data.mb_str(wxConvLibc);
344 char *rdat = wxMBSTRINGCAST dat;
345 long int ret = strtol(dat, &rdat, base);
346
347 if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
348
349 return ret;
350 }
351 #endif
352
353 #ifdef wxNEED_WX_STDIO_H
354 WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
355 {
356 return fopen(wxConvFile.cWX2MB(path), wxConvLibc.cWX2MB(mode));
357 }
358
359 WXDLLEXPORT FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream)
360 {
361 return freopen(wxConvFile.cWX2MB(path), wxConvLibc.cWX2MB(mode), stream);
362 }
363
364 WXDLLEXPORT int wxRemove(const wxChar *path)
365 {
366 return remove(wxConvFile.cWX2MB(path));
367 }
368
369 WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
370 {
371 return rename(wxConvFile.cWX2MB(oldpath), wxConvFile.cWX2MB(newpath));
372 }
373
374 int WXDLLEXPORT wxPrintf(const wxChar *fmt, ...)
375 {
376 va_list argptr;
377 int ret;
378
379 va_start(argptr, fmt);
380 ret = wxVprintf(fmt, argptr);
381 va_end(argptr);
382 return ret;
383 }
384
385 int WXDLLEXPORT wxVprintf(const wxChar *fmt, va_list argptr)
386 {
387 wxString str;
388 str.PrintfV(fmt,argptr);
389 printf("%s", (const char*)str.mb_str());
390 return str.Len();
391 }
392
393 int WXDLLEXPORT wxFprintf(FILE *stream, const wxChar *fmt, ...)
394 {
395 va_list argptr;
396 int ret;
397
398 va_start(argptr, fmt);
399 ret = wxVfprintf(stream, fmt, argptr);
400 va_end(argptr);
401 return ret;
402 }
403
404 int WXDLLEXPORT wxVfprintf(FILE *stream, const wxChar *fmt, va_list argptr)
405 {
406 wxString str;
407 str.PrintfV(fmt,argptr);
408 fprintf(stream, "%s", (const char*)str.mb_str());
409 return str.Len();
410 }
411
412 int WXDLLEXPORT wxSprintf(wxChar *buf, const wxChar *fmt, ...)
413 {
414 va_list argptr;
415 int ret;
416
417 va_start(argptr, fmt);
418 ret = wxVsprintf(buf, fmt, argptr);
419 va_end(argptr);
420 return ret;
421 }
422
423 int WXDLLEXPORT wxVsprintf(wxChar *buf, const wxChar *fmt, va_list argptr)
424 {
425 // this might be sort of inefficient, but it doesn't matter since
426 // we'd prefer people to use wxString::Printf directly instead anyway
427 wxString str;
428 str.PrintfV(fmt,argptr);
429 wxStrcpy(buf,str.c_str());
430 return str.Len();
431 }
432
433 int WXDLLEXPORT wxSscanf(const wxChar *buf, const wxChar *fmt, ...)
434 {
435 va_list argptr;
436 int ret;
437
438 va_start(argptr, fmt);
439 ret = wxVsscanf(buf, fmt, argptr);
440 va_end(argptr);
441 return ret;
442 }
443
444 int WXDLLEXPORT wxVsscanf(const wxChar *buf, const wxChar *fmt, va_list argptr)
445 {
446 int ret;
447 // this will work only for numeric conversion! Strings will not be converted correctly
448 // hopefully this is all we'll need
449 ret = vsscanf(wxConvLibc.cWX2MB(buf), wxConvLibc.cWX2MB(fmt), argptr);
450 return ret;
451 }
452 #endif
453
454 #ifndef wxAtof
455 double WXDLLEXPORT wxAtof(const wxChar *psz)
456 {
457 return atof(wxConvLibc.cWX2MB(psz));
458 }
459 #endif
460
461 #ifdef wxNEED_WX_STDLIB_H
462 int WXDLLEXPORT wxAtoi(const wxChar *psz)
463 {
464 return atoi(wxConvLibc.cWX2MB(psz));
465 }
466
467 long WXDLLEXPORT wxAtol(const wxChar *psz)
468 {
469 return atol(wxConvLibc.cWX2MB(psz));
470 }
471
472 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
473 {
474 static wxHashTable env;
475 // check if we already have stored the converted env var
476 wxObject *data = env.Get(name);
477 if (!data) {
478 // nope, retrieve it,
479 const char *val = getenv(wxConvLibc.cWX2MB(name));
480 if (!val) return (wxChar *)NULL;
481 // convert it,
482 data = (wxObject *)new wxString(val);
483 // and store it
484 env.Put(name, data);
485 }
486 // return converted env var
487 return (wxChar *)((wxString *)data)->c_str();
488 }
489
490 int WXDLLEXPORT wxSystem(const wxChar *psz)
491 {
492 return system(wxConvLibc.cWX2MB(psz));
493 }
494
495 #endif
496
497 #ifdef wxNEED_WX_TIME_H
498 WXDLLEXPORT size_t wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm)
499 {
500 if (!max) return 0;
501 char *buf = (char *)malloc(max);
502 size_t ret = strftime(buf, max, wxConvLibc.cWX2MB(fmt), tm);
503 if (ret) {
504 wxStrcpy(s, wxConvLibc.cMB2WX(buf));
505 free(buf);
506 return wxStrlen(s);
507 } else {
508 free(buf);
509 *s = 0;
510 return 0;
511 }
512 }
513 #endif