]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/wxchar.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Add wxOverlay
[wxWidgets.git] / src / common / wxchar.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/common/wxchar.cpp
3// Purpose: wxChar implementation
4// Author: Ove Kaven
5// Modified by: Ron Lee, Francesco Montorsi
6// Created: 09/04/99
7// RCS-ID: $Id$
8// Copyright: (c) wxWidgets copyright
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ===========================================================================
13// headers, declarations, constants
14// ===========================================================================
15
16// For compilers that support precompilation, includes "wx.h".
17#include "wx/wxprec.h"
18
19#ifdef __BORLANDC__
20 #pragma hdrstop
21#endif
22
23#include "wx/wxchar.h"
24
25#define _ISOC9X_SOURCE 1 // to get vsscanf()
26#define _BSD_SOURCE 1 // to still get strdup()
27
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31
32#ifndef __WXWINCE__
33 #include <time.h>
34 #include <locale.h>
35#else
36 #include "wx/msw/wince/time.h"
37#endif
38
39#ifndef WX_PRECOMP
40 #include "wx/string.h"
41 #include "wx/hash.h"
42 #include "wx/utils.h" // for wxMin and wxMax
43 #include "wx/log.h"
44#endif
45
46#if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
47 #include <windef.h>
48 #include <winbase.h>
49 #include <winnls.h>
50 #include <winnt.h>
51#endif
52
53#if defined(__MWERKS__) && __MSL__ >= 0x6000
54namespace std {}
55using namespace std ;
56#endif
57
58#if wxUSE_WCHAR_T
59size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
60{
61 // assume that we have mbsrtowcs() too if we have wcsrtombs()
62#ifdef HAVE_WCSRTOMBS
63 mbstate_t mbstate;
64 memset(&mbstate, 0, sizeof(mbstate_t));
65#endif
66
67 if (buf) {
68 if (!n || !*psz) {
69 if (n) *buf = wxT('\0');
70 return 0;
71 }
72#ifdef HAVE_WCSRTOMBS
73 return mbsrtowcs(buf, &psz, n, &mbstate);
74#else
75 return wxMbstowcs(buf, psz, n);
76#endif
77 }
78
79 // note that we rely on common (and required by Unix98 but unfortunately not
80 // C99) extension which allows to call mbs(r)towcs() with NULL output pointer
81 // to just get the size of the needed buffer -- this is needed as otherwise
82 // we have no idea about how much space we need and if the CRT doesn't
83 // support it (the only currently known example being Metrowerks, see
84 // wx/wxchar.h) we don't use its mbstowcs() at all
85#ifdef HAVE_WCSRTOMBS
86 return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
87#else
88 return wxMbstowcs((wchar_t *) NULL, psz, 0);
89#endif
90}
91
92size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
93{
94#ifdef HAVE_WCSRTOMBS
95 mbstate_t mbstate;
96 memset(&mbstate, 0, sizeof(mbstate_t));
97#endif
98
99 if (buf) {
100 if (!n || !*pwz) {
101 // glibc2.1 chokes on null input
102 if (n) *buf = '\0';
103 return 0;
104 }
105#ifdef HAVE_WCSRTOMBS
106 return wcsrtombs(buf, &pwz, n, &mbstate);
107#else
108 return wxWcstombs(buf, pwz, n);
109#endif
110 }
111
112#ifdef HAVE_WCSRTOMBS
113 return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
114#else
115 return wxWcstombs((char *) NULL, pwz, 0);
116#endif
117}
118#endif // wxUSE_WCHAR_T
119
120bool WXDLLEXPORT wxOKlibc()
121{
122#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
123 // glibc 2.0 uses UTF-8 even when it shouldn't
124 wchar_t res = 0;
125 if ((MB_CUR_MAX == 2) &&
126 (wxMB2WC(&res, "\xdd\xa5", 1) == 1) &&
127 (res==0x765)) {
128 // this is UTF-8 allright, check whether that's what we want
129 char *cur_locale = setlocale(LC_CTYPE, NULL);
130 if ((strlen(cur_locale) < 4) ||
131 (strcasecmp(cur_locale + strlen(cur_locale) - 4, "utf8")) ||
132 (strcasecmp(cur_locale + strlen(cur_locale) - 5, "utf-8"))) {
133 // nope, don't use libc conversion
134 return false;
135 }
136 }
137#endif
138 return true;
139}
140
141// ============================================================================
142// printf() functions business
143// ============================================================================
144
145// special test mode: define all functions below even if we don't really need
146// them to be able to test them
147#ifdef wxTEST_PRINTF
148 #undef wxFprintf
149 #undef wxPrintf
150 #undef wxSprintf
151 #undef wxVfprintf
152 #undef wxVsprintf
153 #undef wxVprintf
154 #undef wxVsnprintf_
155 #undef wxSnprintf_
156
157 #define wxNEED_WPRINTF
158
159 int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr );
160#endif
161
162// ----------------------------------------------------------------------------
163// implement [v]snprintf() if the system doesn't provide a safe one
164// or if the system's one does not support positional parameters
165// (very useful for i18n purposes)
166// ----------------------------------------------------------------------------
167
168#if !defined(wxVsnprintf_)
169
170// wxUSE_STRUTILS says our wxVsnprintf_ implementation to use or not to
171// use wxStrlen and wxStrncpy functions over one-char processing loops.
172//
173// Some benchmarking revealed that wxUSE_STRUTILS == 1 has the following
174// effects:
175// -> on Windows:
176// when in ANSI mode, this setting does not change almost anything
177// when in Unicode mode, it gives ~ 50% of slowdown !
178// -> on Linux:
179// both in ANSI and Unicode mode it gives ~ 60% of speedup !
180//
181#if defined(WIN32) && wxUSE_UNICODE
182#define wxUSE_STRUTILS 0
183#else
184#define wxUSE_STRUTILS 1
185#endif
186
187// some limits of our implementation
188#define wxMAX_SVNPRINTF_ARGUMENTS 64
189#define wxMAX_SVNPRINTF_FLAGBUFFER_LEN 32
190#define wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN 512
191
192// prefer snprintf over sprintf
193#if defined(__VISUALC__) || \
194 (defined(__BORLANDC__) && __BORLANDC__ >= 0x540)
195 #define system_sprintf(buff, max, flags, data) \
196 ::_snprintf(buff, max, flags, data)
197#elif defined(HAVE_SNPRINTF)
198 #define system_sprintf(buff, max, flags, data) \
199 ::snprintf(buff, max, flags, data)
200#else // NB: at least sprintf() should always be available
201 // since 'max' is not used in this case, wxVsnprintf() should always
202 // ensure that 'buff' is big enough for all common needs
203 // (see wxMAX_SVNPRINTF_FLAGBUFFER_LEN and wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN)
204 #define system_sprintf(buff, max, flags, data) \
205 ::sprintf(buff, flags, data)
206
207 #define SYSTEM_SPRINTF_IS_UNSAFE
208#endif
209
210// the conversion specifiers accepted by wxVsnprintf_
211enum wxPrintfArgType {
212 wxPAT_INVALID = -1,
213
214 wxPAT_INT, // %d, %i, %o, %u, %x, %X
215 wxPAT_LONGINT, // %ld, etc
216#if SIZEOF_LONG_LONG
217 wxPAT_LONGLONGINT, // %Ld, etc
218#endif
219 wxPAT_SIZET, // %Zd, etc
220
221 wxPAT_DOUBLE, // %e, %E, %f, %g, %G
222 wxPAT_LONGDOUBLE, // %le, etc
223
224 wxPAT_POINTER, // %p
225
226 wxPAT_CHAR, // %hc (in ANSI mode: %c, too)
227 wxPAT_WCHAR, // %lc (in Unicode mode: %c, too)
228
229 wxPAT_PCHAR, // %s (related to a char *)
230 wxPAT_PWCHAR, // %s (related to a wchar_t *)
231
232 wxPAT_NINT, // %n
233 wxPAT_NSHORTINT, // %hn
234 wxPAT_NLONGINT // %ln
235};
236
237// an argument passed to wxVsnprintf_
238typedef union {
239 int pad_int; // %d, %i, %o, %u, %x, %X
240 long int pad_longint; // %ld, etc
241#if SIZEOF_LONG_LONG
242 long long int pad_longlongint; // %Ld, etc
243#endif
244 size_t pad_sizet; // %Zd, etc
245
246 double pad_double; // %e, %E, %f, %g, %G
247 long double pad_longdouble; // %le, etc
248
249 void *pad_pointer; // %p
250
251 char pad_char; // %hc (in ANSI mode: %c, too)
252 wchar_t pad_wchar; // %lc (in Unicode mode: %c, too)
253
254 char *pad_pchar; // %s (related to a char *)
255 wchar_t *pad_pwchar; // %s (related to a wchar_t *)
256
257 int *pad_nint; // %n
258 short int *pad_nshortint; // %hn
259 long int *pad_nlongint; // %ln
260} wxPrintfArg;
261
262
263// Contains parsed data relative to a conversion specifier given to
264// wxVsnprintf_ and parsed from the format string
265// NOTE: in C++ there is almost no difference between struct & classes thus
266// there is no performance gain by using a struct here...
267class wxPrintfConvSpec
268{
269public:
270
271 // the position of the argument relative to this conversion specifier
272 size_t m_pos;
273
274 // the type of this conversion specifier
275 wxPrintfArgType m_type;
276
277 // the minimum and maximum width
278 // when one of this var is set to -1 it means: use the following argument
279 // in the stack as minimum/maximum width for this conversion specifier
280 int m_nMinWidth, m_nMaxWidth;
281
282 // does the argument need to the be aligned to left ?
283 bool m_bAlignLeft;
284
285 // pointer to the '%' of this conversion specifier in the format string
286 // NOTE: this points somewhere in the string given to the Parse() function -
287 // it's task of the caller ensure that memory is still valid !
288 const wxChar *m_pArgPos;
289
290 // pointer to the last character of this conversion specifier in the
291 // format string
292 // NOTE: this points somewhere in the string given to the Parse() function -
293 // it's task of the caller ensure that memory is still valid !
294 const wxChar *m_pArgEnd;
295
296 // a little buffer where formatting flags like #+\.hlqLZ are stored by Parse()
297 // for use in Process()
298 // NB: even if this buffer is used only for numeric conversion specifiers and
299 // thus could be safely declared as a char[] buffer, we want it to be wxChar
300 // so that in Unicode builds we can avoid to convert its contents to Unicode
301 // chars when copying it in user's buffer.
302 char m_szFlags[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
303
304
305public:
306
307 // we don't declare this as a constructor otherwise it would be called
308 // automatically and we don't want this: to be optimized, wxVsnprintf_
309 // calls this function only on really-used instances of this class.
310 void Init();
311
312 // Parses the first conversion specifier in the given string, which must
313 // begin with a '%'. Returns false if the first '%' does not introduce a
314 // (valid) conversion specifier and thus should be ignored.
315 bool Parse(const wxChar *format);
316
317 // Process this conversion specifier and puts the result in the given
318 // buffer. Returns the number of characters written in 'buf' or -1 if
319 // there's not enough space.
320 int Process(wxChar *buf, size_t lenMax, wxPrintfArg *p, size_t written);
321
322 // Loads the argument of this conversion specifier from given va_list.
323 bool LoadArg(wxPrintfArg *p, va_list &argptr);
324
325private:
326 // An helper function of LoadArg() which is used to handle the '*' flag
327 void ReplaceAsteriskWith(int w);
328};
329
330void wxPrintfConvSpec::Init()
331{
332 m_nMinWidth = 0;
333 m_nMaxWidth = 0xFFFF;
334 m_pos = 0;
335 m_bAlignLeft = false;
336 m_pArgPos = m_pArgEnd = NULL;
337 m_type = wxPAT_INVALID;
338
339 // this character will never be removed from m_szFlags array and
340 // is important when calling sprintf() in wxPrintfConvSpec::Process() !
341 m_szFlags[0] = '%';
342}
343
344bool wxPrintfConvSpec::Parse(const wxChar *format)
345{
346 bool done = false;
347
348 // temporary parse data
349 size_t flagofs = 1;
350 bool in_prec, prec_dot;
351 int ilen = 0;
352
353 m_bAlignLeft = in_prec = prec_dot = false;
354 m_pArgPos = m_pArgEnd = format;
355 do
356 {
357#define CHECK_PREC \
358 if (in_prec && !prec_dot) \
359 { \
360 m_szFlags[flagofs++] = '.'; \
361 prec_dot = true; \
362 }
363
364 // what follows '%'?
365 const wxChar ch = *(++m_pArgEnd);
366 switch ( ch )
367 {
368 case wxT('\0'):
369 return false; // not really an argument
370
371 case wxT('%'):
372 return false; // not really an argument
373
374 case wxT('#'):
375 case wxT('0'):
376 case wxT(' '):
377 case wxT('+'):
378 case wxT('\''):
379 CHECK_PREC
380 m_szFlags[flagofs++] = char(ch);
381 break;
382
383 case wxT('-'):
384 CHECK_PREC
385 m_bAlignLeft = true;
386 m_szFlags[flagofs++] = char(ch);
387 break;
388
389 case wxT('.'):
390 CHECK_PREC
391 in_prec = true;
392 prec_dot = false;
393 m_nMaxWidth = 0;
394 // dot will be auto-added to m_szFlags if non-negative
395 // number follows
396 break;
397
398 case wxT('h'):
399 ilen = -1;
400 CHECK_PREC
401 m_szFlags[flagofs++] = char(ch);
402 break;
403
404 case wxT('l'):
405 // NB: it's safe to use flagofs-1 as flagofs always start from 1
406 if (m_szFlags[flagofs-1] == 'l') // 'll' modifier is the same as 'L' or 'q'
407 ilen = 2;
408 else
409 ilen = 1;
410 CHECK_PREC
411 m_szFlags[flagofs++] = char(ch);
412 break;
413
414 case wxT('q'):
415 case wxT('L'):
416 ilen = 2;
417 CHECK_PREC
418 m_szFlags[flagofs++] = char(ch);
419 break;
420
421 case wxT('Z'):
422 ilen = 3;
423 CHECK_PREC
424 m_szFlags[flagofs++] = char(ch);
425 break;
426
427 case wxT('*'):
428 if (in_prec)
429 {
430 CHECK_PREC
431
432 // tell Process() to use the next argument
433 // in the stack as maxwidth...
434 m_nMaxWidth = -1;
435 }
436 else
437 {
438 // tell Process() to use the next argument
439 // in the stack as minwidth...
440 m_nMinWidth = -1;
441 }
442
443 // save the * in our formatting buffer...
444 // will be replaced later by Process()
445 m_szFlags[flagofs++] = char(ch);
446 break;
447
448 case wxT('1'): case wxT('2'): case wxT('3'):
449 case wxT('4'): case wxT('5'): case wxT('6'):
450 case wxT('7'): case wxT('8'): case wxT('9'):
451 {
452 int len = 0;
453 CHECK_PREC
454 while ( (*m_pArgEnd >= wxT('0')) &&
455 (*m_pArgEnd <= wxT('9')) )
456 {
457 m_szFlags[flagofs++] = char(*m_pArgEnd);
458 len = len*10 + (*m_pArgEnd - wxT('0'));
459 m_pArgEnd++;
460 }
461
462 if (in_prec)
463 m_nMaxWidth = len;
464 else
465 m_nMinWidth = len;
466
467 m_pArgEnd--; // the main loop pre-increments n again
468 }
469 break;
470
471 case wxT('$'): // a positional parameter (e.g. %2$s) ?
472 {
473 if (m_nMinWidth <= 0)
474 break; // ignore this formatting flag as no
475 // numbers are preceding it
476
477 // remove from m_szFlags all digits previously added
478 do {
479 flagofs--;
480 } while (m_szFlags[flagofs] >= '1' &&
481 m_szFlags[flagofs] <= '9');
482
483 // re-adjust the offset making it point to the
484 // next free char of m_szFlags
485 flagofs++;
486
487 m_pos = m_nMinWidth;
488 m_nMinWidth = 0;
489 }
490 break;
491
492 case wxT('d'):
493 case wxT('i'):
494 case wxT('o'):
495 case wxT('u'):
496 case wxT('x'):
497 case wxT('X'):
498 CHECK_PREC
499 m_szFlags[flagofs++] = char(ch);
500 m_szFlags[flagofs] = '\0';
501 if (ilen == 0)
502 m_type = wxPAT_INT;
503 else if (ilen == -1)
504 // NB: 'short int' value passed through '...'
505 // is promoted to 'int', so we have to get
506 // an int from stack even if we need a short
507 m_type = wxPAT_INT;
508 else if (ilen == 1)
509 m_type = wxPAT_LONGINT;
510 else if (ilen == 2)
511#if SIZEOF_LONG_LONG
512 m_type = wxPAT_LONGLONGINT;
513#else // !long long
514 m_type = wxPAT_LONGINT;
515#endif // long long/!long long
516 else if (ilen == 3)
517 m_type = wxPAT_SIZET;
518 done = true;
519 break;
520
521 case wxT('e'):
522 case wxT('E'):
523 case wxT('f'):
524 case wxT('g'):
525 case wxT('G'):
526 CHECK_PREC
527 m_szFlags[flagofs++] = char(ch);
528 m_szFlags[flagofs] = '\0';
529 if (ilen == 2)
530 m_type = wxPAT_LONGDOUBLE;
531 else
532 m_type = wxPAT_DOUBLE;
533 done = true;
534 break;
535
536 case wxT('p'):
537 m_type = wxPAT_POINTER;
538 m_szFlags[flagofs++] = char(ch);
539 m_szFlags[flagofs] = '\0';
540 done = true;
541 break;
542
543 case wxT('c'):
544 if (ilen == -1)
545 {
546 // in Unicode mode %hc == ANSI character
547 // and in ANSI mode, %hc == %c == ANSI...
548 m_type = wxPAT_CHAR;
549 }
550 else if (ilen == 1)
551 {
552 // in ANSI mode %lc == Unicode character
553 // and in Unicode mode, %lc == %c == Unicode...
554 m_type = wxPAT_WCHAR;
555 }
556 else
557 {
558#if wxUSE_UNICODE
559 // in Unicode mode, %c == Unicode character
560 m_type = wxPAT_WCHAR;
561#else
562 // in ANSI mode, %c == ANSI character
563 m_type = wxPAT_CHAR;
564#endif
565 }
566 done = true;
567 break;
568
569 case wxT('s'):
570 if (ilen == -1)
571 {
572 // Unicode mode wx extension: we'll let %hs mean non-Unicode
573 // strings (when in ANSI mode, %s == %hs == ANSI string)
574 m_type = wxPAT_PCHAR;
575 }
576 else if (ilen == 1)
577 {
578 // in Unicode mode, %ls == %s == Unicode string
579 // in ANSI mode, %ls == Unicode string
580 m_type = wxPAT_PWCHAR;
581 }
582 else
583 {
584#if wxUSE_UNICODE
585 m_type = wxPAT_PWCHAR;
586#else
587 m_type = wxPAT_PCHAR;
588#endif
589 }
590 done = true;
591 break;
592
593 case wxT('n'):
594 if (ilen == 0)
595 m_type = wxPAT_NINT;
596 else if (ilen == -1)
597 m_type = wxPAT_NSHORTINT;
598 else if (ilen >= 1)
599 m_type = wxPAT_NLONGINT;
600 done = true;
601 break;
602
603 default:
604 // bad format, don't consider this an argument;
605 // leave it unchanged
606 return false;
607 }
608
609 if (flagofs == wxMAX_SVNPRINTF_FLAGBUFFER_LEN)
610 {
611 wxLogDebug(wxT("Too many flags specified for a single conversion specifier!"));
612 return false;
613 }
614 }
615 while (!done);
616
617 return true; // parsing was successful
618}
619
620
621void wxPrintfConvSpec::ReplaceAsteriskWith(int width)
622{
623 char temp[wxMAX_SVNPRINTF_FLAGBUFFER_LEN];
624
625 // find the first * in our flag buffer
626 char *pwidth = strchr(m_szFlags, '*');
627 wxASSERT(pwidth);
628
629 // save what follows the * (the +1 is to skip the asterisk itself!)
630 strcpy(temp, pwidth+1);
631 if (width < 0)
632 {
633 pwidth[0] = wxT('-');
634 pwidth++;
635 }
636
637 // replace * with the actual integer given as width
638#ifndef SYSTEM_SPRINTF_IS_UNSAFE
639 int maxlen = (m_szFlags + wxMAX_SVNPRINTF_FLAGBUFFER_LEN - pwidth) /
640 sizeof(*m_szFlags);
641#endif
642 int offset = system_sprintf(pwidth, maxlen, "%d", abs(width));
643
644 // restore after the expanded * what was following it
645 strcpy(pwidth+offset, temp);
646}
647
648bool wxPrintfConvSpec::LoadArg(wxPrintfArg *p, va_list &argptr)
649{
650 // did the '*' width/precision specifier was used ?
651 if (m_nMaxWidth == -1)
652 {
653 // take the maxwidth specifier from the stack
654 m_nMaxWidth = va_arg(argptr, int);
655 if (m_nMaxWidth < 0)
656 m_nMaxWidth = 0;
657 else
658 ReplaceAsteriskWith(m_nMaxWidth);
659 }
660
661 if (m_nMinWidth == -1)
662 {
663 // take the minwidth specifier from the stack
664 m_nMinWidth = va_arg(argptr, int);
665
666 ReplaceAsteriskWith(m_nMinWidth);
667 if (m_nMinWidth < 0)
668 {
669 m_bAlignLeft = !m_bAlignLeft;
670 m_nMinWidth = -m_nMinWidth;
671 }
672 }
673
674 switch (m_type) {
675 case wxPAT_INT:
676 p->pad_int = va_arg(argptr, int);
677 break;
678 case wxPAT_LONGINT:
679 p->pad_longint = va_arg(argptr, long int);
680 break;
681#if SIZEOF_LONG_LONG
682 case wxPAT_LONGLONGINT:
683 p->pad_longlongint = va_arg(argptr, long long int);
684 break;
685#endif
686 case wxPAT_SIZET:
687 p->pad_sizet = va_arg(argptr, size_t);
688 break;
689 case wxPAT_DOUBLE:
690 p->pad_double = va_arg(argptr, double);
691 break;
692 case wxPAT_LONGDOUBLE:
693 p->pad_longdouble = va_arg(argptr, long double);
694 break;
695 case wxPAT_POINTER:
696 p->pad_pointer = va_arg(argptr, void *);
697 break;
698
699 case wxPAT_CHAR:
700 p->pad_char = (char)va_arg(argptr, int); // char is promoted to int when passed through '...'
701 break;
702 case wxPAT_WCHAR:
703 p->pad_wchar = (wchar_t)va_arg(argptr, int); // char is promoted to int when passed through '...'
704 break;
705
706 case wxPAT_PCHAR:
707 p->pad_pchar = va_arg(argptr, char *);
708 break;
709 case wxPAT_PWCHAR:
710 p->pad_pwchar = va_arg(argptr, wchar_t *);
711 break;
712
713 case wxPAT_NINT:
714 p->pad_nint = va_arg(argptr, int *);
715 break;
716 case wxPAT_NSHORTINT:
717 p->pad_nshortint = va_arg(argptr, short int *);
718 break;
719 case wxPAT_NLONGINT:
720 p->pad_nlongint = va_arg(argptr, long int *);
721 break;
722
723 case wxPAT_INVALID:
724 default:
725 return false;
726 }
727
728 return true; // loading was successful
729}
730
731int wxPrintfConvSpec::Process(wxChar *buf, size_t lenMax, wxPrintfArg *p, size_t written)
732{
733 // buffer to avoid dynamic memory allocation each time for small strings;
734 // note that this buffer is used only to hold results of number formatting,
735 // %s directly writes user's string in buf, without using szScratch
736 char szScratch[wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN];
737 size_t lenScratch = 0, lenCur = 0;
738
739#define APPEND_CH(ch) \
740 { \
741 if ( lenCur == lenMax ) \
742 return -1; \
743 \
744 buf[lenCur++] = ch; \
745 }
746
747#define APPEND_STR(s) \
748 { \
749 for ( const wxChar *p = s; *p; p++ ) \
750 { \
751 APPEND_CH(*p); \
752 } \
753 }
754
755 switch ( m_type )
756 {
757 case wxPAT_INT:
758 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_int);
759 break;
760
761 case wxPAT_LONGINT:
762 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longint);
763 break;
764
765#if SIZEOF_LONG_LONG
766 case wxPAT_LONGLONGINT:
767 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longlongint);
768 break;
769#endif // SIZEOF_LONG_LONG
770
771 case wxPAT_SIZET:
772 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_sizet);
773 break;
774
775 case wxPAT_LONGDOUBLE:
776 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_longdouble);
777 break;
778
779 case wxPAT_DOUBLE:
780 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_double);
781 break;
782
783 case wxPAT_POINTER:
784 lenScratch = system_sprintf(szScratch, wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN, m_szFlags, p->pad_pointer);
785 break;
786
787 case wxPAT_CHAR:
788 case wxPAT_WCHAR:
789 {
790 wxChar val =
791#if wxUSE_UNICODE
792 p->pad_wchar;
793
794 if (m_type == wxPAT_CHAR)
795 {
796 // user passed a character explicitely indicated as ANSI...
797 const char buf[2] = { p->pad_char, 0 };
798 val = wxString(buf, wxConvLibc)[0u];
799
800 //wprintf(L"converting ANSI=>Unicode"); // for debug
801 }
802#else
803 p->pad_char;
804
805#if wxUSE_WCHAR_T
806 if (m_type == wxPAT_WCHAR)
807 {
808 // user passed a character explicitely indicated as Unicode...
809 const wchar_t buf[2] = { p->pad_wchar, 0 };
810 val = wxString(buf, wxConvLibc)[0u];
811
812 //printf("converting Unicode=>ANSI"); // for debug
813 }
814#endif
815#endif
816
817 size_t i;
818
819 if (!m_bAlignLeft)
820 for (i = 1; i < (size_t)m_nMinWidth; i++)
821 APPEND_CH(_T(' '));
822
823 APPEND_CH(val);
824
825 if (m_bAlignLeft)
826 for (i = 1; i < (size_t)m_nMinWidth; i++)
827 APPEND_CH(_T(' '));
828 }
829 break;
830
831 case wxPAT_PCHAR:
832 case wxPAT_PWCHAR:
833 {
834 wxString s;
835 const wxChar *val =
836#if wxUSE_UNICODE
837 p->pad_pwchar;
838
839 if (m_type == wxPAT_PCHAR)
840 {
841 // user passed a string explicitely indicated as ANSI...
842 val = s = wxString(p->pad_pchar, wxConvLibc);
843
844 //wprintf(L"converting ANSI=>Unicode"); // for debug
845 }
846#else
847 p->pad_pchar;
848
849#if wxUSE_WCHAR_T
850 if (m_type == wxPAT_PWCHAR)
851 {
852 // user passed a string explicitely indicated as Unicode...
853 val = s = wxString(p->pad_pwchar, wxConvLibc);
854
855 //printf("converting Unicode=>ANSI"); // for debug
856 }
857#endif
858#endif
859 int len;
860
861 if (val)
862 {
863#if wxUSE_STRUTILS
864 // at this point we are sure that m_nMaxWidth is positive or null
865 // (see top of wxPrintfConvSpec::LoadArg)
866 len = wxMin((unsigned int)m_nMaxWidth, wxStrlen(val));
867#else
868 for ( len = 0; val[len] && (len < m_nMaxWidth); len++ )
869 ;
870#endif
871 }
872 else if (m_nMaxWidth >= 6)
873 {
874 val = wxT("(null)");
875 len = 6;
876 }
877 else
878 {
879 val = wxEmptyString;
880 len = 0;
881 }
882
883 int i;
884
885 if (!m_bAlignLeft)
886 {
887 for (i = len; i < m_nMinWidth; i++)
888 APPEND_CH(_T(' '));
889 }
890
891#if wxUSE_STRUTILS
892 len = wxMin((unsigned int)len, lenMax-lenCur);
893 wxStrncpy(buf+lenCur, val, len);
894 lenCur += len;
895#else
896 for (i = 0; i < len; i++)
897 APPEND_CH(val[i]);
898#endif
899
900 if (m_bAlignLeft)
901 {
902 for (i = len; i < m_nMinWidth; i++)
903 APPEND_CH(_T(' '));
904 }
905 }
906 break;
907
908 case wxPAT_NINT:
909 *p->pad_nint = written;
910 break;
911
912 case wxPAT_NSHORTINT:
913 *p->pad_nshortint = (short int)written;
914 break;
915
916 case wxPAT_NLONGINT:
917 *p->pad_nlongint = written;
918 break;
919
920 case wxPAT_INVALID:
921 default:
922 return -1;
923 }
924
925 // if we used system's sprintf() then we now need to append the s_szScratch
926 // buffer to the given one...
927 switch (m_type)
928 {
929 case wxPAT_INT:
930 case wxPAT_LONGINT:
931#if SIZEOF_LONG_LONG
932 case wxPAT_LONGLONGINT:
933#endif
934 case wxPAT_SIZET:
935 case wxPAT_LONGDOUBLE:
936 case wxPAT_DOUBLE:
937 case wxPAT_POINTER:
938 wxASSERT(lenScratch < wxMAX_SVNPRINTF_SCRATCHBUFFER_LEN);
939#if !wxUSE_UNICODE
940 {
941 if (lenMax < lenScratch)
942 {
943 // fill output buffer and then return -1
944 wxStrncpy(buf, szScratch, lenMax);
945 return -1;
946 }
947 wxStrncpy(buf, szScratch, lenScratch);
948 lenCur += lenScratch;
949 }
950#else
951 {
952 // Copy the char scratch to the wide output. This requires
953 // conversion, but we can optimise by making use of the fact
954 // that we are formatting numbers, this should mean only 7-bit
955 // ascii characters are involved.
956 wxChar *bufptr = buf;
957 const wxChar *bufend = buf + lenMax;
958 const char *scratchptr = szScratch;
959
960 // Simply copy each char to a wxChar, stopping on the first
961 // null or non-ascii byte. Checking '(signed char)*scratchptr
962 // > 0' is an extra optimisation over '*scratchptr != 0 &&
963 // isascii(*scratchptr)', though it assumes signed char is
964 // 8-bit 2 complement.
965 while ((signed char)*scratchptr > 0 && bufptr != bufend)
966 *bufptr++ = *scratchptr++;
967
968 if (bufptr == bufend)
969 return -1;
970
971 lenCur += bufptr - buf;
972
973 // check if the loop stopped on a non-ascii char, if yes then
974 // fall back to wxMB2WX
975 if (*scratchptr)
976 {
977 size_t len = wxMB2WX(bufptr, scratchptr, bufend - bufptr);
978
979 if (len && len != (size_t)(-1))
980 if (bufptr[len - 1])
981 return -1;
982 else
983 lenCur += len;
984 }
985 }
986#endif
987 break;
988
989 default:
990 break; // all other cases were completed previously
991 }
992
993 return lenCur;
994}
995
996// Copy chars from source to dest converting '%%' to '%'. Takes at most maxIn
997// chars from source and write at most outMax chars to dest, returns the
998// number of chars actually written. Does not treat null specially.
999//
1000static int wxCopyStrWithPercents(
1001 size_t maxOut,
1002 wxChar *dest,
1003 size_t maxIn,
1004 const wxChar *source)
1005{
1006 size_t written = 0;
1007
1008 if (maxIn == 0)
1009 return 0;
1010
1011 size_t i;
1012 for ( i = 0; i < maxIn-1 && written < maxOut; source++, i++)
1013 {
1014 dest[written++] = *source;
1015 if (*(source+1) == wxT('%'))
1016 {
1017 // skip this additional '%' character
1018 source++;
1019 i++;
1020 }
1021 }
1022
1023 if (i < maxIn && written < maxOut)
1024 // copy last character inconditionally
1025 dest[written++] = *source;
1026
1027 return written;
1028}
1029
1030int WXDLLEXPORT wxVsnprintf_(wxChar *buf, size_t lenMax,
1031 const wxChar *format, va_list argptr)
1032{
1033 // useful for debugging, to understand if we are really using this function
1034 // rather than the system implementation
1035#if 0
1036 wprintf(L"Using wxVsnprintf_\n");
1037#endif
1038
1039 // required memory:
1040 wxPrintfConvSpec arg[wxMAX_SVNPRINTF_ARGUMENTS];
1041 wxPrintfArg argdata[wxMAX_SVNPRINTF_ARGUMENTS];
1042 wxPrintfConvSpec *pspec[wxMAX_SVNPRINTF_ARGUMENTS] = { NULL };
1043
1044 size_t i;
1045
1046 // number of characters in the buffer so far, must be less than lenMax
1047 size_t lenCur = 0;
1048
1049 size_t nargs = 0;
1050 const wxChar *toparse = format;
1051
1052 // parse the format string
1053 bool posarg_present = false, nonposarg_present = false;
1054 for (; *toparse != wxT('\0'); toparse++)
1055 {
1056 if (*toparse == wxT('%') )
1057 {
1058 arg[nargs].Init();
1059
1060 // let's see if this is a (valid) conversion specifier...
1061 if (arg[nargs].Parse(toparse))
1062 {
1063 // ...yes it is
1064 wxPrintfConvSpec *current = &arg[nargs];
1065
1066 // make toparse point to the end of this specifier
1067 toparse = current->m_pArgEnd;
1068
1069 if (current->m_pos > 0)
1070 {
1071 // the positionals start from number 1... adjust the index
1072 current->m_pos--;
1073 posarg_present = true;
1074 }
1075 else
1076 {
1077 // not a positional argument...
1078 current->m_pos = nargs;
1079 nonposarg_present = true;
1080 }
1081
1082 // this conversion specifier is tied to the pos-th argument...
1083 pspec[current->m_pos] = current;
1084 nargs++;
1085
1086 if (nargs == wxMAX_SVNPRINTF_ARGUMENTS)
1087 {
1088 wxLogDebug(wxT("A single call to wxVsnprintf() has more than %d arguments; ")
1089 wxT("ignoring all remaining arguments."), wxMAX_SVNPRINTF_ARGUMENTS);
1090 break; // cannot handle any additional conv spec
1091 }
1092 }
1093 else
1094 {
1095 // it's safe to look in the next character of toparse as at worst
1096 // we'll hit its \0
1097 if (*(toparse+1) == wxT('%'))
1098 toparse++; // the Parse() returned false because we've found a %%
1099 }
1100 }
1101 }
1102
1103 if (posarg_present && nonposarg_present)
1104 {
1105 buf[0] = 0;
1106 return -1; // format strings with both positional and
1107 } // non-positional conversion specifier are unsupported !!
1108
1109 // on platforms where va_list is an array type, it is necessary to make a
1110 // copy to be able to pass it to LoadArg as a reference.
1111 bool ok = true;
1112 va_list ap;
1113 wxVaCopy(ap, argptr);
1114
1115 // now load arguments from stack
1116 for (i=0; i < nargs && ok; i++)
1117 {
1118 // !pspec[i] means that the user forgot a positional parameter (e.g. %$1s %$3s);
1119 // LoadArg == false means that wxPrintfConvSpec::Parse failed to set the
1120 // conversion specifier 'type' to a valid value...
1121 ok = pspec[i] && pspec[i]->LoadArg(&argdata[i], ap);
1122 }
1123
1124 va_end(ap);
1125
1126 // something failed while loading arguments from the variable list...
1127 if (!ok)
1128 {
1129 buf[0] = 0;
1130 return -1;
1131 }
1132
1133 // finally, process each conversion specifier with its own argument
1134 toparse = format;
1135 for (i=0; i < nargs; i++)
1136 {
1137 // copy in the output buffer the portion of the format string between
1138 // last specifier and the current one
1139 size_t tocopy = ( arg[i].m_pArgPos - toparse );
1140
1141 lenCur += wxCopyStrWithPercents(lenMax - lenCur, buf + lenCur,
1142 tocopy, toparse);
1143 if (lenCur == lenMax)
1144 {
1145 buf[lenMax - 1] = 0;
1146 return -1;
1147 }
1148
1149 // process this specifier directly in the output buffer
1150 int n = arg[i].Process(buf+lenCur, lenMax - lenCur, &argdata[arg[i].m_pos], lenCur);
1151 if (n == -1)
1152 {
1153 buf[lenMax-1] = wxT('\0'); // be sure to always NUL-terminate the string
1154 return -1; // not enough space in the output buffer !
1155 }
1156 lenCur += n;
1157
1158 // the +1 is because wxPrintfConvSpec::m_pArgEnd points to the last character
1159 // of the format specifier, but we are not interested to it...
1160 toparse = arg[i].m_pArgEnd + 1;
1161 }
1162
1163 // copy portion of the format string after last specifier
1164 // NOTE: toparse is pointing to the character just after the last processed
1165 // conversion specifier
1166 // NOTE2: the +1 is because we want to copy also the '\0'
1167 size_t tocopy = wxStrlen(format) + 1 - ( toparse - format ) ;
1168
1169 lenCur += wxCopyStrWithPercents(lenMax - lenCur, buf + lenCur,
1170 tocopy, toparse) - 1;
1171 if (buf[lenCur])
1172 {
1173 buf[lenCur] = 0;
1174 return -1;
1175 }
1176
1177 wxASSERT(lenCur == wxStrlen(buf));
1178 return lenCur;
1179}
1180
1181#undef APPEND_CH
1182#undef APPEND_STR
1183#undef CHECK_PREC
1184
1185#endif // !wxVsnprintfA
1186
1187#if !defined(wxSnprintf_)
1188int WXDLLEXPORT wxSnprintf_(wxChar *buf, size_t len, const wxChar *format, ...)
1189{
1190 va_list argptr;
1191 va_start(argptr, format);
1192
1193 int iLen = wxVsnprintf_(buf, len, format, argptr);
1194
1195 va_end(argptr);
1196
1197 return iLen;
1198}
1199#endif // wxSnprintf_
1200
1201#if defined(__DMC__)
1202 /* Digital Mars adds count to _stprintf (C99) so convert */
1203 #if wxUSE_UNICODE
1204 int wxSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... )
1205 {
1206 va_list arglist;
1207
1208 va_start( arglist, format );
1209 int iLen = swprintf ( s, -1, format, arglist );
1210 va_end( arglist );
1211 return iLen ;
1212 }
1213
1214 #endif // wxUSE_UNICODE
1215
1216#endif //__DMC__
1217
1218// ----------------------------------------------------------------------------
1219// implement the standard IO functions for wide char if libc doesn't have them
1220// ----------------------------------------------------------------------------
1221
1222#ifdef wxNEED_FPUTS
1223int wxFputs(const wchar_t *ws, FILE *stream)
1224{
1225 // counting the number of wide characters written isn't worth the trouble,
1226 // simply distinguish between ok and error
1227 return fputs(wxConvLibc.cWC2MB(ws), stream) == -1 ? -1 : 0;
1228}
1229#endif // wxNEED_FPUTS
1230
1231#ifdef wxNEED_PUTS
1232int wxPuts(const wxChar *ws)
1233{
1234 int rc = wxFputs(ws, stdout);
1235 if ( rc != -1 )
1236 {
1237 if ( wxFputs(L"\n", stdout) == -1 )
1238 return -1;
1239
1240 rc++;
1241 }
1242
1243 return rc;
1244}
1245#endif // wxNEED_PUTS
1246
1247#ifdef wxNEED_PUTC
1248int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
1249{
1250 wchar_t ws[2] = { wc, L'\0' };
1251
1252 return wxFputs(ws, stream);
1253}
1254#endif // wxNEED_PUTC
1255
1256// NB: we only implement va_list functions here, the ones taking ... are
1257// defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
1258// the definitions there to avoid duplicating them here
1259#ifdef wxNEED_WPRINTF
1260
1261// TODO: implement the scanf() functions
1262int vwscanf(const wxChar *format, va_list argptr)
1263{
1264 wxFAIL_MSG( _T("TODO") );
1265
1266 return -1;
1267}
1268
1269int vswscanf(const wxChar *ws, const wxChar *format, va_list argptr)
1270{
1271 // The best we can do without proper Unicode support in glibc is to
1272 // convert the strings into MB representation and run ANSI version
1273 // of the function. This doesn't work with %c and %s because of difference
1274 // in size of char and wchar_t, though.
1275
1276 wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
1277 _T("incomplete vswscanf implementation doesn't allow %s") );
1278 wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
1279 _T("incomplete vswscanf implementation doesn't allow %c") );
1280
1281 va_list argcopy;
1282 wxVaCopy(argcopy, argptr);
1283 return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argcopy);
1284}
1285
1286int vfwscanf(FILE *stream, const wxChar *format, va_list argptr)
1287{
1288 wxFAIL_MSG( _T("TODO") );
1289
1290 return -1;
1291}
1292
1293#define vswprintf wxVsnprintf_
1294
1295int vfwprintf(FILE *stream, const wxChar *format, va_list argptr)
1296{
1297 wxString s;
1298 int rc = s.PrintfV(format, argptr);
1299
1300 if ( rc != -1 )
1301 {
1302 // we can't do much better without Unicode support in libc...
1303 if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )
1304 return -1;
1305 }
1306
1307 return rc;
1308}
1309
1310int vwprintf(const wxChar *format, va_list argptr)
1311{
1312 return wxVfprintf(stdout, format, argptr);
1313}
1314
1315#endif // wxNEED_WPRINTF
1316
1317#ifdef wxNEED_PRINTF_CONVERSION
1318
1319// ----------------------------------------------------------------------------
1320// wxFormatConverter: class doing the "%s" -> "%ls" conversion
1321// ----------------------------------------------------------------------------
1322
1323/*
1324 Here are the gory details. We want to follow the Windows/MS conventions,
1325 that is to have
1326
1327 In ANSI mode:
1328
1329 format specifier results in
1330 -----------------------------------
1331 %c, %hc, %hC char
1332 %lc, %C, %lC wchar_t
1333
1334 In Unicode mode:
1335
1336 format specifier results in
1337 -----------------------------------
1338 %hc, %C, %hC char
1339 %c, %lc, %lC wchar_t
1340
1341
1342 while on POSIX systems we have %C identical to %lc and %c always means char
1343 (in any mode) while %lc always means wchar_t,
1344
1345 So to use native functions in order to get our semantics we must do the
1346 following translations in Unicode mode (nothing to do in ANSI mode):
1347
1348 wxWidgets specifier POSIX specifier
1349 ----------------------------------------
1350
1351 %hc, %C, %hC %c
1352 %c %lc
1353
1354
1355 And, of course, the same should be done for %s as well.
1356*/
1357
1358class wxFormatConverter
1359{
1360public:
1361 wxFormatConverter(const wxChar *format);
1362
1363 // notice that we only translated the string if m_fmtOrig == NULL (as set
1364 // by CopyAllBefore()), otherwise we should simply use the original format
1365 operator const wxChar *() const
1366 { return m_fmtOrig ? m_fmtOrig : m_fmt.c_str(); }
1367
1368private:
1369 // copy another character to the translated format: this function does the
1370 // copy if we are translating but doesn't do anything at all if we don't,
1371 // so we don't create the translated format string at all unless we really
1372 // need to (i.e. InsertFmtChar() is called)
1373 wxChar CopyFmtChar(wxChar ch)
1374 {
1375 if ( !m_fmtOrig )
1376 {
1377 // we're translating, do copy
1378 m_fmt += ch;
1379 }
1380 else
1381 {
1382 // simply increase the count which should be copied by
1383 // CopyAllBefore() later if needed
1384 m_nCopied++;
1385 }
1386
1387 return ch;
1388 }
1389
1390 // insert an extra character
1391 void InsertFmtChar(wxChar ch)
1392 {
1393 if ( m_fmtOrig )
1394 {
1395 // so far we haven't translated anything yet
1396 CopyAllBefore();
1397 }
1398
1399 m_fmt += ch;
1400 }
1401
1402 void CopyAllBefore()
1403 {
1404 wxASSERT_MSG( m_fmtOrig && m_fmt.empty(), _T("logic error") );
1405
1406 m_fmt = wxString(m_fmtOrig, m_nCopied);
1407
1408 // we won't need it any longer
1409 m_fmtOrig = NULL;
1410 }
1411
1412 static bool IsFlagChar(wxChar ch)
1413 {
1414 return ch == _T('-') || ch == _T('+') ||
1415 ch == _T('0') || ch == _T(' ') || ch == _T('#');
1416 }
1417
1418 void SkipDigits(const wxChar **ptpc)
1419 {
1420 while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
1421 CopyFmtChar(*(*ptpc)++);
1422 }
1423
1424 // the translated format
1425 wxString m_fmt;
1426
1427 // the original format
1428 const wxChar *m_fmtOrig;
1429
1430 // the number of characters already copied
1431 size_t m_nCopied;
1432};
1433
1434wxFormatConverter::wxFormatConverter(const wxChar *format)
1435{
1436 m_fmtOrig = format;
1437 m_nCopied = 0;
1438
1439 while ( *format )
1440 {
1441 if ( CopyFmtChar(*format++) == _T('%') )
1442 {
1443 // skip any flags
1444 while ( IsFlagChar(*format) )
1445 CopyFmtChar(*format++);
1446
1447 // and possible width
1448 if ( *format == _T('*') )
1449 CopyFmtChar(*format++);
1450 else
1451 SkipDigits(&format);
1452
1453 // precision?
1454 if ( *format == _T('.') )
1455 {
1456 CopyFmtChar(*format++);
1457 if ( *format == _T('*') )
1458 CopyFmtChar(*format++);
1459 else
1460 SkipDigits(&format);
1461 }
1462
1463 // next we can have a size modifier
1464 enum
1465 {
1466 Default,
1467 Short,
1468 Long
1469 } size;
1470
1471 switch ( *format )
1472 {
1473 case _T('h'):
1474 size = Short;
1475 format++;
1476 break;
1477
1478 case _T('l'):
1479 // "ll" has a different meaning!
1480 if ( format[1] != _T('l') )
1481 {
1482 size = Long;
1483 format++;
1484 break;
1485 }
1486 //else: fall through
1487
1488 default:
1489 size = Default;
1490 }
1491
1492 // and finally we should have the type
1493 switch ( *format )
1494 {
1495 case _T('C'):
1496 case _T('S'):
1497 // %C and %hC -> %c and %lC -> %lc
1498 if ( size == Long )
1499 CopyFmtChar(_T('l'));
1500
1501 InsertFmtChar(*format++ == _T('C') ? _T('c') : _T('s'));
1502 break;
1503
1504 case _T('c'):
1505 case _T('s'):
1506 // %c -> %lc but %hc stays %hc and %lc is still %lc
1507 if ( size == Default)
1508 InsertFmtChar(_T('l'));
1509 // fall through
1510
1511 default:
1512 // nothing special to do
1513 if ( size != Default )
1514 CopyFmtChar(*(format - 1));
1515 CopyFmtChar(*format++);
1516 }
1517 }
1518 }
1519}
1520
1521#else // !wxNEED_PRINTF_CONVERSION
1522 // no conversion necessary
1523 #define wxFormatConverter(x) (x)
1524#endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
1525
1526#ifdef __WXDEBUG__
1527// For testing the format converter
1528wxString wxConvertFormat(const wxChar *format)
1529{
1530 return wxString(wxFormatConverter(format));
1531}
1532#endif
1533
1534// ----------------------------------------------------------------------------
1535// wxPrintf(), wxScanf() and relatives
1536// ----------------------------------------------------------------------------
1537
1538#if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
1539
1540int wxScanf( const wxChar *format, ... )
1541{
1542 va_list argptr;
1543 va_start(argptr, format);
1544
1545 int ret = vwscanf(wxFormatConverter(format), argptr );
1546
1547 va_end(argptr);
1548
1549 return ret;
1550}
1551
1552int wxSscanf( const wxChar *str, const wxChar *format, ... )
1553{
1554 va_list argptr;
1555 va_start(argptr, format);
1556
1557 int ret = vswscanf( str, wxFormatConverter(format), argptr );
1558
1559 va_end(argptr);
1560
1561 return ret;
1562}
1563
1564int wxFscanf( FILE *stream, const wxChar *format, ... )
1565{
1566 va_list argptr;
1567 va_start(argptr, format);
1568 int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
1569
1570 va_end(argptr);
1571
1572 return ret;
1573}
1574
1575int wxPrintf( const wxChar *format, ... )
1576{
1577 va_list argptr;
1578 va_start(argptr, format);
1579
1580 int ret = vwprintf( wxFormatConverter(format), argptr );
1581
1582 va_end(argptr);
1583
1584 return ret;
1585}
1586
1587#ifndef wxSnprintf
1588int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... )
1589{
1590 va_list argptr;
1591 va_start(argptr, format);
1592
1593 int ret = vswprintf( str, size, wxFormatConverter(format), argptr );
1594
1595 // VsnprintfTestCase reveals that glibc's implementation of vswprintf
1596 // doesn't nul terminate on truncation.
1597 str[size - 1] = 0;
1598
1599 va_end(argptr);
1600
1601 return ret;
1602}
1603#endif // wxSnprintf
1604
1605int wxSprintf( wxChar *str, const wxChar *format, ... )
1606{
1607 va_list argptr;
1608 va_start(argptr, format);
1609
1610 // note that wxString::FormatV() uses wxVsnprintf(), not wxSprintf(), so
1611 // it's safe to implement this one in terms of it
1612 wxString s(wxString::FormatV(format, argptr));
1613 wxStrcpy(str, s);
1614
1615 va_end(argptr);
1616
1617 return s.length();
1618}
1619
1620int wxFprintf( FILE *stream, const wxChar *format, ... )
1621{
1622 va_list argptr;
1623 va_start( argptr, format );
1624
1625 int ret = vfwprintf( stream, wxFormatConverter(format), argptr );
1626
1627 va_end(argptr);
1628
1629 return ret;
1630}
1631
1632int wxVsscanf( const wxChar *str, const wxChar *format, va_list argptr )
1633{
1634 return vswscanf( str, wxFormatConverter(format), argptr );
1635}
1636
1637int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr )
1638{
1639 return vfwprintf( stream, wxFormatConverter(format), argptr );
1640}
1641
1642int wxVprintf( const wxChar *format, va_list argptr )
1643{
1644 return vwprintf( wxFormatConverter(format), argptr );
1645}
1646
1647#ifndef wxVsnprintf
1648int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr )
1649{
1650 return vswprintf( str, size, wxFormatConverter(format), argptr );
1651}
1652#endif // wxVsnprintf
1653
1654int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
1655{
1656 // same as for wxSprintf()
1657 return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);
1658}
1659
1660#endif // wxNEED_PRINTF_CONVERSION
1661
1662#if wxUSE_WCHAR_T
1663
1664// ----------------------------------------------------------------------------
1665// ctype.h stuff (currently unused)
1666// ----------------------------------------------------------------------------
1667
1668#if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
1669inline WORD wxMSW_ctype(wxChar ch)
1670{
1671 WORD ret;
1672 GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, &ch, 1, &ret);
1673 return ret;
1674}
1675
1676WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
1677WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }
1678WXDLLEXPORT int wxIscntrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
1679WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
1680WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
1681WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }
1682WXDLLEXPORT int wxIsprint(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_SPACE|C1_PUNCT|C1_ALPHA); }
1683WXDLLEXPORT int wxIspunct(wxChar ch) { return wxMSW_ctype(ch) & C1_PUNCT; }
1684WXDLLEXPORT int wxIsspace(wxChar ch) { return wxMSW_ctype(ch) & C1_SPACE; }
1685WXDLLEXPORT int wxIsupper(wxChar ch) { return IsCharUpper(ch); }
1686WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_XDIGIT; }
1687WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
1688WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
1689#endif
1690
1691#ifdef wxNEED_WX_MBSTOWCS
1692
1693WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
1694{
1695 if (!out)
1696 {
1697 size_t outsize = 0;
1698 while(*in++)
1699 outsize++;
1700 return outsize;
1701 }
1702
1703 const char* origin = in;
1704
1705 while (outlen-- && *in)
1706 {
1707 *out++ = (wchar_t) *in++;
1708 }
1709
1710 *out = '\0';
1711
1712 return in - origin;
1713}
1714
1715WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
1716{
1717 if (!out)
1718 {
1719 size_t outsize = 0;
1720 while(*in++)
1721 outsize++;
1722 return outsize;
1723 }
1724
1725 const wchar_t* origin = in;
1726
1727 while (outlen-- && *in)
1728 {
1729 *out++ = (char) *in++;
1730 }
1731
1732 *out = '\0';
1733
1734 return in - origin;
1735}
1736
1737#endif // wxNEED_WX_MBSTOWCS
1738
1739#if defined(wxNEED_WX_CTYPE_H)
1740
1741#include <CoreFoundation/CoreFoundation.h>
1742
1743#define cfalnumset CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric)
1744#define cfalphaset CFCharacterSetGetPredefined(kCFCharacterSetLetter)
1745#define cfcntrlset CFCharacterSetGetPredefined(kCFCharacterSetControl)
1746#define cfdigitset CFCharacterSetGetPredefined(kCFCharacterSetDecimalDigit)
1747//CFCharacterSetRef cfgraphset = kCFCharacterSetControl && !' '
1748#define cflowerset CFCharacterSetGetPredefined(kCFCharacterSetLowercaseLetter)
1749//CFCharacterSetRef cfprintset = !kCFCharacterSetControl
1750#define cfpunctset CFCharacterSetGetPredefined(kCFCharacterSetPunctuation)
1751#define cfspaceset CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline)
1752#define cfupperset CFCharacterSetGetPredefined(kCFCharacterSetUppercaseLetter)
1753
1754WXDLLEXPORT int wxIsalnum(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalnumset, ch); }
1755WXDLLEXPORT int wxIsalpha(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalphaset, ch); }
1756WXDLLEXPORT int wxIscntrl(wxChar ch) { return CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
1757WXDLLEXPORT int wxIsdigit(wxChar ch) { return CFCharacterSetIsCharacterMember(cfdigitset, ch); }
1758WXDLLEXPORT int wxIsgraph(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch) && ch != ' '; }
1759WXDLLEXPORT int wxIslower(wxChar ch) { return CFCharacterSetIsCharacterMember(cflowerset, ch); }
1760WXDLLEXPORT int wxIsprint(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
1761WXDLLEXPORT int wxIspunct(wxChar ch) { return CFCharacterSetIsCharacterMember(cfpunctset, ch); }
1762WXDLLEXPORT int wxIsspace(wxChar ch) { return CFCharacterSetIsCharacterMember(cfspaceset, ch); }
1763WXDLLEXPORT int wxIsupper(wxChar ch) { return CFCharacterSetIsCharacterMember(cfupperset, ch); }
1764WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxIsdigit(ch) || (ch>='a' && ch<='f') || (ch>='A' && ch<='F'); }
1765WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)tolower((char)(ch)); }
1766WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)toupper((char)(ch)); }
1767
1768#endif // wxNEED_WX_CTYPE_H
1769
1770#ifndef wxStrdupA
1771
1772WXDLLEXPORT char *wxStrdupA(const char *s)
1773{
1774 return strcpy((char *)malloc(strlen(s) + 1), s);
1775}
1776
1777#endif // wxStrdupA
1778
1779#ifndef wxStrdupW
1780
1781WXDLLEXPORT wchar_t * wxStrdupW(const wchar_t *pwz)
1782{
1783 size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
1784 wchar_t *ret = (wchar_t *) malloc(size);
1785 memcpy(ret, pwz, size);
1786 return ret;
1787}
1788
1789#endif // wxStrdupW
1790
1791#ifndef wxStricmp
1792int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
1793{
1794 register wxChar c1, c2;
1795 do {
1796 c1 = wxTolower(*psz1++);
1797 c2 = wxTolower(*psz2++);
1798 } while ( c1 && (c1 == c2) );
1799 return c1 - c2;
1800}
1801#endif
1802
1803#ifndef wxStricmp
1804int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
1805{
1806 // initialize the variables just to suppress stupid gcc warning
1807 register wxChar c1 = 0, c2 = 0;
1808 while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
1809 if (n) {
1810 if (c1 < c2) return -1;
1811 if (c1 > c2) return 1;
1812 }
1813 return 0;
1814}
1815#endif
1816
1817#ifndef wxSetlocale
1818WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
1819{
1820 char *localeOld = setlocale(category, wxConvLibc.cWX2MB(locale));
1821
1822 return wxWCharBuffer(wxConvLibc.cMB2WC(localeOld));
1823}
1824#endif
1825
1826#if wxUSE_WCHAR_T && !defined(HAVE_WCSLEN)
1827WXDLLEXPORT size_t wxWcslen(const wchar_t *s)
1828{
1829 size_t n = 0;
1830 while ( *s++ )
1831 n++;
1832
1833 return n;
1834}
1835#endif
1836
1837// ----------------------------------------------------------------------------
1838// string.h functions
1839// ----------------------------------------------------------------------------
1840
1841#ifdef wxNEED_WX_STRING_H
1842
1843// RN: These need to be c externed for the regex lib
1844#ifdef __cplusplus
1845extern "C" {
1846#endif
1847
1848WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src)
1849{
1850 wxChar *ret = dest;
1851 while (*dest) dest++;
1852 while ((*dest++ = *src++));
1853 return ret;
1854}
1855
1856WXDLLEXPORT const wxChar * wxStrchr(const wxChar *s, wxChar c)
1857{
1858 // be careful here as the terminating NUL makes part of the string
1859 while ( *s != c )
1860 {
1861 if ( !*s++ )
1862 return NULL;
1863 }
1864
1865 return s;
1866}
1867
1868WXDLLEXPORT int wxStrcmp(const wxChar *s1, const wxChar *s2)
1869{
1870 while ((*s1 == *s2) && *s1) s1++, s2++;
1871 if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
1872 if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
1873 return 0;
1874}
1875
1876WXDLLEXPORT wxChar * wxStrcpy(wxChar *dest, const wxChar *src)
1877{
1878 wxChar *ret = dest;
1879 while ((*dest++ = *src++));
1880 return ret;
1881}
1882
1883WXDLLEXPORT size_t wxStrlen_(const wxChar *s)
1884{
1885 size_t n = 0;
1886 while ( *s++ )
1887 n++;
1888
1889 return n;
1890}
1891
1892
1893WXDLLEXPORT wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n)
1894{
1895 wxChar *ret = dest;
1896 while (*dest) dest++;
1897 while (n && (*dest++ = *src++)) n--;
1898 return ret;
1899}
1900
1901WXDLLEXPORT int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n)
1902{
1903 while (n && (*s1 == *s2) && *s1) n--, s1++, s2++;
1904 if (n) {
1905 if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
1906 if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
1907 }
1908 return 0;
1909}
1910
1911WXDLLEXPORT wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n)
1912{
1913 wxChar *ret = dest;
1914 while (n && (*dest++ = *src++)) n--;
1915 while (n) *dest++=0, n--; // the docs specify padding with zeroes
1916 return ret;
1917}
1918
1919WXDLLEXPORT const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept)
1920{
1921 while (*s && !wxStrchr(accept, *s))
1922 s++;
1923
1924 return *s ? s : NULL;
1925}
1926
1927WXDLLEXPORT const wxChar * wxStrrchr(const wxChar *s, wxChar c)
1928{
1929 const wxChar *ret = NULL;
1930 do
1931 {
1932 if ( *s == c )
1933 ret = s;
1934 s++;
1935 }
1936 while ( *s );
1937
1938 return ret;
1939}
1940
1941WXDLLEXPORT size_t wxStrspn(const wxChar *s, const wxChar *accept)
1942{
1943 size_t len = 0;
1944 while (wxStrchr(accept, *s++)) len++;
1945 return len;
1946}
1947
1948WXDLLEXPORT const wxChar *wxStrstr(const wxChar *haystack, const wxChar *needle)
1949{
1950 wxASSERT_MSG( needle != NULL, _T("NULL argument in wxStrstr") );
1951
1952 // VZ: this is not exactly the most efficient string search algorithm...
1953
1954 const size_t len = wxStrlen(needle);
1955
1956 while ( const wxChar *fnd = wxStrchr(haystack, *needle) )
1957 {
1958 if ( !wxStrncmp(fnd, needle, len) )
1959 return fnd;
1960
1961 haystack = fnd + 1;
1962 }
1963
1964 return NULL;
1965}
1966
1967#ifdef __cplusplus
1968}
1969#endif
1970
1971WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr)
1972{
1973 const wxChar *start = nptr;
1974
1975 // FIXME: only correct for C locale
1976 while (wxIsspace(*nptr)) nptr++;
1977 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
1978 while (wxIsdigit(*nptr)) nptr++;
1979 if (*nptr == wxT('.')) {
1980 nptr++;
1981 while (wxIsdigit(*nptr)) nptr++;
1982 }
1983 if (*nptr == wxT('E') || *nptr == wxT('e')) {
1984 nptr++;
1985 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
1986 while (wxIsdigit(*nptr)) nptr++;
1987 }
1988
1989 wxString data(nptr, nptr-start);
1990 wxWX2MBbuf dat = data.mb_str(wxConvLibc);
1991 char *rdat = wxMBSTRINGCAST dat;
1992 double ret = strtod(dat, &rdat);
1993
1994 if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
1995
1996 return ret;
1997}
1998
1999WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
2000{
2001 const wxChar *start = nptr;
2002
2003 // FIXME: only correct for C locale
2004 while (wxIsspace(*nptr)) nptr++;
2005 if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
2006 if (((base == 0) || (base == 16)) &&
2007 (nptr[0] == wxT('0') && nptr[1] == wxT('x'))) {
2008 nptr += 2;
2009 base = 16;
2010 }
2011 else if ((base == 0) && (nptr[0] == wxT('0'))) base = 8;
2012 else if (base == 0) base = 10;
2013
2014 while ((wxIsdigit(*nptr) && (*nptr - wxT('0') < base)) ||
2015 (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
2016
2017 wxString data(start, nptr-start);
2018 wxWX2MBbuf dat = data.mb_str(wxConvLibc);
2019 char *rdat = wxMBSTRINGCAST dat;
2020 long int ret = strtol(dat, &rdat, base);
2021
2022 if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
2023
2024 return ret;
2025}
2026
2027WXDLLEXPORT unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base)
2028{
2029 return (unsigned long int) wxStrtol(nptr, endptr, base);
2030}
2031
2032#endif // wxNEED_WX_STRING_H
2033
2034#ifdef wxNEED_WX_STDIO_H
2035WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
2036{
2037 char mode_buffer[10];
2038 for (size_t i = 0; i < wxStrlen(mode)+1; i++)
2039 mode_buffer[i] = (char) mode[i];
2040
2041 return fopen( wxConvFile.cWX2MB(path), mode_buffer );
2042}
2043
2044WXDLLEXPORT FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream)
2045{
2046 char mode_buffer[10];
2047 for (size_t i = 0; i < wxStrlen(mode)+1; i++)
2048 mode_buffer[i] = (char) mode[i];
2049
2050 return freopen( wxConvFile.cWX2MB(path), mode_buffer, stream );
2051}
2052
2053WXDLLEXPORT int wxRemove(const wxChar *path)
2054{
2055 return remove( wxConvFile.cWX2MB(path) );
2056}
2057
2058WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
2059{
2060 return rename( wxConvFile.cWX2MB(oldpath), wxConvFile.cWX2MB(newpath) );
2061}
2062#endif
2063
2064#ifndef wxAtof
2065double WXDLLEXPORT wxAtof(const wxChar *psz)
2066{
2067#ifdef __WXWINCE__
2068 double d;
2069 wxString str(psz);
2070 if (str.ToDouble(& d))
2071 return d;
2072
2073 return 0.0;
2074#else
2075 return atof(wxConvLibc.cWX2MB(psz));
2076#endif
2077}
2078#endif
2079
2080#ifdef wxNEED_WX_STDLIB_H
2081int WXDLLEXPORT wxAtoi(const wxChar *psz)
2082{
2083 return atoi(wxConvLibc.cWX2MB(psz));
2084}
2085
2086long WXDLLEXPORT wxAtol(const wxChar *psz)
2087{
2088 return atol(wxConvLibc.cWX2MB(psz));
2089}
2090
2091wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
2092{
2093#if wxUSE_UNICODE
2094 // NB: buffer returned by getenv() is allowed to be overwritten next
2095 // time getenv() is called, so it is OK to use static string
2096 // buffer to hold the data.
2097 static wxWCharBuffer value((wxChar*)NULL);
2098 value = wxConvLibc.cMB2WX(getenv(wxConvLibc.cWX2MB(name)));
2099 return value.data();
2100#else
2101 return getenv(name);
2102#endif
2103}
2104
2105int WXDLLEXPORT wxSystem(const wxChar *psz)
2106{
2107 return system(wxConvLibc.cWX2MB(psz));
2108}
2109
2110#endif // wxNEED_WX_STDLIB_H
2111
2112#ifdef wxNEED_WX_TIME_H
2113WXDLLEXPORT size_t
2114wxStrftime(wxChar *s, size_t maxsize, const wxChar *fmt, const struct tm *tm)
2115{
2116 if ( !maxsize )
2117 return 0;
2118
2119 wxCharBuffer buf(maxsize);
2120
2121 wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt));
2122 if ( !bufFmt )
2123 return 0;
2124
2125 size_t ret = strftime(buf.data(), maxsize, bufFmt, tm);
2126 if ( !ret )
2127 return 0;
2128
2129 wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf);
2130 if ( !wbuf )
2131 return 0;
2132
2133 wxStrncpy(s, wbuf, maxsize);
2134 return wxStrlen(s);
2135}
2136#endif // wxNEED_WX_TIME_H
2137
2138#ifndef wxCtime
2139WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
2140{
2141 // normally the string is 26 chars but give one more in case some broken
2142 // DOS compiler decides to use "\r\n" instead of "\n" at the end
2143 static wxChar buf[27];
2144
2145 // ctime() is guaranteed to return a string containing only ASCII
2146 // characters, as its format is always the same for any locale
2147 wxStrncpy(buf, wxString::FromAscii(ctime(timep)), WXSIZEOF(buf));
2148 buf[WXSIZEOF(buf) - 1] = _T('\0');
2149
2150 return buf;
2151}
2152#endif // wxCtime
2153
2154#endif // wxUSE_WCHAR_T
2155
2156// ----------------------------------------------------------------------------
2157// functions which we may need even if !wxUSE_WCHAR_T
2158// ----------------------------------------------------------------------------
2159
2160#ifndef wxStrtok
2161
2162WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
2163{
2164 if (!psz)
2165 {
2166 psz = *save_ptr;
2167 if ( !psz )
2168 return NULL;
2169 }
2170
2171 psz += wxStrspn(psz, delim);
2172 if (!*psz)
2173 {
2174 *save_ptr = (wxChar *)NULL;
2175 return (wxChar *)NULL;
2176 }
2177
2178 wxChar *ret = psz;
2179 psz = wxStrpbrk(psz, delim);
2180 if (!psz)
2181 {
2182 *save_ptr = (wxChar*)NULL;
2183 }
2184 else
2185 {
2186 *psz = wxT('\0');
2187 *save_ptr = psz + 1;
2188 }
2189
2190 return ret;
2191}
2192
2193#endif // wxStrtok
2194
2195// ----------------------------------------------------------------------------
2196// missing C RTL functions
2197// ----------------------------------------------------------------------------
2198
2199#ifdef wxNEED_STRDUP
2200
2201char *strdup(const char *s)
2202{
2203 char *dest = (char*) malloc( strlen( s ) + 1 ) ;
2204 if ( dest )
2205 strcpy( dest , s ) ;
2206 return dest ;
2207}
2208#endif // wxNEED_STRDUP
2209
2210#if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
2211
2212void *calloc( size_t num, size_t size )
2213{
2214 void** ptr = (void **)malloc(num * size);
2215 memset( ptr, 0, num * size);
2216 return ptr;
2217}
2218
2219#endif // __WXWINCE__ <= 211
2220
2221#ifdef __WXWINCE__
2222
2223int wxRemove(const wxChar *path)
2224{
2225 return ::DeleteFile(path) == 0;
2226}
2227
2228#endif
wxWidgets (Impactor)