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
  33 #ifndef __WXPALMOS5__
  34 #ifndef __WXWINCE__
  35     #include <time.h>
  36     #include <locale.h>
  37 #else
  38     #include "wx/msw/wince/time.h"
  39 #endif
  40 #endif // !__WXPALMOS5__
  41
  42 #ifndef WX_PRECOMP
  43     #include "wx/string.h"
  44     #include "wx/hash.h"
  45     #include "wx/utils.h"     // for wxMin and wxMax
  46     #include "wx/log.h"
  47 #endif
  48
  49 #ifdef HAVE_LANGINFO_H
  50     #include <langinfo.h>
  51 #endif
  52
  53 #ifdef __WXWINCE__
  54     // there is no errno.h under CE apparently
  55     #define wxSET_ERRNO(value)
  56 #else
  57     #include <errno.h>
  58
  59     #define wxSET_ERRNO(value) errno = value
  60 #endif
  61
  62 #if defined(__MWERKS__) && __MSL__ >= 0x6000
  63 namespace std {}
  64 using namespace std ;
  65 #endif
  66
  67 #if defined(__DARWIN__)
  68         #include "wx/osx/core/cfref.h"
  69         #include <CoreFoundation/CFLocale.h>
  70         #include "wx/osx/core/cfstring.h"
  71     #include <xlocale.h>
  72 #endif
  73
  74 #if wxUSE_WCHAR_T
  75 WXDLLIMPEXP_BASE size_t wxMB2WC(wchar_t *buf, const char *psz, size_t n)
  76 {
  77   // assume that we have mbsrtowcs() too if we have wcsrtombs()
  78 #ifdef HAVE_WCSRTOMBS
  79   mbstate_t mbstate;
  80   memset(&mbstate, 0, sizeof(mbstate_t));
  81 #endif
  82
  83   if (buf) {
  84     if (!n || !*psz) {
  85       if (n) *buf = wxT('\0');
  86       return 0;
  87     }
  88 #ifdef HAVE_WCSRTOMBS
  89     return mbsrtowcs(buf, &psz, n, &mbstate);
  90 #else
  91     return wxMbstowcs(buf, psz, n);
  92 #endif
  93   }
  94
  95   // note that we rely on common (and required by Unix98 but unfortunately not
  96   // C99) extension which allows to call mbs(r)towcs() with NULL output pointer
  97   // to just get the size of the needed buffer -- this is needed as otherwise
  98   // we have no idea about how much space we need and if the CRT doesn't
  99   // support it (the only currently known example being Metrowerks, see
 100   // wx/crt.h) we don't use its mbstowcs() at all
 101 #ifdef HAVE_WCSRTOMBS
 102   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
 103 #else
 104   return wxMbstowcs((wchar_t *) NULL, psz, 0);
 105 #endif
 106 }
 107
 108 WXDLLIMPEXP_BASE size_t wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 109 {
 110 #ifdef HAVE_WCSRTOMBS
 111   mbstate_t mbstate;
 112   memset(&mbstate, 0, sizeof(mbstate_t));
 113 #endif
 114
 115   if (buf) {
 116     if (!n || !*pwz) {
 117       // glibc2.1 chokes on null input
 118       if (n) *buf = '\0';
 119       return 0;
 120     }
 121 #ifdef HAVE_WCSRTOMBS
 122     return wcsrtombs(buf, &pwz, n, &mbstate);
 123 #else
 124     return wxWcstombs(buf, pwz, n);
 125 #endif
 126   }
 127
 128 #ifdef HAVE_WCSRTOMBS
 129   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
 130 #else
 131   return wxWcstombs((char *) NULL, pwz, 0);
 132 #endif
 133 }
 134 #endif // wxUSE_WCHAR_T
 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( _T("TODO") );
 259
 260     return -1;
 261 }
 262
 263 static int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr)
 264 {
 265     wxFAIL_MSG( _T("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, _T("%s")) == NULL, -1,
 303                  _T("incomplete vswscanf implementation doesn't allow %s") );
 304     wxCHECK_MSG( wxStrstr(format, _T("%c")) == NULL, -1,
 305                  _T("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 wxWX2WCbuf buf = s.wc_str();
 582
 583     size_t len = wxConvLibc.FromWChar(out, outsize, buf);
 584     if ( len != wxCONV_FAILED )
 585         return len-1;
 586     else
 587         return wxConvLibc.FromWChar(NULL, 0, buf);
 588 }
 589 #endif // !wxUSE_UTF8_LOCALE_ONLY
 590
 591 #if wxUSE_UNICODE_UTF8
 592 int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)
 593 {
 594     const wxWX2WCbuf buf(s.wc_str());
 595     size_t len = s.length(); // same as buf length for wchar_t*
 596     if ( outsize > len )
 597     {
 598         memcpy(out, buf, (len+1) * sizeof(wchar_t));
 599     }
 600     else // not enough space
 601     {
 602         memcpy(out, buf, (outsize-1) * sizeof(wchar_t));
 603         out[outsize-1] = 0;
 604     }
 605     return len;
 606 }
 607 #endif // wxUSE_UNICODE_UTF8
 608
 609 } // anonymous namespace
 610
 611 template<typename T>
 612 static size_t PrintfViaString(T *out, size_t outsize,
 613                               const wxString& format, va_list argptr)
 614 {
 615     wxString s;
 616     s.PrintfV(format, argptr);
 617
 618     return ConvertStringToBuf(s, out, outsize);
 619 }
 620 #endif // wxUSE_UNICODE
 621
 622 int wxVsprintf(char *str, const wxString& format, va_list argptr)
 623 {
 624 #if wxUSE_UTF8_LOCALE_ONLY
 625     return wxCRT_VsprintfA(str, format.wx_str(), argptr);
 626 #else
 627     #if wxUSE_UNICODE_UTF8
 628     if ( wxLocaleIsUtf8 )
 629         return wxCRT_VsprintfA(str, format.wx_str(), argptr);
 630     else
 631     #endif
 632     #if wxUSE_UNICODE
 633     return PrintfViaString(str, wxNO_LEN, format, argptr);
 634     #else
 635     return wxCRT_VsprintfA(str, format.mb_str(), argptr);
 636     #endif
 637 #endif
 638 }
 639
 640 #if wxUSE_UNICODE
 641 int wxVsprintf(wchar_t *str, const wxString& format, va_list argptr)
 642 {
 643 #if wxUSE_UNICODE_WCHAR
 644 #ifdef __DMC__
 645 /*
 646 This fails with a bug similar to
 647 http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=c++.beta&artnum=680
 648 in DMC 8.49 and 8.50
 649 I don't see it being used in the wxWidgets sources at present (oct 2007) CE
 650 */
 651 #pragma message ( "warning ::::: wxVsprintf(wchar_t *str, const wxString& format, va_list argptr) not yet implemented" )
 652     wxFAIL_MSG( _T("TODO") );
 653
 654     return -1;
 655 #else
 656     return wxCRT_VsprintfW(str, format.wc_str(), argptr);
 657 #endif //DMC
 658 #else // wxUSE_UNICODE_UTF8
 659     #if !wxUSE_UTF8_LOCALE_ONLY
 660     if ( !wxLocaleIsUtf8 )
 661         return wxCRT_VsprintfW(str, format.wc_str(), argptr);
 662     else
 663     #endif
 664         return PrintfViaString(str, wxNO_LEN, format, argptr);
 665 #endif // wxUSE_UNICODE_UTF8
 666 }
 667 #endif // wxUSE_UNICODE
 668
 669 int wxVsnprintf(char *str, size_t size, const wxString& format, va_list argptr)
 670 {
 671     int rv;
 672 #if wxUSE_UTF8_LOCALE_ONLY
 673     rv = wxCRT_VsnprintfA(str, size, format.wx_str(), argptr);
 674 #else
 675     #if wxUSE_UNICODE_UTF8
 676     if ( wxLocaleIsUtf8 )
 677         rv = wxCRT_VsnprintfA(str, size, format.wx_str(), argptr);
 678     else
 679     #endif
 680     #if wxUSE_UNICODE
 681     {
 682         // NB: if this code is called, then wxString::PrintV() would use the
 683         //     wchar_t* version of wxVsnprintf(), so it's safe to use PrintV()
 684         //     from here
 685         rv = PrintfViaString(str, size, format, argptr);
 686     }
 687     #else
 688     rv = wxCRT_VsnprintfA(str, size, format.mb_str(), argptr);
 689     #endif
 690 #endif
 691
 692     // VsnprintfTestCase reveals that glibc's implementation of vswprintf
 693     // doesn't nul terminate on truncation.
 694     str[size - 1] = 0;
 695
 696     return rv;
 697 }
 698
 699 #if wxUSE_UNICODE
 700 int wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argptr)
 701 {
 702     int rv;
 703
 704 #if wxUSE_UNICODE_WCHAR
 705     rv = wxCRT_VsnprintfW(str, size, format.wc_str(), argptr);
 706 #else // wxUSE_UNICODE_UTF8
 707     #if !wxUSE_UTF8_LOCALE_ONLY
 708     if ( !wxLocaleIsUtf8 )
 709         rv = wxCRT_VsnprintfW(str, size, format.wc_str(), argptr);
 710     else
 711     #endif
 712     {
 713         // NB: if this code is called, then wxString::PrintV() would use the
 714         //     char* version of wxVsnprintf(), so it's safe to use PrintV()
 715         //     from here
 716         rv = PrintfViaString(str, size, format, argptr);
 717     }
 718 #endif // wxUSE_UNICODE_UTF8
 719
 720     // VsnprintfTestCase reveals that glibc's implementation of vswprintf
 721     // doesn't nul terminate on truncation.
 722     str[size - 1] = 0;
 723
 724     return rv;
 725 }
 726 #endif // wxUSE_UNICODE
 727
 728 #if wxUSE_WCHAR_T
 729
 730 // ----------------------------------------------------------------------------
 731 // ctype.h stuff (currently unused)
 732 // ----------------------------------------------------------------------------
 733
 734 #ifdef wxNEED_WX_MBSTOWCS
 735
 736 WXDLLIMPEXP_BASE size_t wxMbstowcs (wchar_t * out, const char * in, size_t outlen)
 737 {
 738     if (!out)
 739     {
 740         size_t outsize = 0;
 741         while(*in++)
 742             outsize++;
 743         return outsize;
 744     }
 745
 746     const char* origin = in;
 747
 748     while (outlen-- && *in)
 749     {
 750         *out++ = (wchar_t) *in++;
 751     }
 752
 753     *out = '\0';
 754
 755     return in - origin;
 756 }
 757
 758 WXDLLIMPEXP_BASE size_t wxWcstombs (char * out, const wchar_t * in, size_t outlen)
 759 {
 760     if (!out)
 761     {
 762         size_t outsize = 0;
 763         while(*in++)
 764             outsize++;
 765         return outsize;
 766     }
 767
 768     const wchar_t* origin = in;
 769
 770     while (outlen-- && *in)
 771     {
 772         *out++ = (char) *in++;
 773     }
 774
 775     *out = '\0';
 776
 777     return in - origin;
 778 }
 779
 780 #endif // wxNEED_WX_MBSTOWCS
 781
 782 #ifndef wxCRT_StrdupA
 783 WXDLLIMPEXP_BASE char *wxCRT_StrdupA(const char *s)
 784 {
 785     return strcpy((char *)malloc(strlen(s) + 1), s);
 786 }
 787 #endif // wxCRT_StrdupA
 788
 789 #ifndef wxCRT_StrdupW
 790 WXDLLIMPEXP_BASE wchar_t * wxCRT_StrdupW(const wchar_t *pwz)
 791 {
 792   size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
 793   wchar_t *ret = (wchar_t *) malloc(size);
 794   memcpy(ret, pwz, size);
 795   return ret;
 796 }
 797 #endif // wxCRT_StrdupW
 798
 799 #ifndef wxWCHAR_T_IS_WXCHAR16
 800 size_t wxStrlen(const wxChar16 *s )
 801 {
 802     if (!s) return 0;
 803     size_t i=0;
 804     while (*s!=0) { ++i; ++s; };
 805     return i;
 806 }
 807
 808 wxChar16* wxStrdup(const wxChar16* s)
 809 {
 810   size_t size = (wxStrlen(s) + 1) * sizeof(wxChar16);
 811   wxChar16 *ret = (wxChar16*) malloc(size);
 812   memcpy(ret, s, size);
 813   return ret;
 814 }
 815 #endif
 816
 817 #ifndef wxWCHAR_T_IS_WXCHAR32
 818 size_t wxStrlen(const wxChar32 *s )
 819 {
 820     if (!s) return 0;
 821     size_t i=0;
 822     while (*s!=0) { ++i; ++s; };
 823     return i;
 824 }
 825
 826 wxChar32* wxStrdup(const wxChar32* s)
 827 {
 828   size_t size = (wxStrlen(s) + 1) * sizeof(wxChar32);
 829   wxChar32 *ret = (wxChar32*) malloc(size);
 830   memcpy(ret, s, size);
 831   return ret;
 832 }
 833 #endif
 834
 835 #ifndef wxCRT_StricmpA
 836 WXDLLIMPEXP_BASE int wxCRT_StricmpA(const char *psz1, const char *psz2)
 837 {
 838   register char c1, c2;
 839   do {
 840     c1 = wxTolower(*psz1++);
 841     c2 = wxTolower(*psz2++);
 842   } while ( c1 && (c1 == c2) );
 843   return c1 - c2;
 844 }
 845 #endif // !defined(wxCRT_StricmpA)
 846
 847 #ifndef wxCRT_StricmpW
 848 WXDLLIMPEXP_BASE int wxCRT_StricmpW(const wchar_t *psz1, const wchar_t *psz2)
 849 {
 850   register wchar_t c1, c2;
 851   do {
 852     c1 = wxTolower(*psz1++);
 853     c2 = wxTolower(*psz2++);
 854   } while ( c1 && (c1 == c2) );
 855   return c1 - c2;
 856 }
 857 #endif // !defined(wxCRT_StricmpW)
 858
 859 #ifndef wxCRT_StrnicmpA
 860 WXDLLIMPEXP_BASE int wxCRT_StrnicmpA(const char *s1, const char *s2, size_t n)
 861 {
 862   // initialize the variables just to suppress stupid gcc warning
 863   register char c1 = 0, c2 = 0;
 864   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
 865   if (n) {
 866     if (c1 < c2) return -1;
 867     if (c1 > c2) return 1;
 868   }
 869   return 0;
 870 }
 871 #endif // !defined(wxCRT_StrnicmpA)
 872
 873 #ifndef wxCRT_StrnicmpW
 874 WXDLLIMPEXP_BASE int wxCRT_StrnicmpW(const wchar_t *s1, const wchar_t *s2, size_t n)
 875 {
 876   // initialize the variables just to suppress stupid gcc warning
 877   register wchar_t c1 = 0, c2 = 0;
 878   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
 879   if (n) {
 880     if (c1 < c2) return -1;
 881     if (c1 > c2) return 1;
 882   }
 883   return 0;
 884 }
 885 #endif // !defined(wxCRT_StrnicmpW)
 886
 887 // ----------------------------------------------------------------------------
 888 // string.h functions
 889 // ----------------------------------------------------------------------------
 890
 891 // this (and wxCRT_StrncmpW below) are extern "C" because they are needed
 892 // by regex code, the rest isn't needed, so it's not declared as extern "C"
 893 #ifndef wxCRT_StrlenW
 894 extern "C" WXDLLIMPEXP_BASE size_t wxCRT_StrlenW(const wchar_t *s)
 895 {
 896     size_t n = 0;
 897     while ( *s++ )
 898         n++;
 899
 900     return n;
 901 }
 902 #endif
 903
 904 // ----------------------------------------------------------------------------
 905 // stdlib.h functions
 906 // ----------------------------------------------------------------------------
 907
 908 #ifndef wxCRT_GetenvW
 909 WXDLLIMPEXP_BASE wchar_t* wxCRT_GetenvW(const wchar_t *name)
 910 {
 911     // NB: buffer returned by getenv() is allowed to be overwritten next
 912     //     time getenv() is called, so it is OK to use static string
 913     //     buffer to hold the data.
 914     static wxWCharBuffer value((wchar_t*)NULL);
 915     value = wxConvLibc.cMB2WC(getenv(wxConvLibc.cWC2MB(name)));
 916     return value.data();
 917 }
 918 #endif // !wxCRT_GetenvW
 919
 920 #ifndef wxCRT_StrftimeW
 921 WXDLLIMPEXP_BASE size_t
 922 wxCRT_StrftimeW(wchar_t *s, size_t maxsize, const wchar_t *fmt, const struct tm *tm)
 923 {
 924     if ( !maxsize )
 925         return 0;
 926
 927     wxCharBuffer buf(maxsize);
 928
 929     wxCharBuffer bufFmt(wxConvLibc.cWX2MB(fmt));
 930     if ( !bufFmt )
 931         return 0;
 932
 933     size_t ret = strftime(buf.data(), maxsize, bufFmt, tm);
 934     if  ( !ret )
 935         return 0;
 936
 937     wxWCharBuffer wbuf = wxConvLibc.cMB2WX(buf);
 938     if ( !wbuf )
 939         return 0;
 940
 941     wxCRT_StrncpyW(s, wbuf, maxsize);
 942     return wxCRT_StrlenW(s);
 943 }
 944 #endif // !wxCRT_StrftimeW
 945
 946 #endif // wxUSE_WCHAR_T
 947
 948 #ifdef wxLongLong_t
 949 template<typename T>
 950 static wxULongLong_t
 951 wxCRT_StrtoullBase(const T* nptr, T** endptr, int base, T* sign)
 952 {
 953     wxULongLong_t sum = 0;
 954     wxString wxstr(nptr);
 955     wxString::const_iterator i = wxstr.begin();
 956     wxString::const_iterator end = wxstr.end();
 957
 958     // Skip spaces
 959     while ( i != end && wxIsspace(*i) ) ++i;
 960
 961     // Starts with sign?
 962     *sign = wxT(' ');
 963     if ( i != end )
 964     {
 965         T c = *i;
 966         if ( c == wxT('+') || c == wxT('-') )
 967         {
 968             *sign = c;
 969             ++i;
 970         }
 971     }
 972
 973     // Starts with 0x?
 974     if ( i != end && *i == wxT('0') )
 975     {
 976         ++i;
 977         if ( i != end )
 978         {
 979             if ( *i == wxT('x') && (base == 16 || base == 0) )
 980             {
 981                 base = 16;
 982                 ++i;
 983             }
 984             else
 985             {
 986                 if ( endptr )
 987                     *endptr = (T*) nptr;
 988                 wxSET_ERRNO(EINVAL);
 989                 return sum;
 990             }
 991         }
 992         else
 993             --i;
 994     }
 995
 996     if ( base == 0 )
 997         base = 10;
 998
 999     for ( ; i != end; ++i )
1000     {
1001         unsigned int n;
1002
1003         T c = *i;
1004         if ( c >= '0' )
1005         {
1006             if ( c <= '9' )
1007                 n = c - wxT('0');
1008             else
1009                 n = wxTolower(c) - wxT('a') + 10;
1010         }
1011         else
1012             break;
1013
1014         if ( n >= (unsigned int)base )
1015             // Invalid character (for this base)
1016             break;
1017
1018         wxULongLong_t prevsum = sum;
1019         sum = (sum * base) + n;
1020
1021         if ( sum < prevsum )
1022         {
1023             wxSET_ERRNO(ERANGE);
1024             break;
1025         }
1026     }
1027
1028     if ( endptr )
1029     {
1030         *endptr = (T*)(nptr + (i - wxstr.begin()));
1031     }
1032
1033     return sum;
1034 }
1035
1036 template<typename T>
1037 static wxULongLong_t wxCRT_DoStrtoull(const T* nptr, T** endptr, int base)
1038 {
1039     T sign;
1040     wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);
1041
1042     if ( sign == wxT('-') )
1043     {
1044         wxSET_ERRNO(ERANGE);
1045         uval = 0;
1046     }
1047
1048     return uval;
1049 }
1050
1051 template<typename T>
1052 static wxLongLong_t wxCRT_DoStrtoll(const T* nptr, T** endptr, int base)
1053 {
1054     T sign;
1055     wxULongLong_t uval = ::wxCRT_StrtoullBase(nptr, endptr, base, &sign);
1056     wxLongLong_t val = 0;
1057
1058     if ( sign == wxT('-') )
1059     {
1060         if (uval <= (wxULongLong_t)wxINT64_MAX + 1)
1061         {
1062             val = -(wxLongLong_t)uval;
1063         }
1064         else
1065         {
1066             wxSET_ERRNO(ERANGE);
1067         }
1068     }
1069     else if ( uval <= wxINT64_MAX )
1070     {
1071         val = uval;
1072     }
1073     else
1074     {
1075         wxSET_ERRNO(ERANGE);
1076     }
1077
1078     return val;
1079 }
1080
1081 #ifndef wxCRT_StrtollA
1082 wxLongLong_t wxCRT_StrtollA(const char* nptr, char** endptr, int base)
1083     { return wxCRT_DoStrtoll(nptr, endptr, base); }
1084 #endif
1085 #ifndef wxCRT_StrtollW
1086 wxLongLong_t wxCRT_StrtollW(const wchar_t* nptr, wchar_t** endptr, int base)
1087     { return wxCRT_DoStrtoll(nptr, endptr, base); }
1088 #endif
1089
1090 #ifndef wxCRT_StrtoullA
1091 wxULongLong_t wxCRT_StrtoullA(const char* nptr, char** endptr, int base)
1092     { return wxCRT_DoStrtoull(nptr, endptr, base); }
1093 #endif
1094 #ifndef wxCRT_StrtoullW
1095 wxULongLong_t wxCRT_StrtoullW(const wchar_t* nptr, wchar_t** endptr, int base)
1096     { return wxCRT_DoStrtoull(nptr, endptr, base); }
1097 #endif
1098
1099 #endif // wxLongLong_t
1100
1101 // ----------------------------------------------------------------------------
1102 // functions which we may need even if !wxUSE_WCHAR_T
1103 // ----------------------------------------------------------------------------
1104
1105 template<typename T>
1106 static T *wxCRT_DoStrtok(T *psz, const T *delim, T **save_ptr)
1107 {
1108     if (!psz)
1109     {
1110         psz = *save_ptr;
1111         if ( !psz )
1112             return NULL;
1113     }
1114
1115     psz += wxStrspn(psz, delim);
1116     if (!*psz)
1117     {
1118         *save_ptr = (T *)NULL;
1119         return (T *)NULL;
1120     }
1121
1122     T *ret = psz;
1123     psz = wxStrpbrk(psz, delim);
1124     if (!psz)
1125     {
1126         *save_ptr = (T*)NULL;
1127     }
1128     else
1129     {
1130         *psz = wxT('\0');
1131         *save_ptr = psz + 1;
1132     }
1133
1134     return ret;
1135 }
1136
1137 #ifndef wxCRT_StrtokA
1138 char *wxCRT_StrtokA(char *psz, const char *delim, char **save_ptr)
1139     { return wxCRT_DoStrtok(psz, delim, save_ptr); }
1140 #endif
1141 #ifndef wxCRT_StrtokW
1142 wchar_t *wxCRT_StrtokW(wchar_t *psz, const wchar_t *delim, wchar_t **save_ptr)
1143     { return wxCRT_DoStrtok(psz, delim, save_ptr); }
1144 #endif
1145
1146 // ----------------------------------------------------------------------------
1147 // missing C RTL functions
1148 // ----------------------------------------------------------------------------
1149
1150 #ifdef wxNEED_STRDUP
1151
1152 char *strdup(const char *s)
1153 {
1154     char *dest = (char*) malloc( strlen( s ) + 1 ) ;
1155     if ( dest )
1156         strcpy( dest , s ) ;
1157     return dest ;
1158 }
1159 #endif // wxNEED_STRDUP
1160
1161 #if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
1162
1163 void *calloc( size_t num, size_t size )
1164 {
1165     void** ptr = (void **)malloc(num * size);
1166     memset( ptr, 0, num * size);
1167     return ptr;
1168 }
1169
1170 #endif // __WXWINCE__ <= 211
1171
1172 // ============================================================================
1173 // wxLocaleIsUtf8
1174 // ============================================================================
1175
1176 #if wxUSE_UNICODE_UTF8
1177
1178 #if !wxUSE_UTF8_LOCALE_ONLY
1179 bool wxLocaleIsUtf8 = false; // the safer setting if not known
1180 #endif
1181
1182 static bool wxIsLocaleUtf8()
1183 {
1184     // NB: we intentionally don't use wxLocale::GetSystemEncodingName(),
1185     //     because a) it may be unavailable in some builds and b) has slightly
1186     //     different semantics (default locale instead of current)
1187
1188 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
1189     // GNU libc provides current character set this way (this conforms to
1190     // Unix98)
1191     const char *charset = nl_langinfo(CODESET);
1192     if ( charset )
1193     {
1194         // "UTF-8" is used by modern glibc versions, but test other variants
1195         // as well, just in case:
1196         if ( strcmp(charset, "UTF-8") == 0 ||
1197              strcmp(charset, "utf-8") == 0 ||
1198              strcmp(charset, "UTF8") == 0 ||
1199              strcmp(charset, "utf8") == 0 )
1200         {
1201             return true;
1202         }
1203     }
1204 #endif // HAVE_LANGINFO_H
1205
1206     // check if we're running under the "C" locale: it is 7bit subset
1207     // of UTF-8, so it can be safely used with the UTF-8 build:
1208     const char *lc_ctype = setlocale(LC_CTYPE, NULL);
1209     if ( lc_ctype &&
1210          (strcmp(lc_ctype, "C") == 0 || strcmp(lc_ctype, "POSIX") == 0) )
1211     {
1212         return true;
1213     }
1214
1215     // we don't know what charset libc is using, so assume the worst
1216     // to be safe:
1217     return false;
1218 }
1219
1220 void wxUpdateLocaleIsUtf8()
1221 {
1222 #if wxUSE_UTF8_LOCALE_ONLY
1223     if ( !wxIsLocaleUtf8() )
1224     {
1225         wxLogFatalError(_T("This program requires UTF-8 locale to run."));
1226     }
1227 #else // !wxUSE_UTF8_LOCALE_ONLY
1228     wxLocaleIsUtf8 = wxIsLocaleUtf8();
1229 #endif
1230 }
1231
1232 #endif // wxUSE_UNICODE_UTF8
1233
1234 // ============================================================================
1235 // wx wrappers for CRT functions
1236 // ============================================================================
1237
1238 #if wxUSE_UNICODE_WCHAR
1239     #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW)  return_kw callW
1240 #elif wxUSE_UNICODE_UTF8 && !wxUSE_UTF8_LOCALE_ONLY
1241     #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW) \
1242             return_kw wxLocaleIsUtf8 ? callA : callW
1243 #else // ANSI or UTF8 only
1244     #define CALL_ANSI_OR_UNICODE(return_kw, callA, callW)  return_kw callA
1245 #endif
1246
1247 int wxPuts(const wxString& s)
1248 {
1249     CALL_ANSI_OR_UNICODE(return,
1250                          wxCRT_PutsA(s.mb_str()),
1251                          wxCRT_PutsW(s.wc_str()));
1252 }
1253
1254 int wxFputs(const wxString& s, FILE *stream)
1255 {
1256     CALL_ANSI_OR_UNICODE(return,
1257                          wxCRT_FputsA(s.mb_str(), stream),
1258                          wxCRT_FputsW(s.wc_str(), stream));
1259 }
1260
1261 int wxFputc(const wxUniChar& c, FILE *stream)
1262 {
1263 #if !wxUSE_UNICODE // FIXME-UTF8: temporary, remove this with ANSI build
1264     return wxCRT_FputcA((char)c, stream);
1265 #else
1266     CALL_ANSI_OR_UNICODE(return,
1267                          wxCRT_FputsA(c.AsUTF8(), stream),
1268                          wxCRT_FputcW((wchar_t)c, stream));
1269 #endif
1270 }
1271
1272 #ifdef wxCRT_PerrorA
1273
1274 void wxPerror(const wxString& s)
1275 {
1276 #ifdef wxCRT_PerrorW
1277     CALL_ANSI_OR_UNICODE(wxEMPTY_PARAMETER_VALUE,
1278                          wxCRT_PerrorA(s.mb_str()),
1279                          wxCRT_PerrorW(s.wc_str()));
1280 #else
1281     wxCRT_PerrorA(s.mb_str());
1282 #endif
1283 }
1284
1285 #endif // wxCRT_PerrorA
1286
1287 wchar_t *wxFgets(wchar_t *s, int size, FILE *stream)
1288 {
1289     wxCHECK_MSG( s, NULL, "empty buffer passed to wxFgets()" );
1290
1291     wxCharBuffer buf(size - 1);
1292     // FIXME: this reads too little data if wxConvLibc uses UTF-8 ('size' wide
1293     //        characters may be encoded by up to 'size'*4 bytes), but what
1294     //        else can we do?
1295     if ( wxFgets(buf.data(), size, stream) == NULL )
1296         return NULL;
1297
1298     if ( wxConvLibc.ToWChar(s, size, buf, wxNO_LEN) == wxCONV_FAILED )
1299         return NULL;
1300
1301     return s;
1302 }
1303
1304 // ----------------------------------------------------------------------------
1305 // wxScanf() and friends
1306 // ----------------------------------------------------------------------------
1307
1308 #ifdef HAVE_VSSCANF // __VISUALC__ and __DMC__ see wx/crt.h
1309 int wxVsscanf(const char *str, const char *format, va_list ap)
1310     { return wxCRT_VsscanfA(str, format, ap); }
1311 int wxVsscanf(const wchar_t *str, const wchar_t *format, va_list ap)
1312     { return wxCRT_VsscanfW(str, format, ap); }
1313 int wxVsscanf(const wxCharBuffer& str, const char *format, va_list ap)
1314     { return wxCRT_VsscanfA(static_cast<const char*>(str), format, ap); }
1315 int wxVsscanf(const wxWCharBuffer& str, const wchar_t *format, va_list ap)
1316     { return wxCRT_VsscanfW(str, format, ap); }
1317 int wxVsscanf(const wxString& str, const char *format, va_list ap)
1318     { return wxCRT_VsscanfA(static_cast<const char*>(str.mb_str()), format, ap); }
1319 int wxVsscanf(const wxString& str, const wchar_t *format, va_list ap)
1320     { return wxCRT_VsscanfW(str.wc_str(), format, ap); }
1321 int wxVsscanf(const wxCStrData& str, const char *format, va_list ap)
1322     { return wxCRT_VsscanfA(static_cast<const char*>(str.AsCharBuf()), format, ap); }
1323 int wxVsscanf(const wxCStrData& str, const wchar_t *format, va_list ap)
1324     { return wxCRT_VsscanfW(str.AsWCharBuf(), format, ap); }
1325 #endif // HAVE_NO_VSSCANF