src/common/wxchar.cpp

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