src/common/wxcrt.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/wxcrt.cpp
   3 // Purpose:     wxChar CRT wrappers 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/crt.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 #ifdef __WXWINCE__
  47     // there is no errno.h under CE apparently
  48     #define wxSET_ERRNO(value)
  49 #else
  50     #include <errno.h>
  51
  52     #define wxSET_ERRNO(value) errno = value
  53 #endif
  54
  55 #if defined(__MWERKS__) && __MSL__ >= 0x6000
  56 namespace std {}
  57 using namespace std ;
  58 #endif
  59
  60 #if wxUSE_WCHAR_T
  61 WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n)
  62 {
  63   // assume that we have mbsrtowcs() too if we have wcsrtombs()
  64 #ifdef HAVE_WCSRTOMBS
  65   mbstate_t mbstate;
  66   memset(&mbstate, 0, sizeof(mbstate_t));
  67 #endif
  68
  69   if (buf) {
  70     if (!n || !*psz) {
  71       if (n) *buf = wxT('\0');
  72       return 0;
  73     }
  74 #ifdef HAVE_WCSRTOMBS
  75     return mbsrtowcs(buf, &psz, n, &mbstate);
  76 #else
  77     return wxMbstowcs(buf, psz, n);
  78 #endif
  79   }
  80
  81   // note that we rely on common (and required by Unix98 but unfortunately not
  82   // C99) extension which allows to call mbs(r)towcs() with NULL output pointer
  83   // to just get the size of the needed buffer -- this is needed as otherwise
  84   // we have no idea about how much space we need and if the CRT doesn't
  85   // support it (the only currently known example being Metrowerks, see
  86   // wx/crt.h) we don't use its mbstowcs() at all
  87 #ifdef HAVE_WCSRTOMBS
  88   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
  89 #else
  90   return wxMbstowcs((wchar_t *) NULL, psz, 0);
  91 #endif
  92 }
  93
  94 WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
  95 {
  96 #ifdef HAVE_WCSRTOMBS
  97   mbstate_t mbstate;
  98   memset(&mbstate, 0, sizeof(mbstate_t));
  99 #endif
 100
 101   if (buf) {
 102     if (!n || !*pwz) {
 103       // glibc2.1 chokes on null input
 104       if (n) *buf = '\0';
 105       return 0;
 106     }
 107 #ifdef HAVE_WCSRTOMBS
 108     return wcsrtombs(buf, &pwz, n, &mbstate);
 109 #else
 110     return wxWcstombs(buf, pwz, n);
 111 #endif
 112   }
 113
 114 #ifdef HAVE_WCSRTOMBS
 115   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
 116 #else
 117   return wxWcstombs((char *) NULL, pwz, 0);
 118 #endif
 119 }
 120 #endif // wxUSE_WCHAR_T
 121
 122 WXDLLIMPEXP_BASE bool wxOKlibc()
 123 {
 124 #if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
 125   // glibc 2.0 uses UTF-8 even when it shouldn't
 126   wchar_t res = 0;
 127   if ((MB_CUR_MAX == 2) &&
 128       (wxMB2WC(&res, "\xdd\xa5", 1) == 1) &&
 129       (res==0x765)) {
 130     // this is UTF-8 allright, check whether that's what we want
 131     char *cur_locale = setlocale(LC_CTYPE, NULL);
 132     if ((strlen(cur_locale) < 4) ||
 133             (strcasecmp(cur_locale + strlen(cur_locale) - 4, "utf8")) ||
 134             (strcasecmp(cur_locale + strlen(cur_locale) - 5, "utf-8"))) {
 135       // nope, don't use libc conversion
 136       return false;
 137     }
 138   }
 139 #endif
 140   return true;
 141 }
 142
 143 char* wxSetlocale(int category, const char *locale)
 144 {
 145 #ifdef __WXWINCE__
 146     // FIXME-CE: there is no setlocale() in CE CRT, use SetThreadLocale()?
 147     wxUnusedVar(category);
 148     wxUnusedVar(locale);
 149
 150     return NULL;
 151 #else // !__WXWINCE__
 152     char *rv = setlocale(category, locale);
 153     if ( locale != NULL /* setting locale, not querying */ &&
 154          rv /* call was successful */ )
 155     {
 156         wxUpdateLocaleIsUtf8();
 157     }
 158     return rv;
 159 #endif // __WXWINCE__/!__WXWINCE__
 160 }
 161
 162 // ============================================================================
 163 // printf() functions business
 164 // ============================================================================
 165
 166 // special test mode: define all functions below even if we don't really need
 167 // them to be able to test them
 168 #ifdef wxTEST_PRINTF
 169     #undef wxFprintf
 170     #undef wxPrintf
 171     #undef wxSprintf
 172     #undef wxVfprintf
 173     #undef wxVsprintf
 174     #undef wxVprintf
 175     #undef wxVsnprintf_
 176
 177     #define wxNEED_WPRINTF
 178
 179     int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list argptr );
 180 #endif
 181
 182 #if defined(__DMC__)
 183 /* Digital Mars adds count to _stprintf (C99) so convert */
 184 int wxCRT_SprintfW (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... )
 185 {
 186     va_list arglist;
 187
 188     va_start( arglist, format );
 189     int iLen = swprintf ( s, -1, format, arglist );
 190     va_end( arglist );
 191     return iLen ;
 192 }
 193 #endif //__DMC__
 194
 195 // ----------------------------------------------------------------------------
 196 // implement the standard IO functions for wide char if libc doesn't have them
 197 // ----------------------------------------------------------------------------
 198
 199 #ifndef wxCRT_FputsW
 200 int wxCRT_FputsW(const wchar_t *ws, FILE *stream)
 201 {
 202     wxCharBuffer buf(wxConvLibc.cWC2MB(ws));
 203     if ( !buf )
 204         return -1;
 205
 206     // counting the number of wide characters written isn't worth the trouble,
 207     // simply distinguish between ok and error
 208     return wxCRT_FputsA(buf, stream) == -1 ? -1 : 0;
 209 }
 210 #endif // !wxCRT_FputsW
 211
 212 #ifndef wxCRT_PutsW
 213 int wxCRT_PutsW(const wchar_t *ws)
 214 {
 215     int rc = wxCRT_FputsW(ws, stdout);
 216     if ( rc != -1 )
 217     {
 218         if ( wxCRT_FputsW(L"\n", stdout) == -1 )
 219             return -1;
 220
 221         rc++;
 222     }
 223
 224     return rc;
 225 }
 226 #endif // !wxCRT_PutsW
 227
 228 #ifndef wxCRT_FputcW
 229 int /* not wint_t */ wxCRT_FputcW(wchar_t wc, FILE *stream)
 230 {
 231     wchar_t ws[2] = { wc, L'\0' };
 232
 233     return wxCRT_FputsW(ws, stream);
 234 }
 235 #endif // !wxCRT_FputcW
 236
 237 // NB: we only implement va_list functions here, the ones taking ... are
 238 //     defined below for wxNEED_PRINTF_CONVERSION case anyhow and we reuse
 239 //     the definitions there to avoid duplicating them here
 240 #ifdef wxNEED_WPRINTF
 241
 242 // TODO: implement the scanf() functions
 243 static int vwscanf(const wchar_t *format, va_list argptr)
 244 {
 245     wxFAIL_MSG( _T("TODO") );
 246
 247     return -1;
 248 }
 249
 250 static int vswscanf(const wchar_t *ws, const wchar_t *format, va_list argptr)
 251 {
 252     // The best we can do without proper Unicode support in glibc is to
 253     // convert the strings into MB representation and run ANSI version
 254     // of the function. This doesn't work with %c and %s because of difference
 255     // in size of char and wchar_t, though.
 256
 257     wxCHECK_MSG( wxStrstr(format, _T("%s")) == NULL, -1,
 258                  _T("incomplete vswscanf implementation doesn't allow %s") );
 259     wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
 260                  _T("incomplete vswscanf implementation doesn't allow %c") );
 261
 262     return vsscanf(wxConvLibc.cWX2MB(ws), wxConvLibc.cWX2MB(format), argptr);
 263 }
 264
 265 static int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
 266 {
 267     wxFAIL_MSG( _T("TODO") );
 268
 269     return -1;
 270 }
 271
 272 #define vswprintf wxCRT_VsnprintfW
 273
 274 static int vfwprintf(FILE *stream, const wchar_t *format, va_list argptr)
 275 {
 276     wxString s;
 277     int rc = s.PrintfV(format, argptr);
 278
 279     if ( rc != -1 )
 280     {
 281         // we can't do much better without Unicode support in libc...
 282         if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )
 283             return -1;
 284     }
 285
 286     return rc;
 287 }
 288
 289 static int vwprintf(const wchar_t *format, va_list argptr)
 290 {
 291     return wxCRT_VfprintfW(stdout, format, argptr);
 292 }
 293
 294 #endif // wxNEED_WPRINTF
 295
 296 // ----------------------------------------------------------------------------
 297 // wxPrintf(), wxScanf() and relatives
 298 // ----------------------------------------------------------------------------
 299
 300 // FIXME-UTF8: do format conversion using (modified) wxFormatConverter in
 301 //             template wrappers, not here; note that it will needed to
 302 //             translate all forms of string specifiers to %(l)s for wxPrintf(),
 303 //             but it only should do what it did in 2.8 for wxScanf()!
 304
 305 #ifndef wxCRT_PrintfW
 306 int wxCRT_PrintfW( const wchar_t *format, ... )
 307 {
 308     va_list argptr;
 309     va_start(argptr, format);
 310
 311     int ret = vwprintf( format, argptr );
 312
 313     va_end(argptr);
 314
 315     return ret;
 316 }
 317 #endif
 318
 319 #ifndef wxCRT_FprintfW
 320 int wxCRT_FprintfW( FILE *stream, const wchar_t *format, ... )
 321 {
 322     va_list argptr;
 323     va_start( argptr, format );
 324
 325     int ret = vfwprintf( stream, format, argptr );
 326
 327     va_end(argptr);
 328
 329     return ret;
 330 }
 331 #endif
 332
 333 #ifndef wxCRT_VfprintfW
 334 int wxCRT_VfprintfW( FILE *stream, const wchar_t *format, va_list argptr )
 335 {
 336     return vfwprintf( stream, format, argptr );
 337 }
 338 #endif
 339
 340 #ifndef wxCRT_VprintfW
 341 int wxCRT_VprintfW( const wchar_t *format, va_list argptr )
 342 {
 343     return vwprintf( format, argptr );
 344 }
 345 #endif
 346
 347 #ifndef wxCRT_VsprintfW
 348 int wxCRT_VsprintfW( wchar_t *str, const wchar_t *format, va_list argptr )
 349 {
 350     // same as for wxSprintf()
 351     return vswprintf(str, INT_MAX / 4, format, argptr);
 352 }
 353 #endif
 354
 355 #ifndef wxCRT_ScanfW
 356 int wxCRT_ScanfW(const wchar_t *format, ...)
 357 {
 358     va_list argptr;
 359     va_start(argptr, format);
 360
 361 #ifdef __VMS
 362 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 363    int ret = std::vwscanf(format, argptr);
 364 #else
 365    int ret = vwscanf(format, argptr);
 366 #endif
 367 #else
 368    int ret = vwscanf(format, argptr);
 369 #endif
 370
 371     va_end(argptr);
 372
 373     return ret;
 374 }
 375 #endif
 376
 377 #ifndef wxCRT_SscanfW
 378 int wxCRT_SscanfW(const wchar_t *str, const wchar_t *format, ...)
 379 {
 380     va_list argptr;
 381     va_start(argptr, format);
 382
 383 #ifdef __VMS
 384 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 385    int ret = std::vswscanf(str, format, argptr);
 386 #else
 387    int ret = vswscanf(str, format, argptr);
 388 #endif
 389 #else
 390    int ret = vswscanf(str, format, argptr);
 391 #endif
 392
 393     va_end(argptr);
 394
 395     return ret;
 396 }
 397 #endif
 398
 399 #ifndef wxCRT_FscanfW
 400 int wxCRT_FscanfW(FILE *stream, const wchar_t *format, ...)
 401 {
 402     va_list argptr;
 403     va_start(argptr, format);
 404 #ifdef __VMS
 405 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 406    int ret = std::vfwscanf(stream, format, argptr);
 407 #else
 408    int ret = vfwscanf(stream, format, argptr);
 409 #endif
 410 #else
 411    int ret = vfwscanf(stream, format, argptr);
 412 #endif
 413
 414     va_end(argptr);
 415
 416     return ret;
 417 }
 418 #endif
 419
 420 #ifndef wxCRT_VsscanfW
 421 int wxCRT_VsscanfW(const wchar_t *str, const wchar_t *format, va_list argptr)
 422 {
 423 #ifdef __VMS
 424 #if (__DECCXX_VER >= 70100000) && !defined(__STD_CFRONT) && !defined( __NONAMESPACE_STD )
 425    return std::vswscanf(str, format, argptr);
 426 #else
 427    return vswscanf(str, format, argptr);
 428 #endif
 429 #else
 430    return vswscanf(str, format, argptr);
 431 #endif
 432 }
 433 #endif
 434
 435
 436 // ----------------------------------------------------------------------------
 437 // wrappers to printf and scanf function families
 438 // ----------------------------------------------------------------------------
 439
 440 #if !wxUSE_UTF8_LOCALE_ONLY
 441 int wxDoSprintfWchar(char *str, const wxChar *format, ...)
 442 {
 443     va_list argptr;
 444     va_start(argptr, format);
 445
 446     int rv = wxVsprintf(str, format, argptr);
 447
 448     va_end(argptr);
 449     return rv;
 450 }
 451 #endif // !wxUSE_UTF8_LOCALE_ONLY
 452
 453 #if wxUSE_UNICODE_UTF8
 454 int wxDoSprintfUtf8(char *str, const char *format, ...)
 455 {
 456     va_list argptr;
 457     va_start(argptr, format);
 458
 459     int rv = wxVsprintf(str, format, argptr);
 460
 461     va_end(argptr);
 462     return rv;
 463 }
 464 #endif // wxUSE_UNICODE_UTF8
 465
 466 #if wxUSE_UNICODE
 467
 468 #if !wxUSE_UTF8_LOCALE_ONLY
 469 int wxDoSprintfWchar(wchar_t *str, const wxChar *format, ...)
 470 {
 471     va_list argptr;
 472     va_start(argptr, format);
 473
 474     int rv = wxVsprintf(str, format, argptr);
 475
 476     va_end(argptr);
 477     return rv;
 478 }
 479 #endif // !wxUSE_UTF8_LOCALE_ONLY
 480
 481 #if wxUSE_UNICODE_UTF8
 482 int wxDoSprintfUtf8(wchar_t *str, const char *format, ...)
 483 {
 484     va_list argptr;
 485     va_start(argptr, format);
 486
 487     int rv = wxVsprintf(str, format, argptr);
 488
 489     va_end(argptr);
 490     return rv;
 491 }
 492 #endif // wxUSE_UNICODE_UTF8
 493
 494 #endif // wxUSE_UNICODE
 495
 496 #if !wxUSE_UTF8_LOCALE_ONLY
 497 int wxDoSnprintfWchar(char *str, size_t size, const wxChar *format, ...)
 498 {
 499     va_list argptr;
 500     va_start(argptr, format);
 501
 502     int rv = wxVsnprintf(str, size, format, argptr);
 503
 504     va_end(argptr);
 505     return rv;
 506 }
 507 #endif // !wxUSE_UTF8_LOCALE_ONLY
 508
 509 #if wxUSE_UNICODE_UTF8
 510 int wxDoSnprintfUtf8(char *str, size_t size, const char *format, ...)
 511 {
 512     va_list argptr;
 513     va_start(argptr, format);
 514
 515     int rv = wxVsnprintf(str, size, format, argptr);
 516
 517     va_end(argptr);
 518     return rv;
 519 }
 520 #endif // wxUSE_UNICODE_UTF8
 521
 522 #if wxUSE_UNICODE
 523
 524 #if !wxUSE_UTF8_LOCALE_ONLY
 525 int wxDoSnprintfWchar(wchar_t *str, size_t size, const wxChar *format, ...)
 526 {
 527     va_list argptr;
 528     va_start(argptr, format);
 529
 530     int rv = wxVsnprintf(str, size, format, argptr);
 531
 532     va_end(argptr);
 533     return rv;
 534 }
 535 #endif // !wxUSE_UTF8_LOCALE_ONLY
 536
 537 #if wxUSE_UNICODE_UTF8
 538 int wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...)
 539 {
 540     va_list argptr;
 541     va_start(argptr, format);
 542
 543     int rv = wxVsnprintf(str, size, format, argptr);
 544
 545     va_end(argptr);
 546     return rv;
 547 }
 548 #endif // wxUSE_UNICODE_UTF8
 549
 550 #endif // wxUSE_UNICODE
 551
 552
 553 #ifdef HAVE_BROKEN_VSNPRINTF_DECL
 554     #define vsnprintf wx_fixed_vsnprintf
 555 #endif
 556
 557 #if wxUSE_UNICODE
 558
 559 namespace
 560 {
 561
 562 #if !wxUSE_UTF8_LOCALE_ONLY
 563 int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
 564 {
 565     const wxWX2WCbuf buf = s.wc_str();
 566
 567     size_t len = wxConvLibc.FromWChar(out, outsize, buf);
 568     if ( len != wxCONV_FAILED )
 569         return len-1;
 570     else
 571         return wxConvLibc.FromWChar(NULL, 0, buf);
 572 }
 573 #endif // !wxUSE_UTF8_LOCALE_ONLY
 574
 575 #if wxUSE_UNICODE_UTF8
 576 int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)
 577 {
 578     const wxWX2WCbuf buf(s.wc_str());
 579     size_t len = s.length(); // same as buf length for wchar_t*
 580     if ( outsize > len )
 581     {
 582         memcpy(out, buf, (len+1) * sizeof(wchar_t));
 583     }
 584     else // not enough space
 585     {
 586         memcpy(out, buf, (outsize-1) * sizeof(wchar_t));
 587         out[outsize-1] = 0;
 588     }
 589     return len;
 590 }
 591 #endif // wxUSE_UNICODE_UTF8
 592
 593 } // anonymous namespace
 594
 595 template<typename T>
 596 static size_t PrintfViaString(T *out, size_t outsize,
 597                               const wxString& format, va_list argptr)
 598 {
 599     wxString s;
 600     s.PrintfV(format, argptr);
 601
 602     return ConvertStringToBuf(s, out, outsize);
 603 }
 604 #endif // wxUSE_UNICODE
 605
 606 int wxVsprintf(char *str, const wxString& format, va_list argptr)
 607 {
 608 #if wxUSE_UTF8_LOCALE_ONLY
 609     return wxCRT_VsprintfA(str, format.wx_str(), argptr);
 610 #else
 611     #if wxUSE_UNICODE_UTF8
 612     if ( wxLocaleIsUtf8 )
 613         return wxCRT_VsprintfA(str, format.wx_str(), argptr);
 614     else
 615     #endif
 616     #if wxUSE_UNICODE
 617     return PrintfViaString(str, wxNO_LEN, format, argptr);
 618     #else
 619     return wxCRT_VsprintfA(str, format.mb_str(), argptr);
 620     #endif
 621 #endif
 622 }
 623
 624 #if wxUSE_UNICODE
 625 int wxVsprintf(wchar_t *str, const wxString& format, va_list argptr)
 626 {
 627 #if wxUSE_UNICODE_WCHAR
 628 #ifdef __DMC__
 629 /*
 630 This fails with a bug similar to
 631 http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=c++.beta&artnum=680
 632 in DMC 8.49 and 8.50
 633 I don't see it being used in the wxWidgets sources at present (oct 2007) CE
 634 */
 635 #pragma message ( "warning ::::: wxVsprintf(wchar_t *str, const wxString& format, va_list argptr) not yet implemented" )
 636     wxFAIL_MSG( _T("TODO") );
 637
 638     return -1;
 639 #else
 640     return wxCRT_VsprintfW(str, format.wc_str(), argptr);
 641 #endif //DMC
 642 #else // wxUSE_UNICODE_UTF8
 643     #if !wxUSE_UTF8_LOCALE_ONLY
 644     if ( !wxLocaleIsUtf8 )
 645         return wxCRT_VsprintfW(str, format.wc_str(), argptr);
 646     else
 647     #endif
 648         return PrintfViaString(str, wxNO_LEN, format, argptr);
 649 #endif // wxUSE_UNICODE_UTF8
 650 }
 651 #endif // wxUSE_UNICODE
 652
 653 int wxVsnprintf(char *str, size_t size, const wxString& format, va_list argptr)
 654 {
 655     int rv;
 656 #if wxUSE_UTF8_LOCALE_ONLY
 657     rv = wxCRT_VsnprintfA(str, size, format.wx_str(), argptr);
 658 #else
 659     #if wxUSE_UNICODE_UTF8
 660     if ( wxLocaleIsUtf8 )
 661         rv = wxCRT_VsnprintfA(str, size, format.wx_str(), argptr);
 662     else
 663     #endif
 664     #if wxUSE_UNICODE
 665     {
 666         // NB: if this code is called, then wxString::PrintV() would use the
 667         //     wchar_t* version of wxVsnprintf(), so it's safe to use PrintV()
 668         //     from here
 669         rv = PrintfViaString(str, size, format, argptr);
 670     }
 671     #else
 672     rv = wxCRT_VsnprintfA(str, size, format.mb_str(), argptr);
 673     #endif
 674 #endif
 675
 676     // VsnprintfTestCase reveals that glibc's implementation of vswprintf
 677     // doesn't nul terminate on truncation.
 678     str[size - 1] = 0;
 679
 680     return rv;
 681 }
 682
 683 #if wxUSE_UNICODE
 684 int wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argptr)
 685 {
 686     int rv;
 687
 688 #if wxUSE_UNICODE_WCHAR
 689     rv = wxCRT_VsnprintfW(str, size, format.wc_str(), argptr);
 690 #else // wxUSE_UNICODE_UTF8
 691     #if !wxUSE_UTF8_LOCALE_ONLY
 692     if ( !wxLocaleIsUtf8 )
 693         rv = wxCRT_VsnprintfW(str, size, format.wc_str(), argptr);
 694     else
 695     #endif
 696     {
 697         // NB: if this code is called, then wxString::PrintV() would use the
 698         //     char* version of wxVsnprintf(), so it's safe to use PrintV()
 699         //     from here
 700         rv = PrintfViaString(str, size, format, argptr);
 701     }
 702 #endif // wxUSE_UNICODE_UTF8
 703
 704     // VsnprintfTestCase reveals that glibc's implementation of vswprintf
 705     // doesn't nul terminate on truncation.
 706     str[size - 1] = 0;
 707
 708     return rv;
 709 }
 710 #endif // wxUSE_UNICODE
 711
 712 #if wxUSE_WCHAR_T
 713
 714 // ----------------------------------------------------------------------------
 715 // ctype.h stuff (currently unused)
 716 // ----------------------------------------------------------------------------
 717
 718 #ifdef wxNEED_WX_MBSTOWCS
 719
 720 WXDLLIMPEXP_BASE size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
 721 {
 722     if (!out)
 723     {
 724         size_t outsize = 0;
 725         while(*in++)
 726             outsize++;
 727         return outsize;
 728     }
 729
 730     const char* origin = in;
 731
 732     while (outlen-- && *in)
 733     {
 734         *out++ = (wchar_t) *in++;
 735     }
 736
 737     *out = '\0';
 738
 739     return in - origin;
 740 }
 741
 742 WXDLLIMPEXP_BASE size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
 743 {
 744     if (!out)
 745     {
 746         size_t outsize = 0;
 747         while(*in++)
 748             outsize++;
 749         return outsize;
 750     }
 751
 752     const wchar_t* origin = in;
 753
 754     while (outlen-- && *in)
 755     {
 756         *out++ = (char) *in++;
 757     }
 758
 759     *out = '\0';
 760
 761     return in - origin;
 762 }
 763
 764 #endif // wxNEED_WX_MBSTOWCS
 765
 766 #ifndef wxCRT_StrdupA
 767 WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *s)
 768 {
 769     return strcpy((char *)malloc(strlen(s) + 1), s);
 770 }
 771 #endif // wxCRT_StrdupA
 772
 773 #ifndef wxCRT_StrdupW
 774 WXDLLIMPEXP_BASE wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
 775 {
 776   size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
 777   wchar_t *ret = (wchar_t *) malloc(size);
 778   memcpy(ret, pwz, size);
 779   return ret;
 780 }
 781 #endif // wxCRT_StrdupW
 782
 783 #ifndef wxCRT_StricmpA
 784 WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2)
 785 {
 786   register char c1, c2;
 787   do {
 788     c1 = wxTolower(*psz1++);
 789     c2 = wxTolower(*psz2++);
 790   } while ( c1 && (c1 == c2) );
 791   return c1 - c2;
 792 }
 793 #endif // !defined(wxCRT_StricmpA)
 794
 795 #ifndef wxCRT_StricmpW
 796 WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
 797 {
 798   register wchar_t c1, c2;
 799   do {
 800     c1 = wxTolower(*psz1++);
 801     c2 = wxTolower(*psz2++);
 802   } while ( c1 && (c1 == c2) );
 803   return c1 - c2;
 804 }
 805 #endif // !defined(wxCRT_StricmpW)
 806
 807 #ifndef wxCRT_StrnicmpA
 808 WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
 809 {
 810   // initialize the variables just to suppress stupid gcc warning
 811   register char c1 = 0, c2 = 0;
 812   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
 813   if (n) {
 814     if (c1 < c2) return -1;
 815     if (c1 > c2) return 1;
 816   }
 817   return 0;
 818 }
 819 #endif // !defined(wxCRT_StrnicmpA)
 820
 821 #ifndef wxCRT_StrnicmpW
 822 WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
 823 {
 824   // initialize the variables just to suppress stupid gcc warning
 825   register wchar_t c1 = 0, c2 = 0;
 826   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
 827   if (n) {
 828     if (c1 < c2) return -1;
 829     if (c1 > c2) return 1;
 830   }
 831   return 0;
 832 }
 833 #endif // !defined(wxCRT_StrnicmpW)
 834
 835 // ----------------------------------------------------------------------------
 836 // string.h functions
 837 // ----------------------------------------------------------------------------
 838
 839 // this (and wxCRT_StrncmpW below) are extern "C" because they are needed
 840 // by regex code, the rest isn't needed, so it's not declared as extern "C"
 841 #ifndef wxCRT_StrlenW
 842 extern "C" WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s)
 843 {
 844     size_t n = 0;
 845     while ( *s++ )
 846         n++;
 847
 848     return n;
 849 }
 850 #endif
 851
 852 // ----------------------------------------------------------------------------
 853 // stdlib.h functions
 854 // ----------------------------------------------------------------------------
 855
 856 #ifndef wxCRT_GetenvW
 857 WXDLLIMPEXP_BASE wchar_t* wxCRT_GetenvW(const wchar_t *name)
 858 {
 859     // NB: buffer returned by getenv() is allowed to be overwritten next
 860     //     time getenv() is called, so it is OK to use static string
 861     //     buffer to hold the data.
 862     static wxWCharBuffer value((wchar_t*)NULL);
 863     value = wxConvLibc.cMB2WC(getenv(wxConvLibc.cWC2MB(name)));
 864     return value.data();
 865 }
 866 #endif // !wxCRT_GetenvW
 867
 868 #ifndef wxCRT_StrftimeW
 869 WXDLLIMPEXP_BASE size_t
 870 wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm *tm)
 871 {
 872     if ( !maxsize )
 873         return 0;
 874
 875     wxCharBuffer buf(maxsize);
 876
 877     wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt));
 878     if ( !bufFmt )
 879         return 0;
 880
 881     size_t ret = strftime(buf.data(), maxsize, bufFmt, tm);
 882     if  ( !ret )
 883         return 0;
 884
 885     wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf);
 886     if ( !wbuf )
 887         return 0;
 888
 889     wxCRT_StrncpyW(s, wbuf, maxsize);
 890     return wxCRT_StrlenW(s);
 891 }
 892 #endif // !wxCRT_StrftimeW
 893
 894 #endif // wxUSE_WCHAR_T
 895
 896 #ifdef wxLongLong_t
 897 template<typename T>
 898 static wxULongLong_t
 899 wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
 900 {
 901     wxULongLong_t sum = 0;
 902     wxString wxstr(nptr);
 903     wxString::const_iterator i = wxstr.begin();
 904     wxString::const_iterator end = wxstr.end();
 905
 906     // Skip spaces
 907     while ( i != end && wxIsspace(*i) ) ++i;
 908
 909     // Starts with sign?
 910     *sign = wxT(' ');
 911     if ( i != end )
 912     {
 913         T c = *i;
 914         if ( c == wxT('+') || c == wxT('-') )
 915         {
 916             *sign = c;
 917             ++i;
 918         }
 919     }
 920
 921     // Starts with 0x?
 922     if ( i != end && *i == wxT('0') )
 923     {
 924         ++i;
 925         if ( i != end )
 926         {
 927             if ( *i == wxT('x') && (base == 16 || base == 0) )
 928             {
 929                 base = 16;
 930                 ++i;
 931             }
 932             else
 933             {
 934                 if ( endptr )
 935                     *endptr = (T*) nptr;
 936                 wxSET_ERRNO(EINVAL);
 937                 return sum;
 938             }
 939         }
 940         else
 941             --i;
 942     }
 943
 944     if ( base == 0 )
 945         base = 10;
 946
 947     for ( ; i != end; ++i )
 948     {
 949         unsigned int n;
 950
 951         T c = *i;
 952         if ( c >= '0' )
 953         {
 954             if ( c <= '9' )
 955                 n = c - wxT('0');
 956             else
 957                 n = wxTolower(c) - wxT('a') + 10;
 958         }
 959         else
 960             break;
 961
 962         if ( n >= (unsigned int)base )
 963             // Invalid character (for this base)
 964             break;
 965
 966         wxULongLong_t prevsum = sum;
 967         sum = (sum * base) + n;
 968
 969         if ( sum < prevsum )
 970         {
 971             wxSET_ERRNO(ERANGE);
 972             break;
 973         }
 974     }
 975
 976     if ( endptr )
 977     {
 978         *endptr = (T*)(nptr + (i - wxstr.begin()));
 979     }
 980
 981     return sum;
 982 }
 983
 984 template<typename T>
 985 static wxULongLong_t wxCRT_DoStrtoull(const T* nptr, T** endptr, int base)
 986 {
 987     T sign;
 988     wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);
 989
 990     if ( sign == wxT('-') )
 991     {
 992         wxSET_ERRNO(ERANGE);
 993         uval = 0;
 994     }
 995
 996     return uval;
 997 }
 998
 999 template<typename T>
1000 static wxLongLong_t wxCRT_DoStrtoll(const T* nptr, T** endptr, int base)
1001 {
1002     T sign;
1003     wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);
1004     wxLongLong_t val = 0;
1005
1006     if ( sign == wxT('-') )
1007     {
1008         if ( uval <= wxULL(wxINT64_MAX+1) )
1009         {
1010             if ( uval == wxULL(wxINT64_MAX+1))
1011                 val = -((wxLongLong_t)wxINT64_MAX) - 1;
1012             else
1013                 val = -((wxLongLong_t)uval);
1014         }
1015         else
1016         {
1017             wxSET_ERRNO(ERANGE);
1018         }
1019     }
1020     else if ( uval <= wxINT64_MAX )
1021     {
1022         val = uval;
1023     }
1024     else
1025     {
1026         wxSET_ERRNO(ERANGE);
1027     }
1028
1029     return val;
1030 }
1031
1032 #ifndef wxCRT_StrtollA
1033 wxLongLong_t wxCRT_StrtollA(const char* nptr, char** endptr, int base)
1034     { return wxCRT_DoStrtoll(nptr, endptr, base); }
1035 #endif
1036 #ifndef wxCRT_StrtollW
1037 wxLongLong_t wxCRT_StrtollW(const wchar_t* nptr, wchar_t** endptr, int base)
1038     { return wxCRT_DoStrtoll(nptr, endptr, base); }
1039 #endif
1040
1041 #ifndef wxCRT_StrtoullA
1042 wxULongLong_t wxCRT_StrtoullA(const char* nptr, char** endptr, int base)
1043     { return wxCRT_DoStrtoull(nptr, endptr, base); }
1044 #endif
1045 #ifndef wxCRT_StrtoullW
1046 wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr, wchar_t** endptr, int base)
1047     { return wxCRT_DoStrtoull(nptr, endptr, base); }
1048 #endif
1049
1050 #endif // wxLongLong_t
1051
1052 // ----------------------------------------------------------------------------
1053 // functions which we may need even if !wxUSE_WCHAR_T
1054 // ----------------------------------------------------------------------------
1055
1056 template<typename T>
1057 static T *wxCRT_DoStrtok(T *psz, const T *delim, T **save_ptr)
1058 {
1059     if (!psz)
1060     {
1061         psz = *save_ptr;
1062         if ( !psz )
1063             return NULL;
1064     }
1065
1066     psz += wxStrspn(psz, delim);
1067     if (!*psz)
1068     {
1069         *save_ptr = (T *)NULL;
1070         return (T *)NULL;
1071     }
1072
1073     T *ret = psz;
1074     psz = wxStrpbrk(psz, delim);
1075     if (!psz)
1076     {
1077         *save_ptr = (T*)NULL;
1078     }
1079     else
1080     {
1081         *psz = wxT('\0');
1082         *save_ptr = psz + 1;
1083     }
1084
1085     return ret;
1086 }
1087
1088 #ifndef wxCRT_StrtokA
1089 char *wxCRT_StrtokA(char *psz, const char *delim, char **save_ptr)
1090     { return wxCRT_DoStrtok(psz, delim, save_ptr); }
1091 #endif
1092 #ifndef wxCRT_StrtokW
1093 wchar_t *wxCRT_StrtokW(wchar_t *psz, const wchar_t *delim, wchar_t **save_ptr)
1094     { return wxCRT_DoStrtok(psz, delim, save_ptr); }
1095 #endif
1096
1097 // ----------------------------------------------------------------------------
1098 // missing C RTL functions
1099 // ----------------------------------------------------------------------------
1100
1101 #ifdef wxNEED_STRDUP
1102
1103 char *strdup(const char *s)
1104 {
1105     char *dest = (char*) malloc( strlen( s ) + 1 ) ;
1106     if ( dest )
1107         strcpy( dest , s ) ;
1108     return dest ;
1109 }
1110 #endif // wxNEED_STRDUP
1111
1112 #if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
1113
1114 void *calloc( size_t num, size_t size )
1115 {
1116     void** ptr = (void **)malloc(num * size);
1117     memset( ptr, 0, num * size);
1118     return ptr;
1119 }
1120
1121 #endif // __WXWINCE__ <= 211
1122
1123 // ============================================================================
1124 // wxLocaleIsUtf8
1125 // ============================================================================
1126
1127 #if wxUSE_UNICODE_UTF8
1128
1129 #if !wxUSE_UTF8_LOCALE_ONLY
1130 bool wxLocaleIsUtf8 = false; // the safer setting if not known
1131 #endif
1132
1133 static bool wxIsLocaleUtf8()
1134 {
1135     // NB: we intentionally don't use wxLocale::GetSystemEncodingName(),
1136     //     because a) it may be unavailable in some builds and b) has slightly
1137     //     different semantics (default locale instead of current)
1138
1139 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
1140     // GNU libc provides current character set this way (this conforms to
1141     // Unix98)
1142     const char *charset = nl_langinfo(CODESET);
1143     if ( charset )
1144     {
1145         // "UTF-8" is used by modern glibc versions, but test other variants
1146         // as well, just in case:
1147         if ( strcmp(charset, "UTF-8") == 0 ||
1148              strcmp(charset, "utf-8") == 0 ||
1149              strcmp(charset, "UTF8") == 0 ||
1150              strcmp(charset, "utf8") == 0 )
1151         {
1152             return true;
1153         }
1154     }
1155 #endif
1156
1157     // check if we're running under the "C" locale: it is 7bit subset
1158     // of UTF-8, so it can be safely used with the UTF-8 build:
1159     const char *lc_ctype = setlocale(LC_CTYPE, NULL);
1160     if ( lc_ctype &&
1161          (strcmp(lc_ctype, "C") == 0 || strcmp(lc_ctype, "POSIX") == 0) )
1162     {
1163         return true;
1164     }
1165
1166     // we don't know what charset libc is using, so assume the worst
1167     // to be safe:
1168     return false;
1169 }
1170
1171 void wxUpdateLocaleIsUtf8()
1172 {
1173 #if wxUSE_UTF8_LOCALE_ONLY
1174     if ( !wxIsLocaleUtf8() )
1175     {
1176         wxLogFatalError(_T("This program requires UTF-8 locale to run."));
1177     }
1178 #else // !wxUSE_UTF8_LOCALE_ONLY
1179     wxLocaleIsUtf8 = wxIsLocaleUtf8();
1180 #endif
1181 }
1182
1183 #endif // wxUSE_UNICODE_UTF8
1184
1185 // ============================================================================
1186 // wx wrappers for CRT functions
1187 // ============================================================================
1188
1189 #if wxUSE_UNICODE_WCHAR
1190     #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW)  return_kw callW
1191 #elif wxUSE_UNICODE_UTF8 && !wxUSE_UTF8_LOCALE_ONLY
1192     #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW) \
1193             return_kw wxLocaleIsUtf8 ? callA : callW
1194 #else // ANSI or UTF8 only
1195     #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW)  return_kw callA
1196 #endif
1197
1198 int wxPuts(const wxString& s)
1199 {
1200     CALL_ANSI_OR_UNICODE(return,
1201                          wxCRT_PutsA(s.mb_str()),
1202                          wxCRT_PutsW(s.wc_str()));
1203 }
1204
1205 int wxFputs(const wxString& s, FILE *stream)
1206 {
1207     CALL_ANSI_OR_UNICODE(return,
1208                          wxCRT_FputsA(s.mb_str(), stream),
1209                          wxCRT_FputsW(s.wc_str(), stream));
1210 }
1211
1212 int wxFputc(const wxUniChar& c, FILE *stream)
1213 {
1214 #if !wxUSE_UNICODE // FIXME-UTF8: temporary, remove this with ANSI build
1215     return wxCRT_FputcA((char)c, stream);
1216 #else
1217     CALL_ANSI_OR_UNICODE(return,
1218                          wxCRT_FputsA(c.AsUTF8(), stream),
1219                          wxCRT_FputcW((wchar_t)c, stream));
1220 #endif
1221 }
1222
1223 #ifdef wxCRT_PerrorA
1224
1225 void wxPerror(const wxString& s)
1226 {
1227 #ifdef wxCRT_PerrorW
1228     CALL_ANSI_OR_UNICODE(wxEMPTY_PARAMETER_VALUE,
1229                          wxCRT_PerrorA(s.mb_str()),
1230                          wxCRT_PerrorW(s.wc_str()));
1231 #else
1232     wxCRT_PerrorA(s.mb_str());
1233 #endif
1234 }
1235
1236 #endif // wxCRT_PerrorA
1237
1238 wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
1239 {
1240     wxCHECK_MSG( s, NULL, "empty buffer passed to wxFgets()" );
1241
1242     wxCharBuffer buf(size - 1);
1243     // FIXME: this reads too little data if wxConvLibc uses UTF-8 ('size' wide
1244     //        characters may be encoded by up to 'size'*4 bytes), but what
1245     //        else can we do?
1246     if ( wxFgets(buf.data(), size, stream) == NULL )
1247         return NULL;
1248
1249     if ( wxConvLibc.ToWChar(s, size, buf, wxNO_LEN) == wxCONV_FAILED )
1250         return NULL;
1251
1252     return s;
1253 }
1254
1255 // ----------------------------------------------------------------------------
1256 // wxScanf() and friends
1257 // ----------------------------------------------------------------------------
1258
1259 #ifndef HAVE_NO_VSSCANF // __VISUALC__ and __DMC__ see wx/crt.h
1260 int wxVsscanf(const char *str, const char *format, va_list ap)
1261     { return wxCRT_VsscanfA(str, format, ap); }
1262 int wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap)
1263     { return wxCRT_VsscanfW(str, format, ap); }
1264 int wxVsscanf(const wxCharBuffer& str, const char *format, va_list ap)
1265     { return wxCRT_VsscanfA(str, format, ap); }
1266 int wxVsscanf(const wxWCharBuffer& str, const wchar_t *format, va_list ap)
1267     { return wxCRT_VsscanfW(str, format, ap); }
1268 int wxVsscanf(const wxString& str, const char *format, va_list ap)
1269     { return wxCRT_VsscanfA(str.mb_str(), format, ap); }
1270 int wxVsscanf(const wxString& str, const wchar_t *format, va_list ap)
1271     { return wxCRT_VsscanfW(str.wc_str(), format, ap); }
1272 int wxVsscanf(const wxCStrData& str, const char *format, va_list ap)
1273     { return wxCRT_VsscanfA(str.AsCharBuf(), format, ap); }
1274 int wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap)
1275     { return wxCRT_VsscanfW(str.AsWCharBuf(), format, ap); }
1276 #endif // HAVE_NO_VSSCANF