src/common/wxcrt.cpp

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