src/common/wxchar.cpp

   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
  54 namespace std {}
  55 using namespace std ;
  56 #endif
  57
  58 #if wxUSE_WCHAR_T
  59 size_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
  92 size_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
 120 bool 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_
 211 enum 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_
 238 typedef 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...
 267 class wxPrintfConvSpec
 268 {
 269 public:
 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
 305 public:
 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
 325 private:
 326     // An helper function of LoadArg() which is used to handle the '*' flag
 327     void ReplaceAsteriskWith(int w);
 328 };
 329
 330 void 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
 344 bool 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
 621 void 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     wxCHECK_RET(pwidth, _T("field width must be specified"));
 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
 648 bool 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
 731 int 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 //
1000 static 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
1030 int 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_)
1188 int 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
1223 int wxFputs(const wchar_t *ws, FILE *stream)
1224 {
1225     wxCharBuffer buf(wxConvLibc.cWC2MB(ws));
1226     if ( !buf )
1227         return -1;
1228
1229     // counting the number of wide characters written isn't worth the trouble,
1230     // simply distinguish between ok and error
1231     return fputs(buf, stream) == -1 ? -1 : 0;
1232 }
1233 #endif // wxNEED_FPUTS
1234
1235 #ifdef wxNEED_PUTS
1236 int wxPuts(const wxChar *ws)
1237 {
1238     int rc = wxFputs(ws, stdout);
1239     if ( rc != -1 )
1240     {
1241         if ( wxFputs(L"\n", stdout) == -1 )
1242             return -1;
1243
1244         rc++;
1245     }
1246
1247     return rc;
1248 }
1249 #endif // wxNEED_PUTS
1250
1251 #ifdef wxNEED_PUTC
1252 int /* not wint_t */ wxPutc(wchar_t wc, FILE *stream)
1253 {
1254     wchar_t ws[2] = { wc, L'\0' };
1255
1256     return wxFputs(ws, stream);
1257 }
1258 #endif // wxNEED_PUTC
1259
1260 // NB: we only implement va_list functions here, the ones taking ... are
1261 //     defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
1262 //     the definitions there to avoid duplicating them here
1263 #ifdef wxNEED_WPRINTF
1264
1265 // TODO: implement the scanf() functions
1266 int vwscanf(const wxChar *format, va_list argptr)
1267 {
1268     wxFAIL_MSG( _T("TODO") );
1269
1270     return -1;
1271 }
1272
1273 int vswscanf(const wxChar *ws, const wxChar *format, va_list argptr)
1274 {
1275     // The best we can do without proper Unicode support in glibc is to
1276     // convert the strings into MB representation and run ANSI version
1277     // of the function. This doesn't work with %c and %s because of difference
1278     // in size of char and wchar_t, though.
1279
1280     wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
1281                  _T("incomplete vswscanf implementation doesn't allow %s") );
1282     wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
1283                  _T("incomplete vswscanf implementation doesn't allow %c") );
1284
1285     va_list argcopy;
1286     wxVaCopy(argcopy, argptr);
1287     return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argcopy);
1288 }
1289
1290 int vfwscanf(FILE *stream, const wxChar *format, va_list argptr)
1291 {
1292     wxFAIL_MSG( _T("TODO") );
1293
1294     return -1;
1295 }
1296
1297 #define vswprintf wxVsnprintf_
1298
1299 int vfwprintf(FILE *stream, const wxChar *format, va_list argptr)
1300 {
1301     wxString s;
1302     int rc = s.PrintfV(format, argptr);
1303
1304     if ( rc != -1 )
1305     {
1306         // we can't do much better without Unicode support in libc...
1307         if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )
1308             return -1;
1309     }
1310
1311     return rc;
1312 }
1313
1314 int vwprintf(const wxChar *format, va_list argptr)
1315 {
1316     return wxVfprintf(stdout, format, argptr);
1317 }
1318
1319 #endif // wxNEED_WPRINTF
1320
1321 #ifdef wxNEED_PRINTF_CONVERSION
1322
1323 // ----------------------------------------------------------------------------
1324 // wxFormatConverter: class doing the "%s" -> "%ls" conversion
1325 // ----------------------------------------------------------------------------
1326
1327 /*
1328    Here are the gory details. We want to follow the Windows/MS conventions,
1329    that is to have
1330
1331    In ANSI mode:
1332
1333    format specifier         results in
1334    -----------------------------------
1335    %c, %hc, %hC             char
1336    %lc, %C, %lC             wchar_t
1337
1338    In Unicode mode:
1339
1340    format specifier         results in
1341    -----------------------------------
1342    %hc, %C, %hC             char
1343    %c, %lc, %lC             wchar_t
1344
1345
1346    while on POSIX systems we have %C identical to %lc and %c always means char
1347    (in any mode) while %lc always means wchar_t,
1348
1349    So to use native functions in order to get our semantics we must do the
1350    following translations in Unicode mode (nothing to do in ANSI mode):
1351
1352    wxWidgets specifier      POSIX specifier
1353    ----------------------------------------
1354
1355    %hc, %C, %hC             %c
1356    %c                       %lc
1357
1358
1359    And, of course, the same should be done for %s as well.
1360 */
1361
1362 class wxFormatConverter
1363 {
1364 public:
1365     wxFormatConverter(const wxChar *format);
1366
1367     // notice that we only translated the string if m_fmtOrig == NULL (as set
1368     // by CopyAllBefore()), otherwise we should simply use the original format
1369     operator const wxChar *() const
1370         { return m_fmtOrig ? m_fmtOrig : m_fmt.c_str(); }
1371
1372 private:
1373     // copy another character to the translated format: this function does the
1374     // copy if we are translating but doesn't do anything at all if we don't,
1375     // so we don't create the translated format string at all unless we really
1376     // need to (i.e. InsertFmtChar() is called)
1377     wxChar CopyFmtChar(wxChar ch)
1378     {
1379         if ( !m_fmtOrig )
1380         {
1381             // we're translating, do copy
1382             m_fmt += ch;
1383         }
1384         else
1385         {
1386             // simply increase the count which should be copied by
1387             // CopyAllBefore() later if needed
1388             m_nCopied++;
1389         }
1390
1391         return ch;
1392     }
1393
1394     // insert an extra character
1395     void InsertFmtChar(wxChar ch)
1396     {
1397         if ( m_fmtOrig )
1398         {
1399             // so far we haven't translated anything yet
1400             CopyAllBefore();
1401         }
1402
1403         m_fmt += ch;
1404     }
1405
1406     void CopyAllBefore()
1407     {
1408         wxASSERT_MSG( m_fmtOrig && m_fmt.empty(), _T("logic error") );
1409
1410         m_fmt = wxString(m_fmtOrig, m_nCopied);
1411
1412         // we won't need it any longer
1413         m_fmtOrig = NULL;
1414     }
1415
1416     static bool IsFlagChar(wxChar ch)
1417     {
1418         return ch == _T('-') || ch == _T('+') ||
1419                ch == _T('0') || ch == _T(' ') || ch == _T('#');
1420     }
1421
1422     void SkipDigits(const wxChar **ptpc)
1423     {
1424         while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
1425             CopyFmtChar(*(*ptpc)++);
1426     }
1427
1428     // the translated format
1429     wxString m_fmt;
1430
1431     // the original format
1432     const wxChar *m_fmtOrig;
1433
1434     // the number of characters already copied
1435     size_t m_nCopied;
1436 };
1437
1438 wxFormatConverter::wxFormatConverter(const wxChar *format)
1439 {
1440     m_fmtOrig = format;
1441     m_nCopied = 0;
1442
1443     while ( *format )
1444     {
1445         if ( CopyFmtChar(*format++) == _T('%') )
1446         {
1447             // skip any flags
1448             while ( IsFlagChar(*format) )
1449                 CopyFmtChar(*format++);
1450
1451             // and possible width
1452             if ( *format == _T('*') )
1453                 CopyFmtChar(*format++);
1454             else
1455                 SkipDigits(&format);
1456
1457             // precision?
1458             if ( *format == _T('.') )
1459             {
1460                 CopyFmtChar(*format++);
1461                 if ( *format == _T('*') )
1462                     CopyFmtChar(*format++);
1463                 else
1464                     SkipDigits(&format);
1465             }
1466
1467             // next we can have a size modifier
1468             enum
1469             {
1470                 Default,
1471                 Short,
1472                 Long
1473             } size;
1474
1475             switch ( *format )
1476             {
1477                 case _T('h'):
1478                     size = Short;
1479                     format++;
1480                     break;
1481
1482                 case _T('l'):
1483                     // "ll" has a different meaning!
1484                     if ( format[1] != _T('l') )
1485                     {
1486                         size = Long;
1487                         format++;
1488                         break;
1489                     }
1490                     //else: fall through
1491
1492                 default:
1493                     size = Default;
1494             }
1495
1496             // and finally we should have the type
1497             switch ( *format )
1498             {
1499                 case _T('C'):
1500                 case _T('S'):
1501                     // %C and %hC -> %c and %lC -> %lc
1502                     if ( size == Long )
1503                         CopyFmtChar(_T('l'));
1504
1505                     InsertFmtChar(*format++ == _T('C') ? _T('c') : _T('s'));
1506                     break;
1507
1508                 case _T('c'):
1509                 case _T('s'):
1510                     // %c -> %lc but %hc stays %hc and %lc is still %lc
1511                     if ( size == Default)
1512                         InsertFmtChar(_T('l'));
1513                     // fall through
1514
1515                 default:
1516                     // nothing special to do
1517                     if ( size != Default )
1518                         CopyFmtChar(*(format - 1));
1519                     CopyFmtChar(*format++);
1520             }
1521         }
1522     }
1523 }
1524
1525 #else // !wxNEED_PRINTF_CONVERSION
1526     // no conversion necessary
1527     #define wxFormatConverter(x) (x)
1528 #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
1529
1530 #ifdef __WXDEBUG__
1531 // For testing the format converter
1532 wxString wxConvertFormat(const wxChar *format)
1533 {
1534     return wxString(wxFormatConverter(format));
1535 }
1536 #endif
1537
1538 // ----------------------------------------------------------------------------
1539 // wxPrintf(), wxScanf() and relatives
1540 // ----------------------------------------------------------------------------
1541
1542 #if defined(wxNEED_PRINTF_CONVERSION) || defined(wxNEED_WPRINTF)
1543
1544 int wxScanf( const wxChar *format, ... )
1545 {
1546     va_list argptr;
1547     va_start(argptr, format);
1548
1549     int ret = vwscanf(wxFormatConverter(format), argptr );
1550
1551     va_end(argptr);
1552
1553     return ret;
1554 }
1555
1556 int wxSscanf( const wxChar *str, const wxChar *format, ... )
1557 {
1558     va_list argptr;
1559     va_start(argptr, format);
1560
1561     int ret = vswscanf( str, wxFormatConverter(format), argptr );
1562
1563     va_end(argptr);
1564
1565     return ret;
1566 }
1567
1568 int wxFscanf( FILE *stream, const wxChar *format, ... )
1569 {
1570     va_list argptr;
1571     va_start(argptr, format);
1572     int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
1573
1574     va_end(argptr);
1575
1576     return ret;
1577 }
1578
1579 int wxPrintf( const wxChar *format, ... )
1580 {
1581     va_list argptr;
1582     va_start(argptr, format);
1583
1584     int ret = vwprintf( wxFormatConverter(format), argptr );
1585
1586     va_end(argptr);
1587
1588     return ret;
1589 }
1590
1591 #ifndef wxSnprintf
1592 int wxSnprintf( wxChar *str, size_t size, const wxChar *format, ... )
1593 {
1594     va_list argptr;
1595     va_start(argptr, format);
1596
1597     int ret = vswprintf( str, size, wxFormatConverter(format), argptr );
1598
1599     // VsnprintfTestCase reveals that glibc's implementation of vswprintf
1600     // doesn't nul terminate on truncation.
1601     str[size - 1] = 0;
1602
1603     va_end(argptr);
1604
1605     return ret;
1606 }
1607 #endif // wxSnprintf
1608
1609 int wxSprintf( wxChar *str, const wxChar *format, ... )
1610 {
1611     va_list argptr;
1612     va_start(argptr, format);
1613
1614     // note that wxString::FormatV() uses wxVsnprintf(), not wxSprintf(), so
1615     // it's safe to implement this one in terms of it
1616     wxString s(wxString::FormatV(format, argptr));
1617     wxStrcpy(str, s);
1618
1619     va_end(argptr);
1620
1621     return s.length();
1622 }
1623
1624 int wxFprintf( FILE *stream, const wxChar *format, ... )
1625 {
1626     va_list argptr;
1627     va_start( argptr, format );
1628
1629     int ret = vfwprintf( stream, wxFormatConverter(format), argptr );
1630
1631     va_end(argptr);
1632
1633     return ret;
1634 }
1635
1636 int wxVsscanf( const wxChar *str, const wxChar *format, va_list argptr )
1637 {
1638     return vswscanf( str, wxFormatConverter(format), argptr );
1639 }
1640
1641 int wxVfprintf( FILE *stream, const wxChar *format, va_list argptr )
1642 {
1643     return vfwprintf( stream, wxFormatConverter(format), argptr );
1644 }
1645
1646 int wxVprintf( const wxChar *format, va_list argptr )
1647 {
1648     return vwprintf( wxFormatConverter(format), argptr );
1649 }
1650
1651 #ifndef wxVsnprintf
1652 int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr )
1653 {
1654     return vswprintf( str, size, wxFormatConverter(format), argptr );
1655 }
1656 #endif // wxVsnprintf
1657
1658 int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
1659 {
1660     // same as for wxSprintf()
1661     return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);
1662 }
1663
1664 #endif // wxNEED_PRINTF_CONVERSION
1665
1666 #if wxUSE_WCHAR_T
1667
1668 // ----------------------------------------------------------------------------
1669 // ctype.h stuff (currently unused)
1670 // ----------------------------------------------------------------------------
1671
1672 #if defined(__WIN32__) && defined(wxNEED_WX_CTYPE_H)
1673 inline WORD wxMSW_ctype(wxChar ch)
1674 {
1675   WORD ret;
1676   GetStringTypeEx(LOCALE_USER_DEFAULT, CT_CTYPE1, &ch, 1, &ret);
1677   return ret;
1678 }
1679
1680 WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
1681 WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }
1682 WXDLLEXPORT int wxIscntrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
1683 WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
1684 WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
1685 WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }
1686 WXDLLEXPORT int wxIsprint(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_SPACE|C1_PUNCT|C1_ALPHA); }
1687 WXDLLEXPORT int wxIspunct(wxChar ch) { return wxMSW_ctype(ch) & C1_PUNCT; }
1688 WXDLLEXPORT int wxIsspace(wxChar ch) { return wxMSW_ctype(ch) & C1_SPACE; }
1689 WXDLLEXPORT int wxIsupper(wxChar ch) { return IsCharUpper(ch); }
1690 WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_XDIGIT; }
1691 WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
1692 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
1693 #endif
1694
1695 #ifdef wxNEED_WX_MBSTOWCS
1696
1697 WXDLLEXPORT size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
1698 {
1699     if (!out)
1700     {
1701         size_t outsize = 0;
1702         while(*in++)
1703             outsize++;
1704         return outsize;
1705     }
1706
1707     const char* origin = in;
1708
1709     while (outlen-- && *in)
1710     {
1711         *out++ = (wchar_t) *in++;
1712     }
1713
1714     *out = '\0';
1715
1716     return in - origin;
1717 }
1718
1719 WXDLLEXPORT size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
1720 {
1721     if (!out)
1722     {
1723         size_t outsize = 0;
1724         while(*in++)
1725             outsize++;
1726         return outsize;
1727     }
1728
1729     const wchar_t* origin = in;
1730
1731     while (outlen-- && *in)
1732     {
1733         *out++ = (char) *in++;
1734     }
1735
1736     *out = '\0';
1737
1738     return in - origin;
1739 }
1740
1741 #endif // wxNEED_WX_MBSTOWCS
1742
1743 #if defined(wxNEED_WX_CTYPE_H)
1744
1745 #include <CoreFoundation/CoreFoundation.h>
1746
1747 #define cfalnumset CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric)
1748 #define cfalphaset CFCharacterSetGetPredefined(kCFCharacterSetLetter)
1749 #define cfcntrlset CFCharacterSetGetPredefined(kCFCharacterSetControl)
1750 #define cfdigitset CFCharacterSetGetPredefined(kCFCharacterSetDecimalDigit)
1751 //CFCharacterSetRef cfgraphset = kCFCharacterSetControl && !' '
1752 #define cflowerset CFCharacterSetGetPredefined(kCFCharacterSetLowercaseLetter)
1753 //CFCharacterSetRef cfprintset = !kCFCharacterSetControl
1754 #define cfpunctset CFCharacterSetGetPredefined(kCFCharacterSetPunctuation)
1755 #define cfspaceset CFCharacterSetGetPredefined(kCFCharacterSetWhitespaceAndNewline)
1756 #define cfupperset CFCharacterSetGetPredefined(kCFCharacterSetUppercaseLetter)
1757
1758 WXDLLEXPORT int wxIsalnum(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalnumset, ch); }
1759 WXDLLEXPORT int wxIsalpha(wxChar ch) { return CFCharacterSetIsCharacterMember(cfalphaset, ch); }
1760 WXDLLEXPORT int wxIscntrl(wxChar ch) { return CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
1761 WXDLLEXPORT int wxIsdigit(wxChar ch) { return CFCharacterSetIsCharacterMember(cfdigitset, ch); }
1762 WXDLLEXPORT int wxIsgraph(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch) && ch != ' '; }
1763 WXDLLEXPORT int wxIslower(wxChar ch) { return CFCharacterSetIsCharacterMember(cflowerset, ch); }
1764 WXDLLEXPORT int wxIsprint(wxChar ch) { return !CFCharacterSetIsCharacterMember(cfcntrlset, ch); }
1765 WXDLLEXPORT int wxIspunct(wxChar ch) { return CFCharacterSetIsCharacterMember(cfpunctset, ch); }
1766 WXDLLEXPORT int wxIsspace(wxChar ch) { return CFCharacterSetIsCharacterMember(cfspaceset, ch); }
1767 WXDLLEXPORT int wxIsupper(wxChar ch) { return CFCharacterSetIsCharacterMember(cfupperset, ch); }
1768 WXDLLEXPORT int wxIsxdigit(wxChar ch) { return wxIsdigit(ch) || (ch>='a' && ch<='f') || (ch>='A' && ch<='F'); }
1769 WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)tolower((char)(ch)); }
1770 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)toupper((char)(ch)); }
1771
1772 #endif  // wxNEED_WX_CTYPE_H
1773
1774 #ifndef wxStrdupA
1775
1776 WXDLLEXPORT char *wxStrdupA(const char *s)
1777 {
1778     return strcpy((char *)malloc(strlen(s) + 1), s);
1779 }
1780
1781 #endif // wxStrdupA
1782
1783 #ifndef wxStrdupW
1784
1785 WXDLLEXPORT wchar_t * wxStrdupW(const wchar_t *pwz)
1786 {
1787   size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
1788   wchar_t *ret = (wchar_t *) malloc(size);
1789   memcpy(ret, pwz, size);
1790   return ret;
1791 }
1792
1793 #endif // wxStrdupW
1794
1795 #ifndef wxStricmp
1796 int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
1797 {
1798   register wxChar c1, c2;
1799   do {
1800     c1 = wxTolower(*psz1++);
1801     c2 = wxTolower(*psz2++);
1802   } while ( c1 && (c1 == c2) );
1803   return c1 - c2;
1804 }
1805 #endif
1806
1807 #ifndef wxStricmp
1808 int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
1809 {
1810   // initialize the variables just to suppress stupid gcc warning
1811   register wxChar c1 = 0, c2 = 0;
1812   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
1813   if (n) {
1814     if (c1 < c2) return -1;
1815     if (c1 > c2) return 1;
1816   }
1817   return 0;
1818 }
1819 #endif
1820
1821 #ifndef wxSetlocale
1822 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
1823 {
1824     char *localeOld = setlocale(category, wxConvLibc.cWX2MB(locale));
1825
1826     return wxWCharBuffer(wxConvLibc.cMB2WC(localeOld));
1827 }
1828 #endif
1829
1830 #if wxUSE_WCHAR_T && !defined(HAVE_WCSLEN)
1831 WXDLLEXPORT size_t wxWcslen(const wchar_t *s)
1832 {
1833     size_t n = 0;
1834     while ( *s++ )
1835         n++;
1836
1837     return n;
1838 }
1839 #endif
1840
1841 // ----------------------------------------------------------------------------
1842 // string.h functions
1843 // ----------------------------------------------------------------------------
1844
1845 #ifdef wxNEED_WX_STRING_H
1846
1847 // RN:  These need to be c externed for the regex lib
1848 #ifdef __cplusplus
1849 extern "C" {
1850 #endif
1851
1852 WXDLLEXPORT wxChar * wxStrcat(wxChar *dest, const wxChar *src)
1853 {
1854   wxChar *ret = dest;
1855   while (*dest) dest++;
1856   while ((*dest++ = *src++));
1857   return ret;
1858 }
1859
1860 WXDLLEXPORT const wxChar * wxStrchr(const wxChar *s, wxChar c)
1861 {
1862     // be careful here as the terminating NUL makes part of the string
1863     while ( *s != c )
1864     {
1865         if ( !*s++ )
1866             return NULL;
1867     }
1868
1869     return s;
1870 }
1871
1872 WXDLLEXPORT int wxStrcmp(const wxChar *s1, const wxChar *s2)
1873 {
1874   while ((*s1 == *s2) && *s1) s1++, s2++;
1875   if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
1876   if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
1877   return 0;
1878 }
1879
1880 WXDLLEXPORT wxChar * wxStrcpy(wxChar *dest, const wxChar *src)
1881 {
1882   wxChar *ret = dest;
1883   while ((*dest++ = *src++));
1884   return ret;
1885 }
1886
1887 WXDLLEXPORT size_t wxStrlen_(const wxChar *s)
1888 {
1889     size_t n = 0;
1890     while ( *s++ )
1891         n++;
1892
1893     return n;
1894 }
1895
1896
1897 WXDLLEXPORT wxChar * wxStrncat(wxChar *dest, const wxChar *src, size_t n)
1898 {
1899   wxChar *ret = dest;
1900   while (*dest) dest++;
1901   while (n && (*dest++ = *src++)) n--;
1902   return ret;
1903 }
1904
1905 WXDLLEXPORT int wxStrncmp(const wxChar *s1, const wxChar *s2, size_t n)
1906 {
1907   while (n && (*s1 == *s2) && *s1) n--, s1++, s2++;
1908   if (n) {
1909     if ((wxUChar)*s1 < (wxUChar)*s2) return -1;
1910     if ((wxUChar)*s1 > (wxUChar)*s2) return 1;
1911   }
1912   return 0;
1913 }
1914
1915 WXDLLEXPORT wxChar * wxStrncpy(wxChar *dest, const wxChar *src, size_t n)
1916 {
1917   wxChar *ret = dest;
1918   while (n && (*dest++ = *src++)) n--;
1919   while (n) *dest++=0, n--; // the docs specify padding with zeroes
1920   return ret;
1921 }
1922
1923 WXDLLEXPORT const wxChar * wxStrpbrk(const wxChar *s, const wxChar *accept)
1924 {
1925   while (*s && !wxStrchr(accept, *s))
1926       s++;
1927
1928   return *s ? s : NULL;
1929 }
1930
1931 WXDLLEXPORT const wxChar * wxStrrchr(const wxChar *s, wxChar c)
1932 {
1933     const wxChar *ret = NULL;
1934     do
1935     {
1936         if ( *s == c )
1937             ret = s;
1938         s++;
1939     }
1940     while ( *s );
1941
1942     return ret;
1943 }
1944
1945 WXDLLEXPORT size_t wxStrspn(const wxChar *s, const wxChar *accept)
1946 {
1947   size_t len = 0;
1948   while (wxStrchr(accept, *s++)) len++;
1949   return len;
1950 }
1951
1952 WXDLLEXPORT const wxChar *wxStrstr(const wxChar *haystack, const wxChar *needle)
1953 {
1954     wxASSERT_MSG( needle != NULL, _T("NULL argument in wxStrstr") );
1955
1956     // VZ: this is not exactly the most efficient string search algorithm...
1957
1958     const size_t len = wxStrlen(needle);
1959
1960     while ( const wxChar *fnd = wxStrchr(haystack, *needle) )
1961     {
1962         if ( !wxStrncmp(fnd, needle, len) )
1963             return fnd;
1964
1965         haystack = fnd + 1;
1966     }
1967
1968     return NULL;
1969 }
1970
1971 #ifdef __cplusplus
1972 }
1973 #endif
1974
1975 WXDLLEXPORT double wxStrtod(const wxChar *nptr, wxChar **endptr)
1976 {
1977   const wxChar *start = nptr;
1978
1979   // FIXME: only correct for C locale
1980   while (wxIsspace(*nptr)) nptr++;
1981   if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
1982   while (wxIsdigit(*nptr)) nptr++;
1983   if (*nptr == wxT('.')) {
1984     nptr++;
1985     while (wxIsdigit(*nptr)) nptr++;
1986   }
1987   if (*nptr == wxT('E') || *nptr == wxT('e')) {
1988     nptr++;
1989     if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
1990     while (wxIsdigit(*nptr)) nptr++;
1991   }
1992
1993   wxString data(nptr, nptr-start);
1994   wxWX2MBbuf dat = data.mb_str(wxConvLibc);
1995   char *rdat = wxMBSTRINGCAST dat;
1996   double ret = strtod(dat, &rdat);
1997
1998   if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
1999
2000   return ret;
2001 }
2002
2003 WXDLLEXPORT long int wxStrtol(const wxChar *nptr, wxChar **endptr, int base)
2004 {
2005   const wxChar *start = nptr;
2006
2007   // FIXME: only correct for C locale
2008   while (wxIsspace(*nptr)) nptr++;
2009   if (*nptr == wxT('+') || *nptr == wxT('-')) nptr++;
2010   if (((base == 0) || (base == 16)) &&
2011       (nptr[0] == wxT('0') && nptr[1] == wxT('x'))) {
2012     nptr += 2;
2013     base = 16;
2014   }
2015   else if ((base == 0) && (nptr[0] == wxT('0'))) base = 8;
2016   else if (base == 0) base = 10;
2017
2018   while ((wxIsdigit(*nptr) && (*nptr - wxT('0') < base)) ||
2019          (wxIsalpha(*nptr) && (wxToupper(*nptr) - wxT('A') + 10 < base))) nptr++;
2020
2021   wxString data(start, nptr-start);
2022   wxWX2MBbuf dat = data.mb_str(wxConvLibc);
2023   char *rdat = wxMBSTRINGCAST dat;
2024   long int ret = strtol(dat, &rdat, base);
2025
2026   if (endptr) *endptr = (wxChar *)(start + (rdat - (const char *)dat));
2027
2028   return ret;
2029 }
2030
2031 WXDLLEXPORT unsigned long int wxStrtoul(const wxChar *nptr, wxChar **endptr, int base)
2032 {
2033     return (unsigned long int) wxStrtol(nptr, endptr, base);
2034 }
2035
2036 #endif // wxNEED_WX_STRING_H
2037
2038 #ifdef wxNEED_WX_STDIO_H
2039 WXDLLEXPORT FILE * wxFopen(const wxChar *path, const wxChar *mode)
2040 {
2041     char mode_buffer[10];
2042     for (size_t i = 0; i < wxStrlen(mode)+1; i++)
2043        mode_buffer[i] = (char) mode[i];
2044
2045     return fopen( wxConvFile.cWX2MB(path), mode_buffer );
2046 }
2047
2048 WXDLLEXPORT FILE * wxFreopen(const wxChar *path, const wxChar *mode, FILE *stream)
2049 {
2050     char mode_buffer[10];
2051     for (size_t i = 0; i < wxStrlen(mode)+1; i++)
2052        mode_buffer[i] = (char) mode[i];
2053
2054     return freopen( wxConvFile.cWX2MB(path), mode_buffer, stream );
2055 }
2056
2057 WXDLLEXPORT int wxRemove(const wxChar *path)
2058 {
2059     return remove( wxConvFile.cWX2MB(path) );
2060 }
2061
2062 WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
2063 {
2064     return rename( wxConvFile.cWX2MB(oldpath), wxConvFile.cWX2MB(newpath) );
2065 }
2066 #endif
2067
2068 #ifndef wxAtof
2069 double   WXDLLEXPORT wxAtof(const wxChar *psz)
2070 {
2071 #ifdef __WXWINCE__
2072     double d;
2073     wxString str(psz);
2074     if (str.ToDouble(& d))
2075         return d;
2076
2077     return 0.0;
2078 #else
2079     return atof(wxConvLibc.cWX2MB(psz));
2080 #endif
2081 }
2082 #endif
2083
2084 #ifdef wxNEED_WX_STDLIB_H
2085 int      WXDLLEXPORT wxAtoi(const wxChar *psz)
2086 {
2087   return atoi(wxConvLibc.cWX2MB(psz));
2088 }
2089
2090 long     WXDLLEXPORT wxAtol(const wxChar *psz)
2091 {
2092   return atol(wxConvLibc.cWX2MB(psz));
2093 }
2094
2095 wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
2096 {
2097 #if wxUSE_UNICODE
2098     // NB: buffer returned by getenv() is allowed to be overwritten next
2099     //     time getenv() is called, so it is OK to use static string
2100     //     buffer to hold the data.
2101     static wxWCharBuffer value((wxChar*)NULL);
2102     value = wxConvLibc.cMB2WX(getenv(wxConvLibc.cWX2MB(name)));
2103     return value.data();
2104 #else
2105     return getenv(name);
2106 #endif
2107 }
2108
2109 int WXDLLEXPORT wxSystem(const wxChar *psz)
2110 {
2111     return system(wxConvLibc.cWX2MB(psz));
2112 }
2113
2114 #endif // wxNEED_WX_STDLIB_H
2115
2116 #ifdef wxNEED_WX_TIME_H
2117 WXDLLEXPORT size_t
2118 wxStrftime(wxChar *s, size_t maxsize, const wxChar *fmt, const struct tm *tm)
2119 {
2120     if ( !maxsize )
2121         return 0;
2122
2123     wxCharBuffer buf(maxsize);
2124
2125     wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt));
2126     if ( !bufFmt )
2127         return 0;
2128
2129     size_t ret = strftime(buf.data(), maxsize, bufFmt, tm);
2130     if  ( !ret )
2131         return 0;
2132
2133     wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf);
2134     if ( !wbuf )
2135         return 0;
2136
2137     wxStrncpy(s, wbuf, maxsize);
2138     return wxStrlen(s);
2139 }
2140 #endif // wxNEED_WX_TIME_H
2141
2142 #ifndef wxCtime
2143 WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
2144 {
2145     // normally the string is 26 chars but give one more in case some broken
2146     // DOS compiler decides to use "\r\n" instead of "\n" at the end
2147     static wxChar buf[27];
2148
2149     // ctime() is guaranteed to return a string containing only ASCII
2150     // characters, as its format is always the same for any locale
2151     wxStrncpy(buf, wxString::FromAscii(ctime(timep)), WXSIZEOF(buf));
2152     buf[WXSIZEOF(buf) - 1] = _T('\0');
2153
2154     return buf;
2155 }
2156 #endif // wxCtime
2157
2158 #endif // wxUSE_WCHAR_T
2159
2160 // ----------------------------------------------------------------------------
2161 // functions which we may need even if !wxUSE_WCHAR_T
2162 // ----------------------------------------------------------------------------
2163
2164 #ifndef wxStrtok
2165
2166 WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
2167 {
2168     if (!psz)
2169     {
2170         psz = *save_ptr;
2171         if ( !psz )
2172             return NULL;
2173     }
2174
2175     psz += wxStrspn(psz, delim);
2176     if (!*psz)
2177     {
2178         *save_ptr = (wxChar *)NULL;
2179         return (wxChar *)NULL;
2180     }
2181
2182     wxChar *ret = psz;
2183     psz = wxStrpbrk(psz, delim);
2184     if (!psz)
2185     {
2186         *save_ptr = (wxChar*)NULL;
2187     }
2188     else
2189     {
2190         *psz = wxT('\0');
2191         *save_ptr = psz + 1;
2192     }
2193
2194     return ret;
2195 }
2196
2197 #endif // wxStrtok
2198
2199 // ----------------------------------------------------------------------------
2200 // missing C RTL functions
2201 // ----------------------------------------------------------------------------
2202
2203 #ifdef wxNEED_STRDUP
2204
2205 char *strdup(const char *s)
2206 {
2207     char *dest = (char*) malloc( strlen( s ) + 1 ) ;
2208     if ( dest )
2209         strcpy( dest , s ) ;
2210     return dest ;
2211 }
2212 #endif // wxNEED_STRDUP
2213
2214 #if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
2215
2216 void *calloc( size_t num, size_t size )
2217 {
2218     void** ptr = (void **)malloc(num * size);
2219     memset( ptr, 0, num * size);
2220     return ptr;
2221 }
2222
2223 #endif // __WXWINCE__ <= 211
2224
2225 #ifdef __WXWINCE__
2226
2227 int wxRemove(const wxChar *path)
2228 {
2229     return ::DeleteFile(path) == 0;
2230 }
2231
2232 #endif