src/common/log.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        log.cpp
   3 // Purpose:     Assorted wxLogXXX functions, and wxLog (sink for logs)
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21   #pragma implementation "log.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28   #pragma hdrstop
  29 #endif
  30
  31 // wxWindows
  32 #ifndef WX_PRECOMP
  33     #include "wx/string.h"
  34     #include "wx/intl.h"
  35     #include "wx/app.h"
  36
  37     #if wxUSE_GUI
  38         #include "wx/window.h"
  39         #ifdef __WXMSW__
  40             #include "wx/msw/private.h"
  41         #endif
  42         #include "wx/msgdlg.h"
  43     #endif
  44 #endif //WX_PRECOMP
  45
  46 #include  "wx/file.h"
  47 #include  "wx/textfile.h"
  48 #include  "wx/utils.h"
  49 #include  "wx/wxchar.h"
  50 #include  "wx/log.h"
  51 #include  "wx/thread.h"
  52
  53 #if wxUSE_LOG
  54
  55 // other standard headers
  56 #include  <errno.h>
  57 #include  <stdlib.h>
  58 #include  <time.h>
  59
  60 #ifdef  __WXMSW__
  61   #include  "wx/msw/private.h"      // includes windows.h for OutputDebugString
  62 #else   //Unix
  63   #include  <signal.h>
  64 #endif  //Win/Unix
  65
  66 // ----------------------------------------------------------------------------
  67 // non member functions
  68 // ----------------------------------------------------------------------------
  69
  70 // define this to enable wrapping of log messages
  71 //#define LOG_PRETTY_WRAP
  72
  73 #ifdef  LOG_PRETTY_WRAP
  74   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  75 #endif
  76
  77 // ============================================================================
  78 // implementation
  79 // ============================================================================
  80
  81 // ----------------------------------------------------------------------------
  82 // globals
  83 // ----------------------------------------------------------------------------
  84
  85 // log functions can't allocate memory (LogError("out of memory...") should
  86 // work!), so we use a static buffer for all log messages
  87 #define LOG_BUFFER_SIZE   (4096)
  88
  89 // static buffer for error messages
  90 static wxChar s_szBuf[LOG_BUFFER_SIZE];
  91
  92 #if wxUSE_THREADS
  93
  94 // the critical section protecting the static buffer
  95 static wxCriticalSection gs_csLogBuf;
  96
  97 #endif // wxUSE_THREADS
  98
  99 // ----------------------------------------------------------------------------
 100 // implementation of Log functions
 101 //
 102 // NB: unfortunately we need all these distinct functions, we can't make them
 103 //     macros and not all compilers inline vararg functions.
 104 // ----------------------------------------------------------------------------
 105
 106 // generic log function
 107 void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
 108 {
 109   if ( wxLog::GetActiveTarget() != NULL ) {
 110     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 111
 112     va_list argptr;
 113     va_start(argptr, szFormat);
 114     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 115     va_end(argptr);
 116
 117     wxLog::OnLog(level, s_szBuf, time(NULL));
 118   }
 119 }
 120
 121 #define IMPLEMENT_LOG_FUNCTION(level)                             \
 122   void wxLog##level(const wxChar *szFormat, ...)                  \
 123   {                                                               \
 124     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 125       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                    \
 126                                                                   \
 127       va_list argptr;                                             \
 128       va_start(argptr, szFormat);                                 \
 129       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);  \
 130       va_end(argptr);                                             \
 131                                                                   \
 132       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));           \
 133     }                                                             \
 134   }
 135
 136 IMPLEMENT_LOG_FUNCTION(FatalError)
 137 IMPLEMENT_LOG_FUNCTION(Error)
 138 IMPLEMENT_LOG_FUNCTION(Warning)
 139 IMPLEMENT_LOG_FUNCTION(Message)
 140 IMPLEMENT_LOG_FUNCTION(Info)
 141 IMPLEMENT_LOG_FUNCTION(Status)
 142
 143 // same as info, but only if 'verbose' mode is on
 144 void wxLogVerbose(const wxChar *szFormat, ...)
 145 {
 146   wxLog *pLog = wxLog::GetActiveTarget();
 147   if ( pLog != NULL && pLog->GetVerbose() ) {
 148     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 149
 150     va_list argptr;
 151     va_start(argptr, szFormat);
 152     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 153     va_end(argptr);
 154
 155     wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
 156   }
 157 }
 158
 159 // debug functions
 160 #ifdef __WXDEBUG__
 161 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                       \
 162   void wxLog##level(const wxChar *szFormat, ...)                  \
 163   {                                                               \
 164     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 165       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                    \
 166                                                                   \
 167       va_list argptr;                                             \
 168       va_start(argptr, szFormat);                                 \
 169       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);  \
 170       va_end(argptr);                                             \
 171                                                                   \
 172       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));           \
 173     }                                                             \
 174   }
 175
 176   void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
 177   {
 178     wxLog *pLog = wxLog::GetActiveTarget();
 179
 180     if ( pLog != NULL && wxLog::IsAllowedTraceMask(mask) ) {
 181       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 182
 183       wxChar *p = s_szBuf;
 184       size_t len = WXSIZEOF(s_szBuf);
 185       wxStrncpy(s_szBuf, _T("("), len);
 186       len -= 1; // strlen("(")
 187       p += 1;
 188       wxStrncat(p, mask, len);
 189       size_t lenMask = wxStrlen(mask);
 190       len -= lenMask;
 191       p += lenMask;
 192
 193       wxStrncat(p, _T(") "), len);
 194       len -= 2;
 195       p += 2;
 196
 197       va_list argptr;
 198       va_start(argptr, szFormat);
 199       wxVsnprintf(p, len, szFormat, argptr);
 200       va_end(argptr);
 201
 202       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 203     }
 204   }
 205
 206   void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
 207   {
 208     wxLog *pLog = wxLog::GetActiveTarget();
 209
 210     // we check that all of mask bits are set in the current mask, so
 211     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 212     // if both bits are set.
 213     if ( pLog != NULL && ((pLog->GetTraceMask() & mask) == mask) ) {
 214       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 215
 216       va_list argptr;
 217       va_start(argptr, szFormat);
 218       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 219       va_end(argptr);
 220
 221       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 222     }
 223   }
 224
 225 #else // release
 226   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 227 #endif
 228
 229 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 230 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 231
 232 // wxLogSysError: one uses the last error code, for other  you must give it
 233 // explicitly
 234
 235 // common part of both wxLogSysError
 236 void wxLogSysErrorHelper(long lErrCode)
 237 {
 238     wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
 239     wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
 240                _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 241     wxStrncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - wxStrlen(s_szBuf));
 242
 243     wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
 244 }
 245
 246 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
 247 {
 248     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 249
 250     va_list argptr;
 251     va_start(argptr, szFormat);
 252     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 253     va_end(argptr);
 254
 255     wxLogSysErrorHelper(wxSysErrorCode());
 256 }
 257
 258 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
 259 {
 260     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 261
 262     va_list argptr;
 263     va_start(argptr, szFormat);
 264     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 265     va_end(argptr);
 266
 267     wxLogSysErrorHelper(lErrCode);
 268 }
 269
 270 // ----------------------------------------------------------------------------
 271 // wxLog class implementation
 272 // ----------------------------------------------------------------------------
 273
 274 wxLog::wxLog()
 275 {
 276     m_bHasMessages = FALSE;
 277
 278     // enable verbose messages by default in the debug builds
 279 #ifdef __WXDEBUG__
 280     m_bVerbose = TRUE;
 281 #else // release
 282     m_bVerbose = FALSE;
 283 #endif // debug/release
 284 }
 285
 286 wxLog *wxLog::GetActiveTarget()
 287 {
 288     if ( ms_bAutoCreate && ms_pLogger == NULL ) {
 289         // prevent infinite recursion if someone calls wxLogXXX() from
 290         // wxApp::CreateLogTarget()
 291         static bool s_bInGetActiveTarget = FALSE;
 292         if ( !s_bInGetActiveTarget ) {
 293             s_bInGetActiveTarget = TRUE;
 294
 295             // ask the application to create a log target for us
 296             if ( wxTheApp != NULL )
 297                 ms_pLogger = wxTheApp->CreateLogTarget();
 298             else
 299                 ms_pLogger = new wxLogStderr;
 300
 301             s_bInGetActiveTarget = FALSE;
 302
 303             // do nothing if it fails - what can we do?
 304         }
 305     }
 306
 307     return ms_pLogger;
 308 }
 309
 310 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 311 {
 312     if ( ms_pLogger != NULL ) {
 313         // flush the old messages before changing because otherwise they might
 314         // get lost later if this target is not restored
 315         ms_pLogger->Flush();
 316     }
 317
 318     wxLog *pOldLogger = ms_pLogger;
 319     ms_pLogger = pLogger;
 320
 321     return pOldLogger;
 322 }
 323
 324 void wxLog::RemoveTraceMask(const wxString& str)
 325 {
 326     int index = ms_aTraceMasks.Index(str);
 327     if ( index != wxNOT_FOUND )
 328         ms_aTraceMasks.Remove((size_t)index);
 329 }
 330
 331 void wxLog::TimeStamp(wxString *str)
 332 {
 333     if ( ms_timestamp )
 334     {
 335         wxChar buf[256];
 336         time_t timeNow;
 337         (void)time(&timeNow);
 338         wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
 339
 340         str->Empty();
 341         *str << buf << wxT(": ");
 342     }
 343 }
 344
 345 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 346 {
 347     switch ( level ) {
 348         case wxLOG_FatalError:
 349             DoLogString(wxString(_("Fatal error: ")) + szString, t);
 350             DoLogString(_("Program aborted."), t);
 351             Flush();
 352             abort();
 353             break;
 354
 355         case wxLOG_Error:
 356             DoLogString(wxString(_("Error: ")) + szString, t);
 357             break;
 358
 359         case wxLOG_Warning:
 360             DoLogString(wxString(_("Warning: ")) + szString, t);
 361             break;
 362
 363         case wxLOG_Info:
 364             if ( GetVerbose() )
 365         case wxLOG_Message:
 366         case wxLOG_Status:
 367         default:    // log unknown log levels too
 368                 DoLogString(szString, t);
 369             break;
 370
 371         case wxLOG_Trace:
 372         case wxLOG_Debug:
 373 #ifdef __WXDEBUG__
 374             {
 375                 wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
 376                                                     : wxT("Debug: ");
 377                 msg << szString;
 378                 DoLogString(msg, t);
 379             }
 380 #endif // Debug
 381             break;
 382     }
 383 }
 384
 385 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
 386 {
 387     wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
 388 }
 389
 390 void wxLog::Flush()
 391 {
 392     // do nothing
 393 }
 394
 395 // ----------------------------------------------------------------------------
 396 // wxLogStderr class implementation
 397 // ----------------------------------------------------------------------------
 398
 399 wxLogStderr::wxLogStderr(FILE *fp)
 400 {
 401     if ( fp == NULL )
 402         m_fp = stderr;
 403     else
 404         m_fp = fp;
 405 }
 406
 407 #if defined(__WXMAC__)
 408 #define kDebuggerSignature              'MWDB'
 409
 410 static Boolean FindProcessBySignature(OSType signature, ProcessInfoRec* info)
 411 {
 412         OSErr err;
 413         ProcessSerialNumber psn;
 414         Boolean found = false;
 415         psn.highLongOfPSN = 0;
 416         psn.lowLongOfPSN = kNoProcess;
 417
 418         if (!info) return false;
 419
 420         info->processInfoLength = sizeof(ProcessInfoRec);
 421         info->processName = NULL;
 422         info->processAppSpec = NULL;
 423
 424         err = noErr;
 425         while (!found && err == noErr)
 426         {
 427                 err = GetNextProcess(&psn);
 428                 if (err == noErr)
 429                 {
 430                         err = GetProcessInformation(&psn, info);
 431                         found = err == noErr && info->processSignature == signature;
 432                 }
 433         }
 434         return found;
 435 }
 436
 437 pascal Boolean MWDebuggerIsRunning(void)
 438 {
 439         ProcessInfoRec info;
 440         return FindProcessBySignature(kDebuggerSignature, &info);
 441 }
 442
 443 pascal OSErr AmIBeingMWDebugged(Boolean* result)
 444 {
 445         OSErr err;
 446         ProcessSerialNumber psn;
 447         OSType sig = kDebuggerSignature;
 448         AppleEvent      theAE = {typeNull, NULL};
 449         AppleEvent      theReply = {typeNull, NULL};
 450         AEAddressDesc addr  = {typeNull, NULL};
 451         DescType actualType;
 452         Size actualSize;
 453
 454         if (!result) return paramErr;
 455
 456         err = AECreateDesc(typeApplSignature, &sig, sizeof(sig), &addr);
 457         if (err != noErr) goto exit;
 458
 459         err = AECreateAppleEvent('MWDB', 'Dbg?', &addr,
 460                                 kAutoGenerateReturnID, kAnyTransactionID, &theAE);
 461         if (err != noErr) goto exit;
 462
 463         GetCurrentProcess(&psn);
 464         err = AEPutParamPtr(&theAE, keyDirectObject, typeProcessSerialNumber,
 465                         &psn, sizeof(psn));
 466         if (err != noErr) goto exit;
 467
 468         err = AESend(&theAE, &theReply, kAEWaitReply, kAENormalPriority,
 469                                         kAEDefaultTimeout, NULL, NULL);
 470         if (err != noErr) goto exit;
 471
 472         err = AEGetParamPtr(&theReply, keyAEResult, typeBoolean, &actualType, result,
 473                                 sizeof(Boolean), &actualSize);
 474
 475 exit:
 476         if (addr.dataHandle)
 477                 AEDisposeDesc(&addr);
 478         if (theAE.dataHandle)
 479                 AEDisposeDesc(&theAE);
 480         if (theReply.dataHandle)
 481                 AEDisposeDesc(&theReply);
 482
 483         return err;
 484 }
 485 #endif
 486
 487 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 488 {
 489     wxString str;
 490     TimeStamp(&str);
 491     str << szString;
 492
 493     fputs(str.mb_str(), m_fp);
 494     fputc(_T('\n'), m_fp);
 495     fflush(m_fp);
 496
 497     // under Windows, programs usually don't have stderr at all, so show the
 498     // messages also under debugger - unless it's a console program
 499 #if defined(__WXMSW__) && wxUSE_GUI
 500     str += wxT("\r\n") ;
 501     OutputDebugString(str.c_str());
 502 #endif // MSW
 503 #if defined(__WXMAC__) && wxUSE_GUI
 504         Str255 pstr ;
 505         strcpy( (char*) pstr , str.c_str() ) ;
 506         strcat( (char*) pstr , ";g" ) ;
 507         c2pstr( (char*) pstr ) ;
 508 #if __WXDEBUG__
 509         Boolean running = false ;
 510
 511 /*
 512         if ( MWDebuggerIsRunning() )
 513         {
 514                 AmIBeingMWDebugged( &running ) ;
 515         }
 516 */
 517         if (running)
 518         {
 519         #ifdef __powerc
 520                 DebugStr(pstr);
 521         #else
 522                 SysBreakStr(pstr);
 523         #endif
 524         }
 525         else
 526 #endif
 527         {
 528         #ifdef __powerc
 529                 DebugStr(pstr);
 530         #else
 531                 DebugStr(pstr);
 532         #endif
 533         }
 534 #endif // MSW
 535 }
 536
 537 // ----------------------------------------------------------------------------
 538 // wxLogStream implementation
 539 // ----------------------------------------------------------------------------
 540
 541 #if wxUSE_STD_IOSTREAM
 542 wxLogStream::wxLogStream(ostream *ostr)
 543 {
 544     if ( ostr == NULL )
 545         m_ostr = &cerr;
 546     else
 547         m_ostr = ostr;
 548 }
 549
 550 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 551 {
 552     (*m_ostr) << wxConvertWX2MB(szString) << endl;
 553 }
 554 #endif // wxUSE_STD_IOSTREAM
 555
 556 // ============================================================================
 557 // Global functions/variables
 558 // ============================================================================
 559
 560 // ----------------------------------------------------------------------------
 561 // static variables
 562 // ----------------------------------------------------------------------------
 563
 564 wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 565 bool            wxLog::ms_doLog        = TRUE;
 566 bool            wxLog::ms_bAutoCreate  = TRUE;
 567
 568 size_t          wxLog::ms_suspendCount = 0;
 569
 570 #if wxUSE_GUI
 571     const wxChar *wxLog::ms_timestamp  = wxT("%X");  // time only, no date
 572 #else
 573     const wxChar *wxLog::ms_timestamp  = NULL;       // save space
 574 #endif
 575
 576 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 577 wxArrayString   wxLog::ms_aTraceMasks;
 578
 579 // ----------------------------------------------------------------------------
 580 // stdout error logging helper
 581 // ----------------------------------------------------------------------------
 582
 583 // helper function: wraps the message and justifies it under given position
 584 // (looks more pretty on the terminal). Also adds newline at the end.
 585 //
 586 // TODO this is now disabled until I find a portable way of determining the
 587 //      terminal window size (ok, I found it but does anybody really cares?)
 588 #ifdef LOG_PRETTY_WRAP
 589 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 590 {
 591     size_t nMax = 80; // FIXME
 592     size_t nStart = strlen(pszPrefix);
 593     fputs(pszPrefix, f);
 594
 595     size_t n;
 596     while ( *psz != '\0' ) {
 597         for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 598             putc(*psz++, f);
 599
 600         // wrapped?
 601         if ( *psz != '\0' ) {
 602             /*putc('\n', f);*/
 603             for ( n = 0; n < nStart; n++ )
 604                 putc(' ', f);
 605
 606             // as we wrapped, squeeze all white space
 607             while ( isspace(*psz) )
 608                 psz++;
 609         }
 610     }
 611
 612     putc('\n', f);
 613 }
 614 #endif  //LOG_PRETTY_WRAP
 615
 616 // ----------------------------------------------------------------------------
 617 // error code/error message retrieval functions
 618 // ----------------------------------------------------------------------------
 619
 620 // get error code from syste
 621 unsigned long wxSysErrorCode()
 622 {
 623 #ifdef  __WXMSW__
 624 #ifdef  __WIN32__
 625     return ::GetLastError();
 626 #else   //WIN16
 627     // TODO what to do on Windows 3.1?
 628     return 0;
 629 #endif  //WIN16/32
 630 #else   //Unix
 631     return errno;
 632 #endif  //Win/Unix
 633 }
 634
 635 // get error message from system
 636 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
 637 {
 638     if ( nErrCode == 0 )
 639         nErrCode = wxSysErrorCode();
 640
 641 #ifdef  __WXMSW__
 642 #ifdef  __WIN32__
 643     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 644
 645     // get error message from system
 646     LPVOID lpMsgBuf;
 647     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 648             NULL, nErrCode,
 649             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 650             (LPTSTR)&lpMsgBuf,
 651             0, NULL);
 652
 653     // copy it to our buffer and free memory
 654     wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 655     s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
 656     LocalFree(lpMsgBuf);
 657
 658     // returned string is capitalized and ended with '\r\n' - bad
 659     s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
 660     size_t len = wxStrlen(s_szBuf);
 661     if ( len > 0 ) {
 662         // truncate string
 663         if ( s_szBuf[len - 2] == wxT('\r') )
 664             s_szBuf[len - 2] = wxT('\0');
 665     }
 666
 667     return s_szBuf;
 668 #else   //Win16
 669     // TODO
 670     return NULL;
 671 #endif // Win16/32
 672 #else   // Unix
 673 #if wxUSE_UNICODE
 674     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 675     wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
 676     return s_szBuf;
 677 #else
 678     return strerror((int)nErrCode);
 679 #endif
 680 #endif  // Win/Unix
 681 }
 682
 683 // ----------------------------------------------------------------------------
 684 // debug helper
 685 // ----------------------------------------------------------------------------
 686
 687 #ifdef  __WXDEBUG__
 688
 689 // break into the debugger
 690 void Trap()
 691 {
 692 #ifdef __WXMSW__
 693     DebugBreak();
 694 #elif defined(__WXMAC__)
 695 #if __powerc
 696     Debugger();
 697 #else
 698     SysBreak();
 699 #endif
 700 #elif defined(__UNIX__)
 701     raise(SIGTRAP);
 702 #else
 703     // TODO
 704 #endif // Win/Unix
 705 }
 706
 707 // this function is called when an assert fails
 708 void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
 709 {
 710     // this variable can be set to true to suppress "assert failure" messages
 711     static bool s_bNoAsserts = FALSE;
 712     static bool s_bInAssert = FALSE;        // FIXME MT-unsafe
 713
 714     if ( s_bInAssert ) {
 715         // He-e-e-e-elp!! we're trapped in endless loop
 716         Trap();
 717
 718         s_bInAssert = FALSE;
 719
 720         return;
 721     }
 722
 723     s_bInAssert = TRUE;
 724
 725     wxChar szBuf[LOG_BUFFER_SIZE];
 726
 727     // make life easier for people using VC++ IDE: clicking on the message
 728     // will take us immediately to the place of the failed assert
 729     wxSnprintf(szBuf, WXSIZEOF(szBuf),
 730 #ifdef __VISUALC__
 731                wxT("%s(%d): assert failed"),
 732 #else  // !VC++
 733     // make the error message more clear for all the others
 734                wxT("Assert failed in file %s at line %d"),
 735 #endif // VC/!VC
 736                szFile, nLine);
 737
 738     if ( szMsg != NULL ) {
 739         wxStrcat(szBuf, wxT(": "));
 740         wxStrcat(szBuf, szMsg);
 741     }
 742     else {
 743         wxStrcat(szBuf, wxT("."));
 744     }
 745
 746     if ( !s_bNoAsserts ) {
 747         // send it to the normal log destination
 748         wxLogDebug(szBuf);
 749
 750 #if wxUSE_GUI || defined(__WXMSW__)
 751         // this message is intentionally not translated - it is for
 752         // developpers only
 753         wxStrcat(szBuf, wxT("\nDo you want to stop the program?\nYou can also choose [Cancel] to suppress further warnings."));
 754
 755         // use the native message box if available: this is more robust than
 756         // using our own
 757 #ifdef __WXMSW__
 758         switch ( ::MessageBox(NULL, szBuf, _T("Debug"),
 759                               MB_YESNOCANCEL | MB_ICONSTOP ) ) {
 760             case IDYES:
 761                 Trap();
 762                 break;
 763
 764             case IDCANCEL:
 765                 s_bNoAsserts = TRUE;
 766                 break;
 767
 768             //case IDNO: nothing to do
 769         }
 770 #else // !MSW
 771         switch ( wxMessageBox(szBuf, wxT("Debug"),
 772                               wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
 773             case wxYES:
 774                 Trap();
 775                 break;
 776
 777             case wxCANCEL:
 778                 s_bNoAsserts = TRUE;
 779                 break;
 780
 781             //case wxNO: nothing to do
 782         }
 783 #endif // GUI or MSW
 784
 785 #else // !GUI
 786         Trap();
 787 #endif // GUI/!GUI
 788     }
 789
 790     s_bInAssert = FALSE;
 791 }
 792
 793 #endif  //WXDEBUG
 794
 795 #endif //wxUSE_LOG