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