src/common/log.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/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 licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_LOG
  28
  29 // wxWidgets
  30 #ifndef WX_PRECOMP
  31     #include "wx/log.h"
  32     #include "wx/app.h"
  33     #include "wx/arrstr.h"
  34     #include "wx/intl.h"
  35     #include "wx/string.h"
  36     #include "wx/utils.h"
  37 #endif //WX_PRECOMP
  38
  39 #include "wx/apptrait.h"
  40 #include "wx/file.h"
  41 #include "wx/msgout.h"
  42 #include "wx/textfile.h"
  43 #include "wx/thread.h"
  44 #include "wx/wxchar.h"
  45
  46 // other standard headers
  47 #ifndef __WXWINCE__
  48 #include <errno.h>
  49 #endif
  50
  51 #include <stdlib.h>
  52
  53 #ifndef __WXWINCE__
  54 #include <time.h>
  55 #else
  56 #include "wx/msw/wince/time.h"
  57 #endif
  58
  59 #if defined(__WINDOWS__)
  60     #include "wx/msw/private.h" // includes windows.h
  61 #endif
  62
  63 // ----------------------------------------------------------------------------
  64 // non member functions
  65 // ----------------------------------------------------------------------------
  66
  67 // define this to enable wrapping of log messages
  68 //#define LOG_PRETTY_WRAP
  69
  70 #ifdef  LOG_PRETTY_WRAP
  71   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  72 #endif
  73
  74 // ============================================================================
  75 // implementation
  76 // ============================================================================
  77
  78 // ----------------------------------------------------------------------------
  79 // globals
  80 // ----------------------------------------------------------------------------
  81
  82 // log functions can't allocate memory (LogError("out of memory...") should
  83 // work!), so we use a static buffer for all log messages
  84 #define LOG_BUFFER_SIZE   (4096)
  85
  86 // static buffer for error messages
  87 static wxChar   s_szBufStatic[LOG_BUFFER_SIZE];
  88
  89 static wxChar  *s_szBuf     = s_szBufStatic;
  90 static size_t   s_szBufSize = WXSIZEOF( s_szBufStatic );
  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 // wrapper for wxVsnprintf(s_szBuf) which always NULL-terminates it
 107 static inline void PrintfInLogBuf(const wxChar *szFormat, va_list argptr)
 108 {
 109     if ( wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr) < 0 )
 110     {
 111         // must NUL-terminate it manually
 112         s_szBuf[s_szBufSize - 1] = _T('\0');
 113     }
 114     //else: NUL-terminated by vsnprintf()
 115 }
 116
 117 // generic log function
 118 void wxVLogGeneric(wxLogLevel level, const wxChar *szFormat, va_list argptr)
 119 {
 120     if ( wxLog::IsEnabled() ) {
 121         wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 122
 123         PrintfInLogBuf(szFormat, argptr);
 124
 125         wxLog::OnLog(level, s_szBuf, time(NULL));
 126     }
 127 }
 128
 129 void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
 130 {
 131     va_list argptr;
 132     va_start(argptr, szFormat);
 133     wxVLogGeneric(level, szFormat, argptr);
 134     va_end(argptr);
 135 }
 136
 137 #define IMPLEMENT_LOG_FUNCTION(level)                               \
 138   void wxVLog##level(const wxChar *szFormat, va_list argptr)        \
 139   {                                                                 \
 140     if ( wxLog::IsEnabled() ) {                                     \
 141       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                      \
 142                                                                     \
 143       PrintfInLogBuf(szFormat, argptr);                             \
 144                                                                     \
 145       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));             \
 146     }                                                               \
 147   }                                                                 \
 148                                                                     \
 149   void wxLog##level(const wxChar *szFormat, ...)                    \
 150   {                                                                 \
 151     va_list argptr;                                                 \
 152     va_start(argptr, szFormat);                                     \
 153     wxVLog##level(szFormat, argptr);                                \
 154     va_end(argptr);                                                 \
 155   }
 156
 157 IMPLEMENT_LOG_FUNCTION(Error)
 158 IMPLEMENT_LOG_FUNCTION(Warning)
 159 IMPLEMENT_LOG_FUNCTION(Message)
 160 IMPLEMENT_LOG_FUNCTION(Info)
 161 IMPLEMENT_LOG_FUNCTION(Status)
 162
 163 void wxSafeShowMessage(const wxString& title, const wxString& text)
 164 {
 165 #ifdef __WINDOWS__
 166     ::MessageBox(NULL, text, title, MB_OK | MB_ICONSTOP);
 167 #else
 168     wxFprintf(stderr, _T("%s: %s\n"), title.c_str(), text.c_str());
 169     fflush(stderr);
 170 #endif
 171 }
 172
 173 // fatal errors can't be suppressed nor handled by the custom log target and
 174 // always terminate the program
 175 void wxVLogFatalError(const wxChar *szFormat, va_list argptr)
 176 {
 177     wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 178
 179     wxSafeShowMessage(_T("Fatal Error"), s_szBuf);
 180
 181 #ifdef __WXWINCE__
 182     ExitThread(3);
 183 #else
 184     abort();
 185 #endif
 186 }
 187
 188 void wxLogFatalError(const wxChar *szFormat, ...)
 189 {
 190     va_list argptr;
 191     va_start(argptr, szFormat);
 192     wxVLogFatalError(szFormat, argptr);
 193
 194     // some compilers warn about unreachable code and it shouldn't matter
 195     // for the others anyhow...
 196     //va_end(argptr);
 197 }
 198
 199 // same as info, but only if 'verbose' mode is on
 200 void wxVLogVerbose(const wxChar *szFormat, va_list argptr)
 201 {
 202     if ( wxLog::IsEnabled() ) {
 203         if ( wxLog::GetActiveTarget() != NULL && wxLog::GetVerbose() ) {
 204             wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 205
 206             wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 207
 208             wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
 209         }
 210     }
 211 }
 212
 213 void wxLogVerbose(const wxChar *szFormat, ...)
 214 {
 215     va_list argptr;
 216     va_start(argptr, szFormat);
 217     wxVLogVerbose(szFormat, argptr);
 218     va_end(argptr);
 219 }
 220
 221 // debug functions
 222 #ifdef __WXDEBUG__
 223 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                         \
 224   void wxVLog##level(const wxChar *szFormat, va_list argptr)        \
 225   {                                                                 \
 226     if ( wxLog::IsEnabled() ) {                                     \
 227       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                      \
 228                                                                     \
 229       wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);    \
 230                                                                     \
 231       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));             \
 232     }                                                               \
 233   }                                                                 \
 234   void wxLog##level(const wxChar *szFormat, ...)                    \
 235   {                                                                 \
 236     va_list argptr;                                                 \
 237     va_start(argptr, szFormat);                                     \
 238     wxVLog##level(szFormat, argptr);                                \
 239     va_end(argptr);                                                 \
 240   }
 241
 242   void wxVLogTrace(const wxChar *mask, const wxChar *szFormat, va_list argptr)
 243   {
 244     if ( wxLog::IsEnabled() && wxLog::IsAllowedTraceMask(mask) ) {
 245       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 246
 247       wxChar *p = s_szBuf;
 248       size_t len = s_szBufSize;
 249       wxStrncpy(s_szBuf, _T("("), len);
 250       len -= 1; // strlen("(")
 251       p += 1;
 252       wxStrncat(p, mask, len);
 253       size_t lenMask = wxStrlen(mask);
 254       len -= lenMask;
 255       p += lenMask;
 256
 257       wxStrncat(p, _T(") "), len);
 258       len -= 2;
 259       p += 2;
 260
 261       wxVsnprintf(p, len, szFormat, argptr);
 262
 263       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 264     }
 265   }
 266
 267   void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
 268   {
 269     va_list argptr;
 270     va_start(argptr, szFormat);
 271     wxVLogTrace(mask, szFormat, argptr);
 272     va_end(argptr);
 273   }
 274
 275   void wxVLogTrace(wxTraceMask mask, const wxChar *szFormat, va_list argptr)
 276   {
 277     // we check that all of mask bits are set in the current mask, so
 278     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 279     // if both bits are set.
 280     if ( wxLog::IsEnabled() && ((wxLog::GetTraceMask() & mask) == mask) ) {
 281       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 282
 283       wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 284
 285       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 286     }
 287   }
 288
 289   void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
 290   {
 291     va_list argptr;
 292     va_start(argptr, szFormat);
 293     wxVLogTrace(mask, szFormat, argptr);
 294     va_end(argptr);
 295   }
 296
 297 #else // release
 298   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 299 #endif
 300
 301 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 302 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 303
 304 // wxLogSysError: one uses the last error code, for other  you must give it
 305 // explicitly
 306
 307 // common part of both wxLogSysError
 308 void wxLogSysErrorHelper(long lErrCode)
 309 {
 310     wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
 311     wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
 312                _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 313     wxStrncat(s_szBuf, szErrMsg, s_szBufSize - wxStrlen(s_szBuf));
 314
 315     wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
 316 }
 317
 318 void WXDLLEXPORT wxVLogSysError(const wxChar *szFormat, va_list argptr)
 319 {
 320     if ( wxLog::IsEnabled() ) {
 321         wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 322
 323         wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 324
 325         wxLogSysErrorHelper(wxSysErrorCode());
 326     }
 327 }
 328
 329 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
 330 {
 331     va_list argptr;
 332     va_start(argptr, szFormat);
 333     wxVLogSysError(szFormat, argptr);
 334     va_end(argptr);
 335 }
 336
 337 void WXDLLEXPORT wxVLogSysError(long lErrCode, const wxChar *szFormat, va_list argptr)
 338 {
 339     if ( wxLog::IsEnabled() ) {
 340         wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 341
 342         wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 343
 344         wxLogSysErrorHelper(lErrCode);
 345     }
 346 }
 347
 348 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
 349 {
 350     va_list argptr;
 351     va_start(argptr, szFormat);
 352     wxVLogSysError(lErrCode, szFormat, argptr);
 353     va_end(argptr);
 354 }
 355
 356 // ----------------------------------------------------------------------------
 357 // wxLog class implementation
 358 // ----------------------------------------------------------------------------
 359
 360 /* static */
 361 unsigned wxLog::DoLogNumberOfRepeats()
 362 {
 363     long retval = ms_prevCounter;
 364     wxLog *pLogger = GetActiveTarget();
 365     if ( pLogger && ms_prevCounter > 0 )
 366     {
 367         wxString msg;
 368 #if wxUSE_INTL
 369         msg.Printf(wxPLURAL("The previous message repeated once.",
 370                             "The previous message repeated %lu times.",
 371                             ms_prevCounter),
 372                    ms_prevCounter);
 373 #else
 374         msg.Printf(wxT("The previous message was repeated."));
 375 #endif
 376         ms_prevCounter = 0;
 377         ms_prevString.clear();
 378         pLogger->DoLog(ms_prevLevel, msg.c_str(), ms_prevTimeStamp);
 379     }
 380     return retval;
 381 }
 382
 383 wxLog::~wxLog()
 384 {
 385     if ( ms_prevCounter > 0 )
 386     {
 387         // looks like the repeat count has not been logged yet,
 388         // so let's do it now
 389         wxLog::DoLogNumberOfRepeats();
 390     }
 391 }
 392
 393 /* static */
 394 void wxLog::OnLog(wxLogLevel level, const wxChar *szString, time_t t)
 395 {
 396     if ( IsEnabled() && ms_logLevel >= level )
 397     {
 398         wxLog *pLogger = GetActiveTarget();
 399         if ( pLogger )
 400         {
 401             if ( GetRepetitionCounting() && ms_prevString == szString )
 402             {
 403                 ms_prevCounter++;
 404             }
 405             else
 406             {
 407                 if ( GetRepetitionCounting() )
 408                 {
 409                     pLogger->DoLogNumberOfRepeats();
 410                 }
 411                 ms_prevString = szString;
 412                 ms_prevLevel = level;
 413                 ms_prevTimeStamp = t;
 414                 pLogger->DoLog(level, szString, t);
 415             }
 416         }
 417     }
 418 }
 419
 420 wxChar *wxLog::SetLogBuffer( wxChar *buf, size_t size)
 421 {
 422     wxChar *oldbuf = s_szBuf;
 423
 424     if( buf == 0 )
 425     {
 426         s_szBuf = s_szBufStatic;
 427         s_szBufSize = WXSIZEOF( s_szBufStatic );
 428     }
 429     else
 430     {
 431         s_szBuf = buf;
 432         s_szBufSize = size;
 433     }
 434
 435     return (oldbuf == s_szBufStatic ) ? 0 : oldbuf;
 436 }
 437
 438 wxLog *wxLog::GetActiveTarget()
 439 {
 440     if ( ms_bAutoCreate && ms_pLogger == NULL ) {
 441         // prevent infinite recursion if someone calls wxLogXXX() from
 442         // wxApp::CreateLogTarget()
 443         static bool s_bInGetActiveTarget = false;
 444         if ( !s_bInGetActiveTarget ) {
 445             s_bInGetActiveTarget = true;
 446
 447             // ask the application to create a log target for us
 448             if ( wxTheApp != NULL )
 449                 ms_pLogger = wxTheApp->GetTraits()->CreateLogTarget();
 450             else
 451                 ms_pLogger = new wxLogStderr;
 452
 453             s_bInGetActiveTarget = false;
 454
 455             // do nothing if it fails - what can we do?
 456         }
 457     }
 458
 459     return ms_pLogger;
 460 }
 461
 462 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 463 {
 464     if ( ms_pLogger != NULL ) {
 465         // flush the old messages before changing because otherwise they might
 466         // get lost later if this target is not restored
 467         ms_pLogger->Flush();
 468     }
 469
 470     wxLog *pOldLogger = ms_pLogger;
 471     ms_pLogger = pLogger;
 472
 473     return pOldLogger;
 474 }
 475
 476 void wxLog::DontCreateOnDemand()
 477 {
 478     ms_bAutoCreate = false;
 479
 480     // this is usually called at the end of the program and we assume that it
 481     // is *always* called at the end - so we free memory here to avoid false
 482     // memory leak reports from wxWin  memory tracking code
 483     ClearTraceMasks();
 484 }
 485
 486 void wxLog::RemoveTraceMask(const wxString& str)
 487 {
 488     int index = ms_aTraceMasks.Index(str);
 489     if ( index != wxNOT_FOUND )
 490         ms_aTraceMasks.RemoveAt((size_t)index);
 491 }
 492
 493 void wxLog::ClearTraceMasks()
 494 {
 495     ms_aTraceMasks.Clear();
 496 }
 497
 498 void wxLog::TimeStamp(wxString *str)
 499 {
 500     if ( ms_timestamp )
 501     {
 502         wxChar buf[256];
 503         time_t timeNow;
 504         (void)time(&timeNow);
 505         wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
 506
 507         str->Empty();
 508         *str << buf << wxT(": ");
 509     }
 510 }
 511
 512 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 513 {
 514     switch ( level ) {
 515         case wxLOG_FatalError:
 516             DoLogString(wxString(_("Fatal error: ")) + szString, t);
 517             DoLogString(_("Program aborted."), t);
 518             Flush();
 519 #ifdef __WXWINCE__
 520             ExitThread(3);
 521 #else
 522             abort();
 523 #endif
 524             break;
 525
 526         case wxLOG_Error:
 527             DoLogString(wxString(_("Error: ")) + szString, t);
 528             break;
 529
 530         case wxLOG_Warning:
 531             DoLogString(wxString(_("Warning: ")) + szString, t);
 532             break;
 533
 534         case wxLOG_Info:
 535             if ( GetVerbose() )
 536         case wxLOG_Message:
 537         case wxLOG_Status:
 538         default:    // log unknown log levels too
 539                 DoLogString(szString, t);
 540             break;
 541
 542         case wxLOG_Trace:
 543         case wxLOG_Debug:
 544 #ifdef __WXDEBUG__
 545             {
 546                 wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
 547                                                     : wxT("Debug: ");
 548                 msg << szString;
 549                 DoLogString(msg, t);
 550             }
 551 #endif // Debug
 552             break;
 553     }
 554 }
 555
 556 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
 557 {
 558     wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
 559 }
 560
 561 void wxLog::Flush()
 562 {
 563     // nothing to do here
 564 }
 565
 566 /*static*/ bool wxLog::IsAllowedTraceMask(const wxChar *mask)
 567 {
 568     for ( wxArrayString::iterator it = ms_aTraceMasks.begin(),
 569                                   en = ms_aTraceMasks.end();
 570          it != en; ++it )
 571         if ( *it == mask)
 572             return true;
 573     return false;
 574 }
 575
 576 // ----------------------------------------------------------------------------
 577 // wxLogBuffer implementation
 578 // ----------------------------------------------------------------------------
 579
 580 void wxLogBuffer::Flush()
 581 {
 582     if ( !m_str.empty() )
 583     {
 584         wxMessageOutputBest out;
 585         out.Printf(_T("%s"), m_str.c_str());
 586         m_str.clear();
 587     }
 588 }
 589
 590 void wxLogBuffer::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 591 {
 592     switch ( level )
 593     {
 594         case wxLOG_Trace:
 595         case wxLOG_Debug:
 596 #ifdef __WXDEBUG__
 597             // don't put debug messages in the buffer, we don't want to show
 598             // them to the user in a msg box, log them immediately
 599             {
 600                 wxString str;
 601                 TimeStamp(&str);
 602                 str += szString;
 603
 604                 wxMessageOutputDebug dbgout;
 605                 dbgout.Printf(_T("%s\n"), str.c_str());
 606             }
 607 #endif // __WXDEBUG__
 608             break;
 609
 610         default:
 611             wxLog::DoLog(level, szString, t);
 612     }
 613 }
 614
 615 void wxLogBuffer::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 616 {
 617     m_str << szString << _T("\n");
 618 }
 619
 620 // ----------------------------------------------------------------------------
 621 // wxLogStderr class implementation
 622 // ----------------------------------------------------------------------------
 623
 624 wxLogStderr::wxLogStderr(FILE *fp)
 625 {
 626     if ( fp == NULL )
 627         m_fp = stderr;
 628     else
 629         m_fp = fp;
 630 }
 631
 632 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 633 {
 634     wxString str;
 635     TimeStamp(&str);
 636     str << szString;
 637
 638     fputs(str.mb_str(), m_fp);
 639     fputc(_T('\n'), m_fp);
 640     fflush(m_fp);
 641
 642     // under GUI systems such as Windows or Mac, programs usually don't have
 643     // stderr at all, so show the messages also somewhere else, typically in
 644     // the debugger window so that they go at least somewhere instead of being
 645     // simply lost
 646     if ( m_fp == stderr )
 647     {
 648         wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
 649         if ( traits && !traits->HasStderr() )
 650         {
 651             wxMessageOutputDebug dbgout;
 652             dbgout.Printf(_T("%s\n"), str.c_str());
 653         }
 654     }
 655 }
 656
 657 // ----------------------------------------------------------------------------
 658 // wxLogStream implementation
 659 // ----------------------------------------------------------------------------
 660
 661 #if wxUSE_STD_IOSTREAM
 662 #include "wx/ioswrap.h"
 663 wxLogStream::wxLogStream(wxSTD ostream *ostr)
 664 {
 665     if ( ostr == NULL )
 666         m_ostr = &wxSTD cerr;
 667     else
 668         m_ostr = ostr;
 669 }
 670
 671 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 672 {
 673     wxString str;
 674     TimeStamp(&str);
 675     (*m_ostr) << wxConvertWX2MB(str) << wxConvertWX2MB(szString) << wxSTD endl;
 676 }
 677 #endif // wxUSE_STD_IOSTREAM
 678
 679 // ----------------------------------------------------------------------------
 680 // wxLogChain
 681 // ----------------------------------------------------------------------------
 682
 683 wxLogChain::wxLogChain(wxLog *logger)
 684 {
 685     m_bPassMessages = true;
 686
 687     m_logNew = logger;
 688     m_logOld = wxLog::SetActiveTarget(this);
 689 }
 690
 691 wxLogChain::~wxLogChain()
 692 {
 693     delete m_logOld;
 694
 695     if ( m_logNew != this )
 696         delete m_logNew;
 697 }
 698
 699 void wxLogChain::SetLog(wxLog *logger)
 700 {
 701     if ( m_logNew != this )
 702         delete m_logNew;
 703
 704     m_logNew = logger;
 705 }
 706
 707 void wxLogChain::Flush()
 708 {
 709     if ( m_logOld )
 710         m_logOld->Flush();
 711
 712     // be careful to avoid infinite recursion
 713     if ( m_logNew && m_logNew != this )
 714         m_logNew->Flush();
 715 }
 716
 717 void wxLogChain::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 718 {
 719     // let the previous logger show it
 720     if ( m_logOld && IsPassingMessages() )
 721     {
 722         // bogus cast just to access protected DoLog
 723         ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
 724     }
 725
 726     if ( m_logNew && m_logNew != this )
 727     {
 728         // as above...
 729         ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
 730     }
 731 }
 732
 733 // ----------------------------------------------------------------------------
 734 // wxLogPassThrough
 735 // ----------------------------------------------------------------------------
 736
 737 #ifdef __VISUALC__
 738     // "'this' : used in base member initializer list" - so what?
 739     #pragma warning(disable:4355)
 740 #endif // VC++
 741
 742 wxLogPassThrough::wxLogPassThrough()
 743                 : wxLogChain(this)
 744 {
 745 }
 746
 747 #ifdef __VISUALC__
 748     #pragma warning(default:4355)
 749 #endif // VC++
 750
 751 // ============================================================================
 752 // Global functions/variables
 753 // ============================================================================
 754
 755 // ----------------------------------------------------------------------------
 756 // static variables
 757 // ----------------------------------------------------------------------------
 758
 759 bool            wxLog::ms_bRepetCounting = false;
 760 wxString        wxLog::ms_prevString;
 761 unsigned int    wxLog::ms_prevCounter = 0;
 762 time_t          wxLog::ms_prevTimeStamp= 0;
 763 wxLogLevel      wxLog::ms_prevLevel;
 764
 765 wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 766 bool            wxLog::ms_doLog        = true;
 767 bool            wxLog::ms_bAutoCreate  = true;
 768 bool            wxLog::ms_bVerbose     = false;
 769
 770 wxLogLevel      wxLog::ms_logLevel     = wxLOG_Max;  // log everything by default
 771
 772 size_t          wxLog::ms_suspendCount = 0;
 773
 774 const wxChar   *wxLog::ms_timestamp    = wxT("%X");  // time only, no date
 775
 776 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 777 wxArrayString   wxLog::ms_aTraceMasks;
 778
 779 // ----------------------------------------------------------------------------
 780 // stdout error logging helper
 781 // ----------------------------------------------------------------------------
 782
 783 // helper function: wraps the message and justifies it under given position
 784 // (looks more pretty on the terminal). Also adds newline at the end.
 785 //
 786 // TODO this is now disabled until I find a portable way of determining the
 787 //      terminal window size (ok, I found it but does anybody really cares?)
 788 #ifdef LOG_PRETTY_WRAP
 789 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 790 {
 791     size_t nMax = 80; // FIXME
 792     size_t nStart = strlen(pszPrefix);
 793     fputs(pszPrefix, f);
 794
 795     size_t n;
 796     while ( *psz != '\0' ) {
 797         for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 798             putc(*psz++, f);
 799
 800         // wrapped?
 801         if ( *psz != '\0' ) {
 802             /*putc('\n', f);*/
 803             for ( n = 0; n < nStart; n++ )
 804                 putc(' ', f);
 805
 806             // as we wrapped, squeeze all white space
 807             while ( isspace(*psz) )
 808                 psz++;
 809         }
 810     }
 811
 812     putc('\n', f);
 813 }
 814 #endif  //LOG_PRETTY_WRAP
 815
 816 // ----------------------------------------------------------------------------
 817 // error code/error message retrieval functions
 818 // ----------------------------------------------------------------------------
 819
 820 // get error code from syste
 821 unsigned long wxSysErrorCode()
 822 {
 823 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 824     return ::GetLastError();
 825 #else   //Unix
 826     return errno;
 827 #endif  //Win/Unix
 828 }
 829
 830 // get error message from system
 831 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
 832 {
 833     if ( nErrCode == 0 )
 834         nErrCode = wxSysErrorCode();
 835
 836 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 837     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 838
 839     // get error message from system
 840     LPVOID lpMsgBuf;
 841     if ( ::FormatMessage
 842          (
 843             FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 844             NULL,
 845             nErrCode,
 846             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 847             (LPTSTR)&lpMsgBuf,
 848             0,
 849             NULL
 850          ) == 0 )
 851     {
 852         // if this happens, something is seriously wrong, so don't use _() here
 853         // for safety
 854         wxSprintf(s_szBuf, _T("unknown error %lx"), nErrCode);
 855         return s_szBuf;
 856     }
 857
 858
 859     // copy it to our buffer and free memory
 860     // Crashes on SmartPhone (FIXME)
 861 #if !defined(__SMARTPHONE__) /* of WinCE */
 862     if( lpMsgBuf != 0 )
 863     {
 864         wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 865         s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
 866
 867         LocalFree(lpMsgBuf);
 868
 869         // returned string is capitalized and ended with '\r\n' - bad
 870         s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
 871         size_t len = wxStrlen(s_szBuf);
 872         if ( len > 0 ) {
 873             // truncate string
 874             if ( s_szBuf[len - 2] == wxT('\r') )
 875                 s_szBuf[len - 2] = wxT('\0');
 876         }
 877     }
 878     else
 879 #endif
 880     {
 881         s_szBuf[0] = wxT('\0');
 882     }
 883
 884     return s_szBuf;
 885 #else   // Unix-WXMICROWIN
 886 #if wxUSE_UNICODE
 887     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 888     wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
 889     return s_szBuf;
 890 #else
 891     return strerror((int)nErrCode);
 892 #endif
 893 #endif  // Win/Unix-WXMICROWIN
 894 }
 895
 896 #endif // wxUSE_LOG