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 // other standard headers
  54 #include  <errno.h>
  55 #include  <stdlib.h>
  56 #include  <time.h>
  57
  58 #ifdef  __WXMSW__
  59   #include  "wx/msw/private.h"      // includes windows.h for OutputDebugString
  60 #else   //Unix
  61   #include  <signal.h>
  62 #endif  //Win/Unix
  63
  64 // ----------------------------------------------------------------------------
  65 // non member functions
  66 // ----------------------------------------------------------------------------
  67
  68 // define this to enable wrapping of log messages
  69 //#define LOG_PRETTY_WRAP
  70
  71 #ifdef  LOG_PRETTY_WRAP
  72   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  73 #endif
  74
  75 // ============================================================================
  76 // implementation
  77 // ============================================================================
  78
  79 // ----------------------------------------------------------------------------
  80 // globals
  81 // ----------------------------------------------------------------------------
  82
  83 // log functions can't allocate memory (LogError("out of memory...") should
  84 // work!), so we use a static buffer for all log messages
  85 #define LOG_BUFFER_SIZE   (4096)
  86
  87 // static buffer for error messages
  88 static wxChar s_szBuf[LOG_BUFFER_SIZE];
  89
  90 #if wxUSE_THREADS
  91
  92 // the critical section protecting the static buffer
  93 static wxCriticalSection gs_csLogBuf;
  94
  95 #endif // wxUSE_THREADS
  96
  97 // ----------------------------------------------------------------------------
  98 // implementation of Log functions
  99 //
 100 // NB: unfortunately we need all these distinct functions, we can't make them
 101 //     macros and not all compilers inline vararg functions.
 102 // ----------------------------------------------------------------------------
 103
 104 // generic log function
 105 void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
 106 {
 107   if ( wxLog::GetActiveTarget() != NULL ) {
 108     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 109
 110     va_list argptr;
 111     va_start(argptr, szFormat);
 112     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 113     va_end(argptr);
 114
 115     wxLog::OnLog(level, s_szBuf, time(NULL));
 116   }
 117 }
 118
 119 #define IMPLEMENT_LOG_FUNCTION(level)                             \
 120   void wxLog##level(const wxChar *szFormat, ...)                  \
 121   {                                                               \
 122     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 123       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                    \
 124                                                                   \
 125       va_list argptr;                                             \
 126       va_start(argptr, szFormat);                                 \
 127       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);  \
 128       va_end(argptr);                                             \
 129                                                                   \
 130       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));           \
 131     }                                                             \
 132   }
 133
 134 IMPLEMENT_LOG_FUNCTION(FatalError)
 135 IMPLEMENT_LOG_FUNCTION(Error)
 136 IMPLEMENT_LOG_FUNCTION(Warning)
 137 IMPLEMENT_LOG_FUNCTION(Message)
 138 IMPLEMENT_LOG_FUNCTION(Info)
 139 IMPLEMENT_LOG_FUNCTION(Status)
 140
 141 // same as info, but only if 'verbose' mode is on
 142 void wxLogVerbose(const wxChar *szFormat, ...)
 143 {
 144   wxLog *pLog = wxLog::GetActiveTarget();
 145   if ( pLog != NULL && pLog->GetVerbose() ) {
 146     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 147
 148     va_list argptr;
 149     va_start(argptr, szFormat);
 150     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 151     va_end(argptr);
 152
 153     wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
 154   }
 155 }
 156
 157 // debug functions
 158 #ifdef __WXDEBUG__
 159 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                       \
 160   void wxLog##level(const wxChar *szFormat, ...)                  \
 161   {                                                               \
 162     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 163       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                    \
 164                                                                   \
 165       va_list argptr;                                             \
 166       va_start(argptr, szFormat);                                 \
 167       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);  \
 168       va_end(argptr);                                             \
 169                                                                   \
 170       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));           \
 171     }                                                             \
 172   }
 173
 174   void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
 175   {
 176     wxLog *pLog = wxLog::GetActiveTarget();
 177
 178     if ( pLog != NULL && wxLog::IsAllowedTraceMask(mask) ) {
 179       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 180
 181       va_list argptr;
 182       va_start(argptr, szFormat);
 183       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 184       va_end(argptr);
 185
 186       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 187     }
 188   }
 189
 190   void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
 191   {
 192     wxLog *pLog = wxLog::GetActiveTarget();
 193
 194     // we check that all of mask bits are set in the current mask, so
 195     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 196     // if both bits are set.
 197     if ( pLog != NULL && ((pLog->GetTraceMask() & mask) == mask) ) {
 198       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 199
 200       va_list argptr;
 201       va_start(argptr, szFormat);
 202       wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 203       va_end(argptr);
 204
 205       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 206     }
 207   }
 208
 209 #else // release
 210   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 211 #endif
 212
 213 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 214 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 215
 216 // wxLogSysError: one uses the last error code, for other  you must give it
 217 // explicitly
 218
 219 // common part of both wxLogSysError
 220 void wxLogSysErrorHelper(long lErrCode)
 221 {
 222     wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
 223     wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
 224                _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 225     wxStrncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - wxStrlen(s_szBuf));
 226
 227     wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
 228 }
 229
 230 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
 231 {
 232     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 233
 234     va_list argptr;
 235     va_start(argptr, szFormat);
 236     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 237     va_end(argptr);
 238
 239     wxLogSysErrorHelper(wxSysErrorCode());
 240 }
 241
 242 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
 243 {
 244     wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 245
 246     va_list argptr;
 247     va_start(argptr, szFormat);
 248     wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
 249     va_end(argptr);
 250
 251     wxLogSysErrorHelper(lErrCode);
 252 }
 253
 254 // ----------------------------------------------------------------------------
 255 // wxLog class implementation
 256 // ----------------------------------------------------------------------------
 257
 258 wxLog::wxLog()
 259 {
 260     m_bHasMessages = FALSE;
 261
 262     // enable verbose messages by default in the debug builds
 263 #ifdef __WXDEBUG__
 264     m_bVerbose = TRUE;
 265 #else // release
 266     m_bVerbose = FALSE;
 267 #endif // debug/release
 268 }
 269
 270 wxLog *wxLog::GetActiveTarget()
 271 {
 272     if ( ms_bAutoCreate && ms_pLogger == NULL ) {
 273         // prevent infinite recursion if someone calls wxLogXXX() from
 274         // wxApp::CreateLogTarget()
 275         static bool s_bInGetActiveTarget = FALSE;
 276         if ( !s_bInGetActiveTarget ) {
 277             s_bInGetActiveTarget = TRUE;
 278
 279             // ask the application to create a log target for us
 280             if ( wxTheApp != NULL )
 281                 ms_pLogger = wxTheApp->CreateLogTarget();
 282             else
 283                 ms_pLogger = new wxLogStderr;
 284
 285             s_bInGetActiveTarget = FALSE;
 286
 287             // do nothing if it fails - what can we do?
 288         }
 289     }
 290
 291     return ms_pLogger;
 292 }
 293
 294 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 295 {
 296     if ( ms_pLogger != NULL ) {
 297         // flush the old messages before changing because otherwise they might
 298         // get lost later if this target is not restored
 299         ms_pLogger->Flush();
 300     }
 301
 302     wxLog *pOldLogger = ms_pLogger;
 303     ms_pLogger = pLogger;
 304
 305     return pOldLogger;
 306 }
 307
 308 void wxLog::RemoveTraceMask(const wxString& str)
 309 {
 310     int index = ms_aTraceMasks.Index(str);
 311     if ( index != wxNOT_FOUND )
 312         ms_aTraceMasks.Remove((size_t)index);
 313 }
 314
 315 void wxLog::TimeStamp(wxString *str)
 316 {
 317     if ( ms_timestamp )
 318     {
 319         wxChar buf[256];
 320         time_t timeNow;
 321         (void)time(&timeNow);
 322         wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
 323
 324         str->Empty();
 325         *str << buf << wxT(": ");
 326     }
 327 }
 328
 329 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 330 {
 331     switch ( level ) {
 332         case wxLOG_FatalError:
 333             DoLogString(wxString(_("Fatal error: ")) + szString, t);
 334             DoLogString(_("Program aborted."), t);
 335             Flush();
 336             abort();
 337             break;
 338
 339         case wxLOG_Error:
 340             DoLogString(wxString(_("Error: ")) + szString, t);
 341             break;
 342
 343         case wxLOG_Warning:
 344             DoLogString(wxString(_("Warning: ")) + szString, t);
 345             break;
 346
 347         case wxLOG_Info:
 348             if ( GetVerbose() )
 349         case wxLOG_Message:
 350         case wxLOG_Status:
 351         default:    // log unknown log levels too
 352                 DoLogString(szString, t);
 353             break;
 354
 355         case wxLOG_Trace:
 356         case wxLOG_Debug:
 357 #ifdef __WXDEBUG__
 358             DoLogString(szString, t);
 359 #endif
 360             break;
 361     }
 362 }
 363
 364 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
 365 {
 366     wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
 367 }
 368
 369 void wxLog::Flush()
 370 {
 371     // do nothing
 372 }
 373
 374 // ----------------------------------------------------------------------------
 375 // wxLogStderr class implementation
 376 // ----------------------------------------------------------------------------
 377
 378 wxLogStderr::wxLogStderr(FILE *fp)
 379 {
 380     if ( fp == NULL )
 381         m_fp = stderr;
 382     else
 383         m_fp = fp;
 384 }
 385
 386 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 387 {
 388     wxString str;
 389     TimeStamp(&str);
 390     str << szString;
 391
 392     fputs(str.mb_str(), m_fp);
 393     fputc(_T('\n'), m_fp);
 394     fflush(m_fp);
 395
 396     // under Windows, programs usually don't have stderr at all, so show the
 397     // messages also under debugger - unless it's a console program
 398 #if defined(__WXMSW__) && wxUSE_GUI
 399     OutputDebugString(str + wxT("\r\n"));
 400 #endif // MSW
 401 #if defined(__WXMAC__) && wxUSE_GUI
 402     debugstr(str + wxT("\r\n"));
 403 #endif // MSW
 404 }
 405
 406 // ----------------------------------------------------------------------------
 407 // wxLogStream implementation
 408 // ----------------------------------------------------------------------------
 409
 410 #if wxUSE_STD_IOSTREAM
 411 wxLogStream::wxLogStream(ostream *ostr)
 412 {
 413     if ( ostr == NULL )
 414         m_ostr = &cerr;
 415     else
 416         m_ostr = ostr;
 417 }
 418
 419 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 420 {
 421     (*m_ostr) << wxConvertWX2MB(szString) << endl;
 422 }
 423 #endif // wxUSE_STD_IOSTREAM
 424
 425 // ============================================================================
 426 // Global functions/variables
 427 // ============================================================================
 428
 429 // ----------------------------------------------------------------------------
 430 // static variables
 431 // ----------------------------------------------------------------------------
 432
 433 wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 434 bool            wxLog::ms_doLog        = TRUE;
 435 bool            wxLog::ms_bAutoCreate  = TRUE;
 436
 437 #if wxUSE_GUI
 438     const wxChar *wxLog::ms_timestamp  = wxT("%X");  // time only, no date
 439 #else
 440     const wxChar *wxLog::ms_timestamp  = NULL;       // save space
 441 #endif
 442
 443 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 444 wxArrayString   wxLog::ms_aTraceMasks;
 445
 446 // ----------------------------------------------------------------------------
 447 // stdout error logging helper
 448 // ----------------------------------------------------------------------------
 449
 450 // helper function: wraps the message and justifies it under given position
 451 // (looks more pretty on the terminal). Also adds newline at the end.
 452 //
 453 // TODO this is now disabled until I find a portable way of determining the
 454 //      terminal window size (ok, I found it but does anybody really cares?)
 455 #ifdef LOG_PRETTY_WRAP
 456 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 457 {
 458     size_t nMax = 80; // FIXME
 459     size_t nStart = strlen(pszPrefix);
 460     fputs(pszPrefix, f);
 461
 462     size_t n;
 463     while ( *psz != '\0' ) {
 464         for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 465             putc(*psz++, f);
 466
 467         // wrapped?
 468         if ( *psz != '\0' ) {
 469             /*putc('\n', f);*/
 470             for ( n = 0; n < nStart; n++ )
 471                 putc(' ', f);
 472
 473             // as we wrapped, squeeze all white space
 474             while ( isspace(*psz) )
 475                 psz++;
 476         }
 477     }
 478
 479     putc('\n', f);
 480 }
 481 #endif  //LOG_PRETTY_WRAP
 482
 483 // ----------------------------------------------------------------------------
 484 // error code/error message retrieval functions
 485 // ----------------------------------------------------------------------------
 486
 487 // get error code from syste
 488 unsigned long wxSysErrorCode()
 489 {
 490 #ifdef  __WXMSW__
 491 #ifdef  __WIN32__
 492     return ::GetLastError();
 493 #else   //WIN16
 494     // TODO what to do on Windows 3.1?
 495     return 0;
 496 #endif  //WIN16/32
 497 #else   //Unix
 498     return errno;
 499 #endif  //Win/Unix
 500 }
 501
 502 // get error message from system
 503 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
 504 {
 505     if ( nErrCode == 0 )
 506         nErrCode = wxSysErrorCode();
 507
 508 #ifdef  __WXMSW__
 509 #ifdef  __WIN32__
 510     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 511
 512     // get error message from system
 513     LPVOID lpMsgBuf;
 514     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 515             NULL, nErrCode,
 516             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 517             (LPTSTR)&lpMsgBuf,
 518             0, NULL);
 519
 520     // copy it to our buffer and free memory
 521     wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 522     s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
 523     LocalFree(lpMsgBuf);
 524
 525     // returned string is capitalized and ended with '\r\n' - bad
 526     s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
 527     size_t len = wxStrlen(s_szBuf);
 528     if ( len > 0 ) {
 529         // truncate string
 530         if ( s_szBuf[len - 2] == wxT('\r') )
 531             s_szBuf[len - 2] = wxT('\0');
 532     }
 533
 534     return s_szBuf;
 535 #else   //Win16
 536     // TODO
 537     return NULL;
 538 #endif // Win16/32
 539 #else   // Unix
 540 #if wxUSE_UNICODE
 541     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 542     wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
 543     return s_szBuf;
 544 #else
 545     return strerror((int)nErrCode);
 546 #endif
 547 #endif  // Win/Unix
 548 }
 549
 550 // ----------------------------------------------------------------------------
 551 // debug helper
 552 // ----------------------------------------------------------------------------
 553
 554 #ifdef  __WXDEBUG__
 555
 556 // break into the debugger
 557 void Trap()
 558 {
 559 #ifdef __WXMSW__
 560     DebugBreak();
 561 #elif defined(__WXMAC__)
 562 #if __powerc
 563     Debugger();
 564 #else
 565     SysBreak();
 566 #endif
 567 #elif defined(__UNIX__)
 568     raise(SIGTRAP);
 569 #else
 570     // TODO
 571 #endif // Win/Unix
 572 }
 573
 574 // this function is called when an assert fails
 575 void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
 576 {
 577     // this variable can be set to true to suppress "assert failure" messages
 578     static bool s_bNoAsserts = FALSE;
 579     static bool s_bInAssert = FALSE;        // FIXME MT-unsafe
 580
 581     if ( s_bInAssert ) {
 582         // He-e-e-e-elp!! we're trapped in endless loop
 583         Trap();
 584
 585         s_bInAssert = FALSE;
 586
 587         return;
 588     }
 589
 590     s_bInAssert = TRUE;
 591
 592     wxChar szBuf[LOG_BUFFER_SIZE];
 593
 594     // make life easier for people using VC++ IDE: clicking on the message
 595     // will take us immediately to the place of the failed assert
 596     wxSnprintf(szBuf, WXSIZEOF(szBuf),
 597 #ifdef __VISUALC__
 598                wxT("%s(%d): assert failed"),
 599 #else  // !VC++
 600     // make the error message more clear for all the others
 601                wxT("Assert failed in file %s at line %d"),
 602 #endif // VC/!VC
 603                szFile, nLine);
 604
 605     if ( szMsg != NULL ) {
 606         wxStrcat(szBuf, wxT(": "));
 607         wxStrcat(szBuf, szMsg);
 608     }
 609     else {
 610         wxStrcat(szBuf, wxT("."));
 611     }
 612
 613     if ( !s_bNoAsserts ) {
 614         // send it to the normal log destination
 615         wxLogDebug(szBuf);
 616
 617 #if wxUSE_GUI || defined(__WXMSW__)
 618         // this message is intentionally not translated - it is for
 619         // developpers only
 620         wxStrcat(szBuf, wxT("\nDo you want to stop the program?"
 621                             "\nYou can also choose [Cancel] to suppress "
 622                             "further warnings."));
 623
 624 #if wxUSE_GUI
 625         switch ( wxMessageBox(szBuf, "Debug",
 626                               wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
 627             case wxYES:
 628                 Trap();
 629                 break;
 630
 631             case wxCANCEL:
 632                 s_bNoAsserts = TRUE;
 633                 break;
 634
 635             //case wxNO: nothing to do
 636         }
 637 #else // !GUI, but MSW
 638         switch ( ::MessageBox(NULL, szBuf, "Debug",
 639                               MB_YESNOCANCEL | MB_ICONSTOP ) ) {
 640             case IDYES:
 641                 Trap();
 642                 break;
 643
 644             case IDCANCEL:
 645                 s_bNoAsserts = TRUE;
 646                 break;
 647
 648             //case IDNO: nothing to do
 649         }
 650 #endif // GUI or MSW
 651
 652 #else // !GUI
 653         Trap();
 654 #endif // GUI/!GUI
 655     }
 656
 657     s_bInAssert = FALSE;
 658 }
 659
 660 #endif  //WXDEBUG
 661