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