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