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