]> git.saurik.com Git - wxWidgets.git/blob - src/common/wxchar.cpp
projects / wxWidgets.git / blob
? search:


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