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         #include "wx/msgdlg.h"
  40         #ifdef __WXMSW__
  41             #include "wx/msw/private.h"
  42         #endif
  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 #if wxUSE_LOG
  54
  55 // other standard headers
  56 #include  <errno.h>
  57 #include  <stdlib.h>
  58 #include  <time.h>
  59
  60 #if defined(__WXMSW__)
  61   #include  "wx/msw/private.h"      // includes windows.h for OutputDebugString
  62 #endif
  63
  64 #if defined(__WXMAC__)
  65   #include  "wx/mac/private.h"  // includes mac headers
  66 #endif
  67
  68 // ----------------------------------------------------------------------------
  69 // non member functions
  70 // ----------------------------------------------------------------------------
  71
  72 // define this to enable wrapping of log messages
  73 //#define LOG_PRETTY_WRAP
  74
  75 #ifdef  LOG_PRETTY_WRAP
  76   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  77 #endif
  78
  79 // ============================================================================
  80 // implementation
  81 // ============================================================================
  82
  83 // ----------------------------------------------------------------------------
  84 // globals
  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
  92 static wxChar   s_szBufStatic[LOG_BUFFER_SIZE];
  93
  94 static wxChar  *s_szBuf     = s_szBufStatic;
  95 static size_t   s_szBufSize = WXSIZEOF( s_szBufStatic );
  96
  97 #if wxUSE_THREADS
  98
  99 // the critical section protecting the static buffer
 100 static wxCriticalSection gs_csLogBuf;
 101
 102 #endif // wxUSE_THREADS
 103
 104 // return true if we have a non NULL non disabled log target
 105 static inline bool IsLoggingEnabled()
 106 {
 107     return wxLog::IsEnabled() && (wxLog::GetActiveTarget() != NULL);
 108 }
 109
 110 // ----------------------------------------------------------------------------
 111 // implementation of Log functions
 112 //
 113 // NB: unfortunately we need all these distinct functions, we can't make them
 114 //     macros and not all compilers inline vararg functions.
 115 // ----------------------------------------------------------------------------
 116
 117 // generic log function
 118 void wxVLogGeneric(wxLogLevel level, const wxChar *szFormat, va_list argptr)
 119 {
 120     if ( IsLoggingEnabled() ) {
 121         wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 122
 123         wxVsnprintf(s_szBuf, s_szBufSize, 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 ( IsLoggingEnabled() ) {                                     \
 141       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                      \
 142                                                                     \
 143       wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);    \
 144                                                                     \
 145       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));             \
 146     }                                                               \
 147   }                                                                 \
 148   void wxLog##level(const wxChar *szFormat, ...)                    \
 149   {                                                                 \
 150     va_list argptr;                                                 \
 151     va_start(argptr, szFormat);                                     \
 152     wxVLog##level(szFormat, argptr);                                \
 153     va_end(argptr);                                                 \
 154   }
 155
 156 IMPLEMENT_LOG_FUNCTION(Error)
 157 IMPLEMENT_LOG_FUNCTION(Warning)
 158 IMPLEMENT_LOG_FUNCTION(Message)
 159 IMPLEMENT_LOG_FUNCTION(Info)
 160 IMPLEMENT_LOG_FUNCTION(Status)
 161
 162 void wxSafeShowMessage(const wxString& title, const wxString& text)
 163 {
 164 #ifdef __WINDOWS__
 165     ::MessageBox(NULL, text, title, MB_OK | MB_ICONSTOP);
 166 #else
 167     wxFprintf(stderr, _T("%s: %s\n"), title.c_str(), text.c_str());
 168 #endif
 169 }
 170
 171 // fatal errors can't be suppressed nor handled by the custom log target and
 172 // always terminate the program
 173 void wxVLogFatalError(const wxChar *szFormat, va_list argptr)
 174 {
 175     wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 176
 177     wxSafeShowMessage(_T("Fatal Error"), s_szBuf);
 178
 179     abort();
 180 }
 181
 182 void wxLogFatalError(const wxChar *szFormat, ...)
 183 {
 184     va_list argptr;
 185     va_start(argptr, szFormat);
 186     wxVLogFatalError(szFormat, argptr);
 187     va_end(argptr);
 188 }
 189
 190 // same as info, but only if 'verbose' mode is on
 191 void wxVLogVerbose(const wxChar *szFormat, va_list argptr)
 192 {
 193     if ( IsLoggingEnabled() ) {
 194         wxLog *pLog = wxLog::GetActiveTarget();
 195         if ( pLog != NULL && pLog->GetVerbose() ) {
 196             wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 197
 198             wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 199
 200             wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
 201         }
 202     }
 203 }
 204
 205 void wxLogVerbose(const wxChar *szFormat, ...)
 206 {
 207     va_list argptr;
 208     va_start(argptr, szFormat);
 209     wxVLogVerbose(szFormat, argptr);
 210     va_end(argptr);
 211 }
 212
 213 // debug functions
 214 #ifdef __WXDEBUG__
 215 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                         \
 216   void wxVLog##level(const wxChar *szFormat, va_list argptr)        \
 217   {                                                                 \
 218     if ( IsLoggingEnabled() ) {                                     \
 219       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);                      \
 220                                                                     \
 221       wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);    \
 222                                                                     \
 223       wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL));             \
 224     }                                                               \
 225   }                                                                 \
 226   void wxLog##level(const wxChar *szFormat, ...)                    \
 227   {                                                                 \
 228     va_list argptr;                                                 \
 229     va_start(argptr, szFormat);                                     \
 230     wxVLog##level(szFormat, argptr);                                \
 231     va_end(argptr);                                                 \
 232   }
 233
 234   void wxVLogTrace(const wxChar *mask, const wxChar *szFormat, va_list argptr)
 235   {
 236     if ( IsLoggingEnabled() && wxLog::IsAllowedTraceMask(mask) ) {
 237       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 238
 239       wxChar *p = s_szBuf;
 240       size_t len = s_szBufSize;
 241       wxStrncpy(s_szBuf, _T("("), len);
 242       len -= 1; // strlen("(")
 243       p += 1;
 244       wxStrncat(p, mask, len);
 245       size_t lenMask = wxStrlen(mask);
 246       len -= lenMask;
 247       p += lenMask;
 248
 249       wxStrncat(p, _T(") "), len);
 250       len -= 2;
 251       p += 2;
 252
 253       wxVsnprintf(p, len, szFormat, argptr);
 254
 255       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 256     }
 257   }
 258
 259   void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
 260   {
 261     va_list argptr;
 262     va_start(argptr, szFormat);
 263     wxVLogTrace(mask, szFormat, argptr);
 264     va_end(argptr);
 265   }
 266
 267   void wxVLogTrace(wxTraceMask mask, const wxChar *szFormat, va_list argptr)
 268   {
 269     // we check that all of mask bits are set in the current mask, so
 270     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 271     // if both bits are set.
 272     if ( IsLoggingEnabled() && ((wxLog::GetTraceMask() & mask) == mask) ) {
 273       wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 274
 275       wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 276
 277       wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
 278     }
 279   }
 280
 281   void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
 282   {
 283     va_list argptr;
 284     va_start(argptr, szFormat);
 285     wxVLogTrace(mask, szFormat, argptr);
 286     va_end(argptr);
 287   }
 288
 289 #else // release
 290   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 291 #endif
 292
 293 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 294 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 295
 296 // wxLogSysError: one uses the last error code, for other  you must give it
 297 // explicitly
 298
 299 // common part of both wxLogSysError
 300 void wxLogSysErrorHelper(long lErrCode)
 301 {
 302     wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
 303     wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
 304                _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 305     wxStrncat(s_szBuf, szErrMsg, s_szBufSize - wxStrlen(s_szBuf));
 306
 307     wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
 308 }
 309
 310 void WXDLLEXPORT wxVLogSysError(const wxChar *szFormat, va_list argptr)
 311 {
 312     if ( IsLoggingEnabled() ) {
 313         wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 314
 315         wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 316
 317         wxLogSysErrorHelper(wxSysErrorCode());
 318     }
 319 }
 320
 321 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
 322 {
 323     va_list argptr;
 324     va_start(argptr, szFormat);
 325     wxVLogSysError(szFormat, argptr);
 326     va_end(argptr);
 327 }
 328
 329 void WXDLLEXPORT wxVLogSysError(long lErrCode, const wxChar *szFormat, va_list argptr)
 330 {
 331     if ( IsLoggingEnabled() ) {
 332         wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
 333
 334         wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
 335
 336         wxLogSysErrorHelper(lErrCode);
 337     }
 338 }
 339
 340 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
 341 {
 342     va_list argptr;
 343     va_start(argptr, szFormat);
 344     wxVLogSysError(lErrCode, szFormat, argptr);
 345     va_end(argptr);
 346 }
 347
 348 // ----------------------------------------------------------------------------
 349 // wxLog class implementation
 350 // ----------------------------------------------------------------------------
 351
 352 wxLog::wxLog()
 353 {
 354     m_bHasMessages = FALSE;
 355 }
 356
 357 wxChar *wxLog::SetLogBuffer( wxChar *buf, size_t size)
 358 {
 359     wxChar *oldbuf = s_szBuf;
 360
 361     if( buf == 0 )
 362     {
 363         s_szBuf = s_szBufStatic;
 364         s_szBufSize = WXSIZEOF( s_szBufStatic );
 365     }
 366     else
 367     {
 368         s_szBuf = buf;
 369         s_szBufSize = size;
 370     }
 371
 372     return (oldbuf == s_szBufStatic ) ? 0 : oldbuf;
 373 }
 374
 375 wxLog *wxLog::GetActiveTarget()
 376 {
 377     if ( ms_bAutoCreate && ms_pLogger == NULL ) {
 378         // prevent infinite recursion if someone calls wxLogXXX() from
 379         // wxApp::CreateLogTarget()
 380         static bool s_bInGetActiveTarget = FALSE;
 381         if ( !s_bInGetActiveTarget ) {
 382             s_bInGetActiveTarget = TRUE;
 383
 384             // ask the application to create a log target for us
 385             if ( wxTheApp != NULL )
 386                 ms_pLogger = wxTheApp->CreateLogTarget();
 387             else
 388                 ms_pLogger = new wxLogStderr;
 389
 390             s_bInGetActiveTarget = FALSE;
 391
 392             // do nothing if it fails - what can we do?
 393         }
 394     }
 395
 396     return ms_pLogger;
 397 }
 398
 399 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 400 {
 401     if ( ms_pLogger != NULL ) {
 402         // flush the old messages before changing because otherwise they might
 403         // get lost later if this target is not restored
 404         ms_pLogger->Flush();
 405     }
 406
 407     wxLog *pOldLogger = ms_pLogger;
 408     ms_pLogger = pLogger;
 409
 410     return pOldLogger;
 411 }
 412
 413 void wxLog::DontCreateOnDemand()
 414 {
 415     ms_bAutoCreate = FALSE;
 416
 417     // this is usually called at the end of the program and we assume that it
 418     // is *always* called at the end - so we free memory here to avoid false
 419     // memory leak reports from wxWin  memory tracking code
 420     ClearTraceMasks();
 421 }
 422
 423 void wxLog::RemoveTraceMask(const wxString& str)
 424 {
 425     int index = ms_aTraceMasks.Index(str);
 426     if ( index != wxNOT_FOUND )
 427         ms_aTraceMasks.Remove((size_t)index);
 428 }
 429
 430 void wxLog::ClearTraceMasks()
 431 {
 432     ms_aTraceMasks.Clear();
 433 }
 434
 435 void wxLog::TimeStamp(wxString *str)
 436 {
 437     if ( ms_timestamp )
 438     {
 439         wxChar buf[256];
 440         time_t timeNow;
 441         (void)time(&timeNow);
 442         wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
 443
 444         str->Empty();
 445         *str << buf << wxT(": ");
 446     }
 447 }
 448
 449 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 450 {
 451     switch ( level ) {
 452         case wxLOG_FatalError:
 453             DoLogString(wxString(_("Fatal error: ")) + szString, t);
 454             DoLogString(_("Program aborted."), t);
 455             Flush();
 456             abort();
 457             break;
 458
 459         case wxLOG_Error:
 460             DoLogString(wxString(_("Error: ")) + szString, t);
 461             break;
 462
 463         case wxLOG_Warning:
 464             DoLogString(wxString(_("Warning: ")) + szString, t);
 465             break;
 466
 467         case wxLOG_Info:
 468             if ( GetVerbose() )
 469         case wxLOG_Message:
 470         case wxLOG_Status:
 471         default:    // log unknown log levels too
 472                 DoLogString(szString, t);
 473             break;
 474
 475         case wxLOG_Trace:
 476         case wxLOG_Debug:
 477 #ifdef __WXDEBUG__
 478             {
 479                 wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
 480                                                     : wxT("Debug: ");
 481                 msg << szString;
 482                 DoLogString(msg, t);
 483             }
 484 #endif // Debug
 485             break;
 486     }
 487 }
 488
 489 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
 490 {
 491     wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
 492 }
 493
 494 void wxLog::Flush()
 495 {
 496     // remember that we don't have any more messages to show
 497     m_bHasMessages = FALSE;
 498 }
 499
 500 // ----------------------------------------------------------------------------
 501 // wxLogStderr class implementation
 502 // ----------------------------------------------------------------------------
 503
 504 wxLogStderr::wxLogStderr(FILE *fp)
 505 {
 506     if ( fp == NULL )
 507         m_fp = stderr;
 508     else
 509         m_fp = fp;
 510 }
 511
 512 #if defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
 513
 514 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
 515
 516 #ifndef __MetroNubUtils__
 517 #include "MetroNubUtils.h"
 518 #endif
 519
 520 #ifdef __cplusplus
 521     extern "C" {
 522 #endif
 523
 524 #ifndef __GESTALT__
 525 #include <Gestalt.h>
 526 #endif
 527
 528 #ifndef true
 529 #define true 1
 530 #endif
 531
 532 #ifndef false
 533 #define false 0
 534 #endif
 535
 536 #if TARGET_API_MAC_CARBON
 537
 538     #include <CodeFragments.h>
 539
 540     EXTERN_API_C( long )
 541     CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
 542
 543     ProcPtr gCallUniversalProc_Proc = NULL;
 544
 545 #endif
 546
 547 static MetroNubUserEntryBlock*    gMetroNubEntry = NULL;
 548
 549 static long fRunOnce = false;
 550
 551 Boolean IsCompatibleVersion(short inVersion);
 552
 553 /* ---------------------------------------------------------------------------
 554         IsCompatibleVersion
 555    --------------------------------------------------------------------------- */
 556
 557 Boolean IsCompatibleVersion(short inVersion)
 558 {
 559     Boolean result = false;
 560
 561     if (fRunOnce)
 562     {
 563         MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
 564
 565         result = (inVersion <= block->apiHiVersion);
 566     }
 567
 568     return result;
 569 }
 570
 571 /* ---------------------------------------------------------------------------
 572         IsMetroNubInstalled
 573    --------------------------------------------------------------------------- */
 574
 575 Boolean IsMetroNubInstalled()
 576 {
 577     if (!fRunOnce)
 578     {
 579         long result, value;
 580
 581         fRunOnce = true;
 582         gMetroNubEntry = NULL;
 583
 584         if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
 585         {
 586             /* look for MetroNub's Gestalt selector */
 587             if (Gestalt(kMetroNubUserSignature, &result) == noErr)
 588             {
 589
 590             #if TARGET_API_MAC_CARBON
 591                 if (gCallUniversalProc_Proc == NULL)
 592                 {
 593                     CFragConnectionID   connectionID;
 594                     Ptr                 mainAddress;
 595                     Str255              errorString;
 596                     ProcPtr             symbolAddress;
 597                     OSErr               err;
 598                     CFragSymbolClass    symbolClass;
 599
 600                     symbolAddress = NULL;
 601                     err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
 602                                            &connectionID, &mainAddress, errorString);
 603
 604                     if (err != noErr)
 605                     {
 606                         gCallUniversalProc_Proc = NULL;
 607                         goto end;
 608                     }
 609
 610                     err = FindSymbol(connectionID, "\pCallUniversalProc",
 611                                     (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
 612
 613                     if (err != noErr)
 614                     {
 615                         gCallUniversalProc_Proc = NULL;
 616                         goto end;
 617                     }
 618                 }
 619             #endif
 620
 621                 {
 622                     MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
 623
 624                     /* make sure the version of the API is compatible */
 625                     if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
 626                         kMetroNubUserAPIVersion <= block->apiHiVersion)
 627                         gMetroNubEntry = block;        /* success! */
 628                 }
 629
 630             }
 631         }
 632     }
 633
 634 end:
 635
 636 #if TARGET_API_MAC_CARBON
 637     return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
 638 #else
 639     return (gMetroNubEntry != NULL);
 640 #endif
 641 }
 642
 643 /* ---------------------------------------------------------------------------
 644         IsMWDebuggerRunning                                            [v1 API]
 645    --------------------------------------------------------------------------- */
 646
 647 Boolean IsMWDebuggerRunning()
 648 {
 649     if (IsMetroNubInstalled())
 650         return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
 651     else
 652         return false;
 653 }
 654
 655 /* ---------------------------------------------------------------------------
 656         AmIBeingMWDebugged                                            [v1 API]
 657    --------------------------------------------------------------------------- */
 658
 659 Boolean AmIBeingMWDebugged()
 660 {
 661     if (IsMetroNubInstalled())
 662         return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
 663     else
 664         return false;
 665 }
 666
 667 /* ---------------------------------------------------------------------------
 668         UserSetWatchPoint                                            [v2 API]
 669    --------------------------------------------------------------------------- */
 670
 671 OSErr UserSetWatchPoint (Ptr address, long length, WatchPointIDT* watchPointID)
 672 {
 673     if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion))
 674         return CallUserSetWatchPointProc(gMetroNubEntry->userSetWatchPoint,
 675                                          address, length, watchPointID);
 676     else
 677         return errProcessIsNotClient;
 678 }
 679
 680 /* ---------------------------------------------------------------------------
 681         ClearWatchPoint                                                [v2 API]
 682    --------------------------------------------------------------------------- */
 683
 684 OSErr ClearWatchPoint (WatchPointIDT watchPointID)
 685 {
 686     if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion))
 687         return CallClearWatchPointProc(gMetroNubEntry->clearWatchPoint, watchPointID);
 688     else
 689         return errProcessIsNotClient;
 690 }
 691
 692 #ifdef __cplusplus
 693     }
 694 #endif
 695
 696 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
 697
 698 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 699 {
 700     wxString str;
 701     TimeStamp(&str);
 702     str << szString;
 703
 704     fputs(str.mb_str(), m_fp);
 705     fputc(_T('\n'), m_fp);
 706     fflush(m_fp);
 707
 708     // under Windows, programs usually don't have stderr at all, so show the
 709     // messages also under debugger - unless it's a console program
 710 #if defined(__WXMSW__) && wxUSE_GUI && !defined(__WXMICROWIN__)
 711     str += wxT("\r\n") ;
 712     OutputDebugString(str.c_str());
 713 #endif // MSW
 714 #if defined(__WXMAC__) && !defined(__DARWIN__) && wxUSE_GUI
 715     Str255 pstr ;
 716     strcpy( (char*) pstr , str.c_str() ) ;
 717     strcat( (char*) pstr , ";g" ) ;
 718     c2pstr( (char*) pstr ) ;
 719
 720     Boolean running = false ;
 721
 722 #if defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
 723
 724     if ( IsMWDebuggerRunning() && AmIBeingMWDebugged() )
 725     {
 726         running = true ;
 727     }
 728
 729 #endif
 730
 731     if (running)
 732     {
 733 #ifdef __powerc
 734         DebugStr(pstr);
 735 #else
 736         SysBreakStr(pstr);
 737 #endif
 738     }
 739 #endif // Mac
 740 }
 741
 742 // ----------------------------------------------------------------------------
 743 // wxLogStream implementation
 744 // ----------------------------------------------------------------------------
 745
 746 #if wxUSE_STD_IOSTREAM
 747 wxLogStream::wxLogStream(wxSTD ostream *ostr)
 748 {
 749     if ( ostr == NULL )
 750         m_ostr = &wxSTD cerr;
 751     else
 752         m_ostr = ostr;
 753 }
 754
 755 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
 756 {
 757     wxString str;
 758     TimeStamp(&str);
 759     (*m_ostr) << str << wxConvertWX2MB(szString) << wxSTD endl;
 760 }
 761 #endif // wxUSE_STD_IOSTREAM
 762
 763 // ----------------------------------------------------------------------------
 764 // wxLogChain
 765 // ----------------------------------------------------------------------------
 766
 767 wxLogChain::wxLogChain(wxLog *logger)
 768 {
 769     m_bPassMessages = TRUE;
 770
 771     m_logNew = logger;
 772     m_logOld = wxLog::SetActiveTarget(this);
 773 }
 774
 775 wxLogChain::~wxLogChain()
 776 {
 777     delete m_logOld;
 778
 779     if ( m_logNew != this )
 780         delete m_logNew;
 781 }
 782
 783 void wxLogChain::SetLog(wxLog *logger)
 784 {
 785     if ( m_logNew != this )
 786         delete m_logNew;
 787
 788     m_logNew = logger;
 789 }
 790
 791 void wxLogChain::Flush()
 792 {
 793     if ( m_logOld )
 794         m_logOld->Flush();
 795
 796     // be careful to avoid inifinite recursion
 797     if ( m_logNew && m_logNew != this )
 798         m_logNew->Flush();
 799 }
 800
 801 void wxLogChain::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
 802 {
 803     // let the previous logger show it
 804     if ( m_logOld && IsPassingMessages() )
 805     {
 806         // bogus cast just to access protected DoLog
 807         ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
 808     }
 809
 810     if ( m_logNew && m_logNew != this )
 811     {
 812         // as above...
 813         ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
 814     }
 815 }
 816
 817 // ----------------------------------------------------------------------------
 818 // wxLogPassThrough
 819 // ----------------------------------------------------------------------------
 820
 821 #ifdef __VISUALC__
 822     // "'this' : used in base member initializer list" - so what?
 823     #pragma warning(disable:4355)
 824 #endif // VC++
 825
 826 wxLogPassThrough::wxLogPassThrough()
 827                 : wxLogChain(this)
 828 {
 829 }
 830
 831 #ifdef __VISUALC__
 832     #pragma warning(default:4355)
 833 #endif // VC++
 834
 835 // ============================================================================
 836 // Global functions/variables
 837 // ============================================================================
 838
 839 // ----------------------------------------------------------------------------
 840 // static variables
 841 // ----------------------------------------------------------------------------
 842
 843 wxLog          *wxLog::ms_pLogger      = (wxLog *)NULL;
 844 bool            wxLog::ms_doLog        = TRUE;
 845 bool            wxLog::ms_bAutoCreate  = TRUE;
 846 bool            wxLog::ms_bVerbose     = FALSE;
 847
 848 wxLogLevel      wxLog::ms_logLevel     = wxLOG_Max;  // log everything by default
 849
 850 size_t          wxLog::ms_suspendCount = 0;
 851
 852 #if wxUSE_GUI
 853     const wxChar *wxLog::ms_timestamp  = wxT("%X");  // time only, no date
 854 #else
 855     const wxChar *wxLog::ms_timestamp  = NULL;       // save space
 856 #endif
 857
 858 wxTraceMask     wxLog::ms_ulTraceMask  = (wxTraceMask)0;
 859 wxArrayString   wxLog::ms_aTraceMasks;
 860
 861 // ----------------------------------------------------------------------------
 862 // stdout error logging helper
 863 // ----------------------------------------------------------------------------
 864
 865 // helper function: wraps the message and justifies it under given position
 866 // (looks more pretty on the terminal). Also adds newline at the end.
 867 //
 868 // TODO this is now disabled until I find a portable way of determining the
 869 //      terminal window size (ok, I found it but does anybody really cares?)
 870 #ifdef LOG_PRETTY_WRAP
 871 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 872 {
 873     size_t nMax = 80; // FIXME
 874     size_t nStart = strlen(pszPrefix);
 875     fputs(pszPrefix, f);
 876
 877     size_t n;
 878     while ( *psz != '\0' ) {
 879         for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 880             putc(*psz++, f);
 881
 882         // wrapped?
 883         if ( *psz != '\0' ) {
 884             /*putc('\n', f);*/
 885             for ( n = 0; n < nStart; n++ )
 886                 putc(' ', f);
 887
 888             // as we wrapped, squeeze all white space
 889             while ( isspace(*psz) )
 890                 psz++;
 891         }
 892     }
 893
 894     putc('\n', f);
 895 }
 896 #endif  //LOG_PRETTY_WRAP
 897
 898 // ----------------------------------------------------------------------------
 899 // error code/error message retrieval functions
 900 // ----------------------------------------------------------------------------
 901
 902 // get error code from syste
 903 unsigned long wxSysErrorCode()
 904 {
 905 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 906 #ifdef  __WIN32__
 907     return ::GetLastError();
 908 #else   //WIN16
 909     // TODO what to do on Windows 3.1?
 910     return 0;
 911 #endif  //WIN16/32
 912 #else   //Unix
 913     return errno;
 914 #endif  //Win/Unix
 915 }
 916
 917 // get error message from system
 918 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
 919 {
 920     if ( nErrCode == 0 )
 921         nErrCode = wxSysErrorCode();
 922
 923 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 924 #ifdef  __WIN32__
 925     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 926
 927     // get error message from system
 928     LPVOID lpMsgBuf;
 929     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 930             NULL, nErrCode,
 931             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 932             (LPTSTR)&lpMsgBuf,
 933             0, NULL);
 934
 935     // copy it to our buffer and free memory
 936     if( lpMsgBuf != 0 ) {
 937         wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 938         s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
 939
 940         LocalFree(lpMsgBuf);
 941
 942         // returned string is capitalized and ended with '\r\n' - bad
 943         s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
 944         size_t len = wxStrlen(s_szBuf);
 945         if ( len > 0 ) {
 946             // truncate string
 947             if ( s_szBuf[len - 2] == wxT('\r') )
 948                 s_szBuf[len - 2] = wxT('\0');
 949         }
 950     }
 951     else {
 952         s_szBuf[0] = wxT('\0');
 953     }
 954
 955     return s_szBuf;
 956 #else   //Win16
 957     // TODO
 958     return NULL;
 959 #endif // Win16/32
 960 #else   // Unix
 961 #if wxUSE_UNICODE
 962     static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
 963     wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
 964     return s_szBuf;
 965 #else
 966     return strerror((int)nErrCode);
 967 #endif
 968 #endif  // Win/Unix
 969 }
 970
 971 #endif //wxUSE_LOG
 972
 973 // vi:sts=4:sw=4:et