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