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