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     wxVsprintf(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       wxVsprintf(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     wxVsprintf(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       wxVsprintf(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       wxVsprintf(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       wxVsprintf(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     wxSprintf(szErrMsg, _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 202     wxStrncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - wxStrlen(s_szBuf));
 203
 204     wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
 205 }
 206
 207 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
 208 {
 209     va_list argptr;
 210     va_start(argptr, szFormat);
 211     wxVsprintf(s_szBuf, szFormat, argptr);
 212     va_end(argptr);
 213
 214     wxLogSysErrorHelper(wxSysErrorCode());
 215 }
 216
 217 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
 218 {
 219     va_list argptr;
 220     va_start(argptr, szFormat);
 221     wxVsprintf(s_szBuf, szFormat, argptr);
 222     va_end(argptr);
 223
 224     wxLogSysErrorHelper(lErrCode);
 225 }
 226
 227 // ----------------------------------------------------------------------------
 228 // wxLog class implementation
 229 // ----------------------------------------------------------------------------
 230
 231 wxLog::wxLog()
 232 {
 233     m_bHasMessages = FALSE;
 234
 235     // enable verbose messages by default in the debug builds
 236 #ifdef __WXDEBUG__
 237     m_bVerbose = TRUE;
 238 #else // release
 239     m_bVerbose = FALSE;
 240 #endif // debug/release
 241 }
 242
 243 wxLog *wxLog::GetActiveTarget()
 244 {
 245     if ( ms_bAutoCreate && ms_pLogger == NULL ) {
 246         // prevent infinite recursion if someone calls wxLogXXX() from
 247         // wxApp::CreateLogTarget()
 248         static bool s_bInGetActiveTarget = FALSE;
 249         if ( !s_bInGetActiveTarget ) {
 250             s_bInGetActiveTarget = TRUE;
 251
 252             // ask the application to create a log target for us
 253             if ( wxTheApp != NULL )
 254                 ms_pLogger = wxTheApp->CreateLogTarget();
 255             else
 256                 ms_pLogger = new wxLogStderr;
 257
 258             s_bInGetActiveTarget = FALSE;
 259
 260             // do nothing if it fails - what can we do?
 261         }
 262     }
 263
 264     return ms_pLogger;
 265 }
 266
 267 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 268 {
 269     if ( ms_pLogger != NULL ) {
 270         // flush the old messages before changing because otherwise they might
 271         // get lost later if this target is not restored
 272         ms_pLogger->Flush();
 273     }
 274
 275     wxLog *pOldLogger = ms_pLogger;
 276     ms_pLogger = pLogger;
 277
 278     return pOldLogger;
 279 }
 280
 281 void wxLog::RemoveTraceMask(const wxString& str)
 282 {
 283     int index = ms_aTraceMasks.Index(str);
 284     if ( index != wxNOT_FOUND )
 285         ms_aTraceMasks.Remove((size_t)index);
 286 }
 287
 288 void wxLog::TimeStamp(wxString *str)
 289 {
 290     if ( ms_timestamp )
 291     {
 292         wxChar buf[256];
 293         time_t timeNow;
 294         (void)time(&timeNow);
 295         wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
 296
 297         str->Empty();
 298         *str << buf << wxT(": ");
 299     }
 300 }
 301
 302 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 303 {
 304     switch ( level ) {
 305         case wxLOG_FatalError:
 306             DoLogString(wxString(_("Fatal error: ")) + szString, t);
 307             DoLogString(_("Program aborted."), t);
 308             Flush();
 309             abort();
 310             break;
 311
 312         case wxLOG_Error:
 313             DoLogString(wxString(_("Error: ")) + szString, t);
 314             break;
 315
 316         case wxLOG_Warning:
 317             DoLogString(wxString(_("Warning: ")) + szString, t);
 318             break;
 319
 320         case wxLOG_Info:
 321             if ( GetVerbose() )
 322         case wxLOG_Message:
 323         case wxLOG_Status:
 324         default:    // log unknown log levels too
 325                 DoLogString(szString, t);
 326             break;
 327
 328         case wxLOG_Trace:
 329         case wxLOG_Debug:
 330 #ifdef __WXDEBUG__
 331             DoLogString(szString, t);
 332 #endif
 333             break;
 334     }
 335 }
 336
 337 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
 338 {
 339     wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
 340 }
 341
 342 void wxLog::Flush()
 343 {
 344     // do nothing
 345 }
 346
 347 // ----------------------------------------------------------------------------
 348 // wxLogStderr class implementation
 349 // ----------------------------------------------------------------------------
 350
 351 wxLogStderr::wxLogStderr(FILE *fp)
 352 {
 353     if ( fp == NULL )
 354         m_fp = stderr;
 355     else
 356         m_fp = fp;
 357 }
 358
 359 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 360 {
 361     wxString str;
 362     TimeStamp(&str);
 363     str << szString << wxT('\n');
 364
 365     fputs(str.mb_str(), m_fp);
 366     fflush(m_fp);
 367
 368     // under Windows, programs usually don't have stderr at all, so make show the
 369     // messages also under debugger
 370 #ifdef __WXMSW__
 371     OutputDebugString(str + wxT('\r'));
 372 #endif // MSW
 373 }
 374
 375 // ----------------------------------------------------------------------------
 376 // wxLogStream implementation
 377 // ----------------------------------------------------------------------------
 378
 379 #if wxUSE_STD_IOSTREAM
 380 wxLogStream::wxLogStream(ostream *ostr)
 381 {
 382     if ( ostr == NULL )
 383         m_ostr = &cerr;
 384     else
 385         m_ostr = ostr;
 386 }
 387
 388 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 389 {
 390     (*m_ostr) << wxConvertWX2MB(szString) << endl;
 391 }
 392 #endif // wxUSE_STD_IOSTREAM
 393
 394 // ============================================================================
 395 // Global functions/variables
 396 // ============================================================================
 397
 398 // ----------------------------------------------------------------------------
 399 // static variables
 400 // ----------------------------------------------------------------------------
 401
 402 wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 403 bool            wxLog::ms_doLog        = TRUE;
 404 bool            wxLog::ms_bAutoCreate  = TRUE;
 405
 406 const wxChar   *wxLog::ms_timestamp    = wxT("%X");  // time only, no date
 407
 408 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 409 wxArrayString   wxLog::ms_aTraceMasks;
 410
 411 // ----------------------------------------------------------------------------
 412 // stdout error logging helper
 413 // ----------------------------------------------------------------------------
 414
 415 // helper function: wraps the message and justifies it under given position
 416 // (looks more pretty on the terminal). Also adds newline at the end.
 417 //
 418 // TODO this is now disabled until I find a portable way of determining the
 419 //      terminal window size (ok, I found it but does anybody really cares?)
 420 #ifdef LOG_PRETTY_WRAP
 421 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 422 {
 423     size_t nMax = 80; // FIXME
 424     size_t nStart = strlen(pszPrefix);
 425     fputs(pszPrefix, f);
 426
 427     size_t n;
 428     while ( *psz != '\0' ) {
 429         for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 430             putc(*psz++, f);
 431
 432         // wrapped?
 433         if ( *psz != '\0' ) {
 434             /*putc('\n', f);*/
 435             for ( n = 0; n < nStart; n++ )
 436                 putc(' ', f);
 437
 438             // as we wrapped, squeeze all white space
 439             while ( isspace(*psz) )
 440                 psz++;
 441         }
 442     }
 443
 444     putc('\n', f);
 445 }
 446 #endif  //LOG_PRETTY_WRAP
 447
 448 // ----------------------------------------------------------------------------
 449 // error code/error message retrieval functions
 450 // ----------------------------------------------------------------------------
 451
 452 // get error code from syste
 453 unsigned long wxSysErrorCode()
 454 {
 455 #ifdef  __WXMSW__
 456 #ifdef  __WIN32__
 457     return ::GetLastError();
 458 #else   //WIN16
 459     // TODO what to do on Windows 3.1?
 460     return 0;
 461 #endif  //WIN16/32
 462 #else   //Unix
 463     return errno;
 464 #endif  //Win/Unix
 465 }
 466
 467 // get error message from system
 468 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
 469 {
 470     if ( nErrCode == 0 )
 471         nErrCode = wxSysErrorCode();
 472
 473 #ifdef  __WXMSW__
 474 #ifdef  __WIN32__
 475     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 476
 477     // get error message from system
 478     LPVOID lpMsgBuf;
 479     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 480             NULL, nErrCode,
 481             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 482             (LPTSTR)&lpMsgBuf,
 483             0, NULL);
 484
 485     // copy it to our buffer and free memory
 486     wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 487     s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
 488     LocalFree(lpMsgBuf);
 489
 490     // returned string is capitalized and ended with '\r\n' - bad
 491     s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
 492     size_t len = wxStrlen(s_szBuf);
 493     if ( len > 0 ) {
 494         // truncate string
 495         if ( s_szBuf[len - 2] == wxT('\r') )
 496             s_szBuf[len - 2] = wxT('\0');
 497     }
 498
 499     return s_szBuf;
 500 #else   //Win16
 501     // TODO
 502     return NULL;
 503 #endif // Win16/32
 504 #else   // Unix
 505 #if wxUSE_UNICODE
 506     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 507     wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
 508     return s_szBuf;
 509 #else
 510     return strerror(nErrCode);
 511 #endif
 512 #endif  // Win/Unix
 513 }
 514
 515 // ----------------------------------------------------------------------------
 516 // debug helper
 517 // ----------------------------------------------------------------------------
 518
 519 #ifdef  __WXDEBUG__
 520
 521 // break into the debugger
 522 void Trap()
 523 {
 524 #ifdef __WXMSW__
 525     DebugBreak();
 526 #elif defined(__WXMAC__)
 527 #if __powerc
 528     Debugger();
 529 #else
 530     SysBreak();
 531 #endif
 532 #elif defined(__UNIX__)
 533     raise(SIGTRAP);
 534 #else
 535     // TODO
 536 #endif // Win/Unix
 537 }
 538
 539 // this function is called when an assert fails
 540 void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
 541 {
 542     // this variable can be set to true to suppress "assert failure" messages
 543     static bool s_bNoAsserts = FALSE;
 544     static bool s_bInAssert = FALSE;        // FIXME MT-unsafe
 545
 546     if ( s_bInAssert ) {
 547         // He-e-e-e-elp!! we're trapped in endless loop
 548         Trap();
 549
 550         s_bInAssert = FALSE;
 551
 552         return;
 553     }
 554
 555     s_bInAssert = TRUE;
 556
 557     wxChar szBuf[LOG_BUFFER_SIZE];
 558
 559     // make life easier for people using VC++ IDE: clicking on the message
 560     // will take us immediately to the place of the failed assert
 561 #ifdef __VISUALC__
 562     wxSprintf(szBuf, wxT("%s(%d): assert failed"), szFile, nLine);
 563 #else  // !VC++
 564     // make the error message more clear for all the others
 565     wxSprintf(szBuf, wxT("Assert failed in file %s at line %d"), szFile, nLine);
 566 #endif // VC/!VC
 567
 568     if ( szMsg != NULL ) {
 569         wxStrcat(szBuf, wxT(": "));
 570         wxStrcat(szBuf, szMsg);
 571     }
 572     else {
 573         wxStrcat(szBuf, wxT("."));
 574     }
 575
 576     if ( !s_bNoAsserts ) {
 577         // send it to the normal log destination
 578         wxLogDebug(szBuf);
 579
 580 #if wxUSE_GUI
 581         // this message is intentionally not translated - it is for
 582         // developpers only
 583         wxStrcat(szBuf, wxT("\nDo you want to stop the program?"
 584                 "\nYou can also choose [Cancel] to suppress "
 585                 "further warnings."));
 586
 587         switch ( wxMessageBox(szBuf, _("Debug"),
 588                     wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
 589             case wxYES:
 590                 Trap();
 591                 break;
 592
 593             case wxCANCEL:
 594                 s_bNoAsserts = TRUE;
 595                 break;
 596
 597                 //case wxNO: nothing to do
 598         }
 599 #else // !GUI
 600         Trap();
 601 #endif // GUI/!GUI
 602     }
 603
 604     s_bInAssert = FALSE;
 605 }
 606
 607 #endif  //WXDEBUG
 608