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 #ifdef __GNUG__
  20   #pragma implementation "log.h"
  21 #endif
  22
  23 // For compilers that support precompilation, includes "wx.h".
  24 #include "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27   #pragma hdrstop
  28 #endif
  29
  30 // wxWindows
  31 #ifndef WX_PRECOMP
  32   #include  <wx/app.h>
  33   #include  <wx/string.h>
  34   #include  <wx/intl.h>
  35
  36   #include  <wx/generic/msgdlgg.h>
  37   #include  <wx/filedlg.h>
  38   #include  <wx/textctrl.h>
  39 #endif //WX_PRECOMP
  40
  41 #include  <wx/file.h>
  42 #include  <wx/textfile.h>
  43 #include  <wx/log.h>
  44
  45 // other standard headers
  46 #include  <errno.h>
  47 #include  <stdlib.h>
  48 #include  <time.h>
  49
  50 #ifdef  __WXMSW__
  51   #include  <windows.h>
  52 #else   //Unix
  53   #include  <signal.h>
  54 #endif  //Win/Unix
  55
  56 // ----------------------------------------------------------------------------
  57 // non member functions
  58 // ----------------------------------------------------------------------------
  59
  60 // define this to enable wrapping of log messages
  61 //#define LOG_PRETTY_WRAP
  62
  63 #ifdef  LOG_PRETTY_WRAP
  64   static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
  65 #endif
  66
  67 // ============================================================================
  68 // implementation
  69 // ============================================================================
  70
  71 // ----------------------------------------------------------------------------
  72 // implementation of Log functions
  73 //
  74 // NB: unfortunately we need all these distinct functions, we can't make them
  75 //     macros and not all compilers inline vararg functions.
  76 // ----------------------------------------------------------------------------
  77
  78 // log functions can't allocate memory (LogError("out of memory...") should
  79 // work!), so we use a static buffer for all log messages
  80 #define LOG_BUFFER_SIZE   (4096)
  81
  82 // static buffer for error messages (@@@ MT-unsafe)
  83 static char s_szBuf[LOG_BUFFER_SIZE];
  84
  85 // generic log function
  86 void wxLogGeneric(wxLogLevel level, const char *szFormat, ...)
  87 {
  88   if ( wxLog::GetActiveTarget() != NULL ) {
  89     va_list argptr;
  90     va_start(argptr, szFormat);
  91     vsprintf(s_szBuf, szFormat, argptr);
  92     va_end(argptr);
  93
  94     wxLog::OnLog(level, s_szBuf);
  95   }
  96 }
  97
  98 #define IMPLEMENT_LOG_FUNCTION(level)                             \
  99   void wxLog##level(const char *szFormat, ...)                    \
 100   {                                                               \
 101     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 102       va_list argptr;                                             \
 103       va_start(argptr, szFormat);                                 \
 104       vsprintf(s_szBuf, szFormat, argptr);                        \
 105       va_end(argptr);                                             \
 106                                                                   \
 107       wxLog::OnLog(wxLOG_##level, s_szBuf);                       \
 108     }                                                             \
 109   }
 110
 111 IMPLEMENT_LOG_FUNCTION(FatalError)
 112 IMPLEMENT_LOG_FUNCTION(Error)
 113 IMPLEMENT_LOG_FUNCTION(Warning)
 114 IMPLEMENT_LOG_FUNCTION(Message)
 115 IMPLEMENT_LOG_FUNCTION(Info)
 116 IMPLEMENT_LOG_FUNCTION(Status)
 117
 118 // same as info, but only if 'verbose' mode is on
 119 void wxLogVerbose(const char *szFormat, ...)
 120 {
 121   wxLog *pLog = wxLog::GetActiveTarget();
 122   if ( pLog != NULL && pLog->GetVerbose() ) {
 123     va_list argptr;
 124     va_start(argptr, szFormat);
 125     vsprintf(s_szBuf, szFormat, argptr);
 126     va_end(argptr);
 127
 128     wxLog::OnLog(wxLOG_Info, s_szBuf);
 129   }
 130 }
 131
 132 // debug functions
 133 #ifdef __WXDEBUG__
 134 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)                       \
 135   void wxLog##level(const char *szFormat, ...)                    \
 136   {                                                               \
 137     if ( wxLog::GetActiveTarget() != NULL ) {                     \
 138       va_list argptr;                                             \
 139       va_start(argptr, szFormat);                                 \
 140       vsprintf(s_szBuf, szFormat, argptr);                        \
 141       va_end(argptr);                                             \
 142                                                                   \
 143       wxLog::OnLog(wxLOG_##level, s_szBuf);                       \
 144     }                                                             \
 145   }
 146
 147   void wxLogTrace(wxTraceMask mask, const char *szFormat, ...)
 148   {
 149     wxLog *pLog = wxLog::GetActiveTarget();
 150
 151     // we check that all of mask bits are set in the current mask, so
 152     // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
 153     // if both bits are set.
 154     if ( pLog != NULL && (pLog->GetTraceMask() & mask == mask) ) {
 155       va_list argptr;
 156       va_start(argptr, szFormat);
 157       vsprintf(s_szBuf, szFormat, argptr);
 158       va_end(argptr);
 159
 160       wxLog::OnLog(wxLOG_Trace, s_szBuf);
 161     }
 162   }
 163
 164 #else // release
 165   #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
 166 #endif
 167
 168 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
 169 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
 170
 171 // wxLogSysError: one uses the last error code, for other  you must give it
 172 // explicitly
 173
 174 // common part of both wxLogSysError
 175 void wxLogSysErrorHelper(long lErrCode)
 176 {
 177   char szErrMsg[LOG_BUFFER_SIZE / 2];
 178   sprintf(szErrMsg, _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
 179   strncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - strlen(s_szBuf));
 180
 181   wxLog::OnLog(wxLOG_Error, s_szBuf);
 182 }
 183
 184 void WXDLLEXPORT wxLogSysError(const char *szFormat, ...)
 185 {
 186   va_list argptr;
 187   va_start(argptr, szFormat);
 188   vsprintf(s_szBuf, szFormat, argptr);
 189   va_end(argptr);
 190
 191   wxLogSysErrorHelper(wxSysErrorCode());
 192 }
 193
 194 void WXDLLEXPORT wxLogSysError(long lErrCode, const char *szFormat, ...)
 195 {
 196   va_list argptr;
 197   va_start(argptr, szFormat);
 198   vsprintf(s_szBuf, szFormat, argptr);
 199   va_end(argptr);
 200
 201   wxLogSysErrorHelper(lErrCode);
 202 }
 203
 204 // ----------------------------------------------------------------------------
 205 // wxLog class implementation
 206 // ----------------------------------------------------------------------------
 207
 208 wxLog::wxLog()
 209 {
 210   m_bHasMessages = FALSE;
 211   m_bVerbose     = FALSE;
 212   m_szTimeFormat = "[%d/%b/%y %H:%M:%S] ";
 213   m_ulTraceMask  = (wxTraceMask)0;        // -1 to set all bits
 214 }
 215
 216 wxLog *wxLog::GetActiveTarget()
 217 {
 218   if ( !ms_bInitialized ) {
 219     // prevent infinite recursion if someone calls wxLogXXX() from
 220     // wxApp::CreateLogTarget()
 221     ms_bInitialized = TRUE;
 222
 223     #ifdef  WX_TEST_MINIMAL
 224       ms_pLogger = new wxLogStderr;
 225     #else
 226       // ask the application to create a log target for us
 227       ms_pLogger = wxTheApp->CreateLogTarget();
 228     #endif
 229
 230     // do nothing if it fails - what can we do?
 231   }
 232
 233   return ms_pLogger;
 234 }
 235
 236 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
 237 {
 238   // flush the old messages before changing
 239   if ( ms_pLogger != NULL )
 240     ms_pLogger->Flush();
 241
 242   ms_bInitialized = TRUE;
 243
 244   wxLog *pOldLogger = ms_pLogger;
 245   ms_pLogger = pLogger;
 246   return pOldLogger;
 247 }
 248
 249 void wxLog::DoLog(wxLogLevel level, const char *szString)
 250 {
 251   wxString str;
 252
 253   // prepend a timestamp if not disabled
 254   if ( !IsEmpty(m_szTimeFormat) ) {
 255     char szBuf[128];
 256     time_t timeNow;
 257     struct tm *ptmNow;
 258
 259     time(&timeNow);
 260     ptmNow = localtime(&timeNow);
 261
 262     strftime(szBuf, WXSIZEOF(szBuf), m_szTimeFormat, ptmNow);
 263     str = szBuf;
 264   }
 265
 266   switch ( level ) {
 267     case wxLOG_FatalError:
 268       DoLogString(str << _("Fatal error: ") << szString);
 269       DoLogString(_("Program aborted."));
 270       Flush();
 271       abort();
 272       break;
 273
 274     case wxLOG_Error:
 275       DoLogString(str << _("Error: ") << szString);
 276       break;
 277
 278     case wxLOG_Warning:
 279       DoLogString(str << _("Warning: ") << szString);
 280       break;
 281
 282     case wxLOG_Info:
 283       if ( GetVerbose() )
 284     case wxLOG_Message:
 285         DoLogString(str + szString);
 286       // fall through
 287
 288     case wxLOG_Status:
 289       // nothing to do
 290       break;
 291
 292     case wxLOG_Trace:
 293     case wxLOG_Debug:
 294       #ifdef __WXDEBUG__
 295         #ifdef  __WIN32__
 296           // in addition to normal logging, also send the string to debugger
 297           // (don't prepend "Debug" here: it will go to debug window anyhow)
 298           ::OutputDebugString(str + szString + "\n\r");
 299         #endif  //Win32
 300         DoLogString(str << (level == wxLOG_Trace ? _("Trace") : _("Debug"))
 301                         << ": " << szString);
 302       #endif
 303
 304       break;
 305
 306     default:
 307       wxFAIL_MSG("unknown log level in wxLog::DoLog");
 308   }
 309 }
 310
 311 void wxLog::DoLogString(const char *szString)
 312 {
 313   wxFAIL_MSG("DoLogString must be overrided if it's called.");
 314 }
 315
 316 void wxLog::Flush()
 317 {
 318   // do nothing
 319 }
 320
 321 // ----------------------------------------------------------------------------
 322 // wxLogStderr class implementation
 323 // ----------------------------------------------------------------------------
 324
 325 wxLogStderr::wxLogStderr(FILE *fp)
 326 {
 327   if ( fp == NULL )
 328     m_fp = stderr;
 329   else
 330     m_fp = fp;
 331 }
 332
 333 void wxLogStderr::DoLogString(const char *szString)
 334 {
 335   fputs(szString, m_fp);
 336   fputc('\n', m_fp);
 337   fflush(m_fp);
 338 }
 339
 340 // ----------------------------------------------------------------------------
 341 // wxLogStream implementation
 342 // ----------------------------------------------------------------------------
 343
 344 wxLogStream::wxLogStream(ostream *ostr)
 345 {
 346   if ( ostr == NULL )
 347     m_ostr = &cerr;
 348   else
 349     m_ostr = ostr;
 350 }
 351
 352 void wxLogStream::DoLogString(const char *szString)
 353 {
 354   (*m_ostr) << szString << endl << flush;
 355 }
 356
 357 // ----------------------------------------------------------------------------
 358 // wxLogTextCtrl implementation
 359 // ----------------------------------------------------------------------------
 360 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl *pTextCtrl)
 361 // @@@ TODO: in wxGTK wxTextCtrl doesn't derive from streambuf
 362 #ifndef __WXGTK__
 363              : wxLogStream(new ostream(pTextCtrl))
 364 #endif //GTK
 365 {
 366 }
 367
 368 wxLogTextCtrl::~wxLogTextCtrl()
 369 {
 370   #ifndef __WXGTK__
 371     delete m_ostr;
 372   #endif //GTK
 373 }
 374
 375 // ----------------------------------------------------------------------------
 376 // wxLogGui implementation
 377 // ----------------------------------------------------------------------------
 378
 379 #ifndef   WX_TEST_MINIMAL
 380
 381 wxLogGui::wxLogGui()
 382 {
 383   m_bErrors = FALSE;
 384 }
 385
 386 void wxLogGui::Flush()
 387 {
 388   if ( !m_bHasMessages )
 389     return;
 390
 391   // @@@ ugly...
 392
 393   // concatenate all strings (but not too many to not overfill the msg box)
 394   wxString str;
 395   uint nLines    = 0,
 396        nMsgCount = m_aMessages.Count();
 397
 398   // start from the most recent message
 399   for ( uint n = nMsgCount; n > 0; n-- ) {
 400     // for Windows strings longer than this value are wrapped (NT 4.0)
 401     const uint nMsgLineWidth = 156;
 402
 403     nLines += (m_aMessages[n - 1].Len() + nMsgLineWidth - 1) / nMsgLineWidth;
 404
 405     if ( nLines > 25 )  // don't put too many lines in message box
 406       break;
 407
 408     str << m_aMessages[n - 1] << "\n";
 409   }
 410
 411   if ( m_bErrors ) {
 412     wxMessageBox(str, _("Error"), wxOK | wxICON_EXCLAMATION);
 413   }
 414   else {
 415     wxMessageBox(str, _("Information"), wxOK | wxICON_INFORMATION);
 416   }
 417
 418   // no undisplayed messages whatsoever
 419   m_bHasMessages =
 420   m_bErrors      = FALSE;
 421   m_aMessages.Empty();
 422 }
 423
 424 // the default behaviour is to discard all informational messages if there
 425 // are any errors/warnings.
 426 void wxLogGui::DoLog(wxLogLevel level, const char *szString)
 427 {
 428   switch ( level ) {
 429     case wxLOG_Info:
 430       if ( GetVerbose() )
 431     case wxLOG_Message:
 432         if ( !m_bErrors ) {
 433           m_aMessages.Add(szString);
 434           m_bHasMessages = TRUE;
 435         }
 436       break;
 437
 438     case wxLOG_Status:
 439       {
 440         // find the top window and set it's status text if it has any
 441         wxWindow *pWin = wxTheApp->GetTopWindow();
 442         if ( pWin != NULL && pWin->IsKindOf(CLASSINFO(wxFrame)) ) {
 443           wxFrame *pFrame = (wxFrame *)pWin;
 444           pFrame->SetStatusText(szString);
 445         }
 446       }
 447       break;
 448
 449     case wxLOG_Trace:
 450     case wxLOG_Debug:
 451       #ifdef __WXDEBUG__
 452         #ifdef  __WIN32__
 453           OutputDebugString(szString);
 454           OutputDebugString("\n\r");
 455         #else   //!WIN32
 456           // send them to stderr
 457           fprintf(stderr, "%s: %s\n",
 458                   level == wxLOG_Trace ? _("Trace") : _("Debug"), szString);
 459           fflush(stderr);
 460         #endif  // WIN32
 461       #endif
 462       break;
 463
 464     case wxLOG_FatalError:
 465       // show this one immediately
 466       wxMessageBox(szString, _("Fatal error"), wxICON_HAND);
 467       break;
 468
 469     case wxLOG_Error:
 470     case wxLOG_Warning:
 471       // discard earlier informational messages if this is the 1st error
 472       if ( !m_bErrors ) {
 473         m_aMessages.Empty();
 474         m_bHasMessages = TRUE;
 475         m_bErrors = TRUE;
 476       }
 477
 478       m_aMessages.Add(szString);
 479       break;
 480
 481     default:
 482       wxFAIL_MSG("unknown log level in wxLogGui::DoLog");
 483   }
 484 }
 485
 486 // ----------------------------------------------------------------------------
 487 // wxLogWindow implementation
 488 // ----------------------------------------------------------------------------
 489
 490 // log frame class
 491 class wxLogFrame : public wxFrame
 492 {
 493 public:
 494   // ctor
 495   wxLogFrame(const char *szTitle);
 496
 497   // menu callbacks
 498   void OnClose(wxCommandEvent& event);
 499   void OnCloseWindow(wxCloseEvent& event);
 500   void OnSave (wxCommandEvent& event);
 501   void OnClear(wxCommandEvent& event);
 502
 503   // accessors
 504   wxTextCtrl *TextCtrl() const { return m_pTextCtrl; }
 505
 506 private:
 507   enum
 508   {
 509     Menu_Close = 100,
 510     Menu_Save,
 511     Menu_Clear
 512   };
 513
 514   wxTextCtrl *m_pTextCtrl;
 515
 516   DECLARE_EVENT_TABLE()
 517 };
 518
 519 BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
 520   // wxLogWindow menu events
 521   EVT_MENU(Menu_Close, wxLogFrame::OnClose)
 522   EVT_MENU(Menu_Save,  wxLogFrame::OnSave)
 523   EVT_MENU(Menu_Clear, wxLogFrame::OnClear)
 524
 525   EVT_CLOSE(wxLogFrame::OnCloseWindow)
 526 END_EVENT_TABLE()
 527
 528 wxLogFrame::wxLogFrame(const char *szTitle)
 529           : wxFrame(NULL, -1, szTitle)
 530 {
 531   // we don't want to be a top-level frame because it would prevent the
 532   // application termination when all other frames are closed
 533   wxTopLevelWindows.DeleteObject(this);
 534
 535   // @@ kludge: wxSIMPLE_BORDER is simply to prevent wxWindows from creating
 536   //    a rich edit control instead of a normal one we want
 537   m_pTextCtrl = new wxTextCtrl(this, -1, wxEmptyString, wxDefaultPosition,
 538                                wxDefaultSize,
 539                                wxSIMPLE_BORDER |
 540                                wxTE_MULTILINE  |
 541                                wxHSCROLL       |
 542                                wxTE_READONLY);
 543   /*
 544   m_pTextCtrl->SetEditable(FALSE);
 545   m_pTextCtrl->SetRichEdit(FALSE);
 546   */
 547
 548   // create menu
 549   wxMenuBar *pMenuBar = new wxMenuBar;
 550   wxMenu *pMenu = new wxMenu;
 551   pMenu->Append(Menu_Save,  "&Save...");
 552   pMenu->Append(Menu_Clear, "C&lear");
 553   pMenu->AppendSeparator();
 554   pMenu->Append(Menu_Close, "&Close");
 555   pMenuBar->Append(pMenu, "&Log");
 556   SetMenuBar(pMenuBar);
 557
 558   // @@ what about status bar? needed (for menu prompts)?
 559 }
 560
 561 void wxLogFrame::OnClose(wxCommandEvent& event)
 562 {
 563   // just hide the window
 564   Show(FALSE);
 565 }
 566
 567 void wxLogFrame::OnCloseWindow(wxCloseEvent& event)
 568 {
 569   // just hide the window
 570   Show(FALSE);
 571 }
 572
 573 void wxLogFrame::OnSave(wxCommandEvent& event)
 574 {
 575   // get the file name
 576   // -----------------
 577   const char *szFileName = wxSaveFileSelector("log", "txt", "log.txt");
 578   if ( szFileName == NULL ) {
 579     // cancelled
 580     return;
 581   }
 582
 583   // open file
 584   // ---------
 585   wxFile file;
 586   bool bOk;
 587   if ( wxFile::Exists(szFileName) ) {
 588     bool bAppend;
 589     wxString strMsg;
 590     strMsg.Printf(_("Append log to file '%s' "
 591                     "(choosing [No] will overwrite it)?"), szFileName);
 592     switch ( wxMessageBox(strMsg, "Question", wxYES_NO | wxCANCEL) ) {
 593       case wxYES:
 594         bAppend = TRUE;
 595         break;
 596
 597       case wxNO:
 598         bAppend = FALSE;
 599         break;
 600
 601       case wxCANCEL:
 602         return;
 603
 604       default:
 605         wxFAIL_MSG("invalid message box return value");
 606     }
 607
 608     if ( bAppend ) {
 609       bOk = file.Open(szFileName, wxFile::write_append);
 610     }
 611     else {
 612       bOk = file.Create(szFileName, TRUE /* overwrite */);
 613     }
 614   }
 615   else {
 616     bOk = file.Create(szFileName);
 617   }
 618
 619   // retrieve text and save it
 620   // -------------------------
 621 #ifdef __WXGTK__
 622   // @@@@ TODO: no GetNumberOfLines and GetLineText in wxGTK yet
 623   wxLogError("Sorry, this function is not implemented under GTK");
 624 #else
 625   int nLines = m_pTextCtrl->GetNumberOfLines();
 626   for ( int nLine = 0; bOk && nLine < nLines; nLine++ ) {
 627     bOk = file.Write(m_pTextCtrl->GetLineText(nLine) + wxTextFile::GetEOL());
 628   }
 629 #endif //GTK
 630
 631   if ( bOk )
 632     bOk = file.Close();
 633
 634   if ( !bOk ) {
 635     wxLogError(_("Can't save log contents to file."));
 636     return;
 637   }
 638 }
 639
 640 void wxLogFrame::OnClear(wxCommandEvent& event)
 641 {
 642   m_pTextCtrl->Clear();
 643 }
 644
 645 wxLogWindow::wxLogWindow(const char *szTitle, bool bShow)
 646 {
 647   m_pOldLog = wxLog::GetActiveTarget();
 648   m_pLogFrame = new wxLogFrame(szTitle);
 649
 650   if ( bShow )
 651     m_pLogFrame->Show(TRUE);
 652 }
 653
 654 void wxLogWindow::Show(bool bShow)
 655 {
 656   m_pLogFrame->Show(bShow);
 657 }
 658
 659 void wxLogWindow::DoLog(wxLogLevel level, const char *szString)
 660 {
 661   // first let the previous logger show it
 662   if ( m_pOldLog != NULL ) {
 663     // @@@ why can't we access protected wxLog method from here (we derive
 664     // from wxLog)? gcc gives "DoLog is protected in this context", what
 665     // does this mean? Anyhow, the cast is harmless and let's us do what
 666     // we want.
 667     ((wxLogWindow *)m_pOldLog)->DoLog(level, szString);
 668   }
 669
 670   // and this will format it nicely and call our DoLogString()
 671   wxLog::DoLog(level, szString);
 672 }
 673
 674 void wxLogWindow::DoLogString(const char *szString)
 675 {
 676   // put the text into our window
 677   wxTextCtrl *pText = m_pLogFrame->TextCtrl();
 678
 679   // remove selection (WriteText is in fact ReplaceSelection)
 680   #ifdef __WXMSW__
 681     long nLen = pText->GetLastPosition();
 682     pText->SetSelection(nLen, nLen);
 683   #endif // Windows
 684
 685   pText->WriteText(szString);
 686   pText->WriteText("\n"); // "\n" ok here (_not_ "\r\n")
 687
 688   // ensure that the line can be seen
 689   // @@@ TODO
 690 }
 691
 692 wxLogWindow::~wxLogWindow()
 693 {
 694   m_pLogFrame->Close(TRUE);
 695 }
 696
 697 #endif  //WX_TEST_MINIMAL
 698
 699 // ============================================================================
 700 // Global functions/variables
 701 // ============================================================================
 702
 703 // ----------------------------------------------------------------------------
 704 // static variables
 705 // ----------------------------------------------------------------------------
 706 wxLog      *wxLog::ms_pLogger      = NULL;
 707 bool        wxLog::ms_bInitialized = FALSE;
 708
 709 // ----------------------------------------------------------------------------
 710 // stdout error logging helper
 711 // ----------------------------------------------------------------------------
 712
 713 // helper function: wraps the message and justifies it under given position
 714 // (looks more pretty on the terminal). Also adds newline at the end.
 715 //
 716 // @@ this is now disabled until I find a portable way of determining the
 717 //    terminal window size (ok, I found it but does anybody really cares?)
 718 #ifdef    LOG_PRETTY_WRAP
 719 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
 720 {
 721   size_t nMax = 80; // @@@@
 722   size_t nStart = strlen(pszPrefix);
 723   fputs(pszPrefix, f);
 724
 725   size_t n;
 726   while ( *psz != '\0' ) {
 727     for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
 728       putc(*psz++, f);
 729
 730     // wrapped?
 731     if ( *psz != '\0' ) {
 732       /*putc('\n', f);*/
 733       for ( n = 0; n < nStart; n++ )
 734         putc(' ', f);
 735
 736       // as we wrapped, squeeze all white space
 737       while ( isspace(*psz) )
 738         psz++;
 739     }
 740   }
 741
 742   putc('\n', f);
 743 }
 744 #endif  //LOG_PRETTY_WRAP
 745
 746 // ----------------------------------------------------------------------------
 747 // error code/error message retrieval functions
 748 // ----------------------------------------------------------------------------
 749
 750 // get error code from syste
 751 unsigned long wxSysErrorCode()
 752 {
 753   #ifdef  __WXMSW__
 754     #ifdef  __WIN32__
 755       return ::GetLastError();
 756     #else   //WIN16
 757       // @@@@ what to do on Windows 3.1?
 758       return 0;
 759     #endif  //WIN16/32
 760   #else   //Unix
 761     return errno;
 762   #endif  //Win/Unix
 763 }
 764
 765 // get error message from system
 766 const char *wxSysErrorMsg(unsigned long nErrCode)
 767 {
 768   if ( nErrCode == 0 )
 769     nErrCode = wxSysErrorCode();
 770
 771   #ifdef  __WXMSW__
 772     #ifdef  __WIN32__
 773       static char s_szBuf[LOG_BUFFER_SIZE / 2];
 774
 775       // get error message from system
 776       LPVOID lpMsgBuf;
 777       FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 778                     NULL, nErrCode,
 779                     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 780                     (LPTSTR)&lpMsgBuf,
 781                     0, NULL);
 782
 783       // copy it to our buffer and free memory
 784       strncpy(s_szBuf, (const char *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
 785       s_szBuf[WXSIZEOF(s_szBuf) - 1] = '\0';
 786       LocalFree(lpMsgBuf);
 787
 788       // returned string is capitalized and ended with '\r\n' - bad
 789       s_szBuf[0] = (char)tolower(s_szBuf[0]);
 790       size_t len = strlen(s_szBuf);
 791       if ( len > 0 ) {
 792         // truncate string
 793         if ( s_szBuf[len - 2] == '\r' )
 794           s_szBuf[len - 2] = '\0';
 795       }
 796
 797       return s_szBuf;
 798     #else   //Win16
 799       // TODO @@@@
 800       return NULL;
 801     #endif // Win16/32
 802   #else   // Unix
 803     return strerror(nErrCode);
 804   #endif  // Win/Unix
 805 }
 806
 807 // ----------------------------------------------------------------------------
 808 // debug helper
 809 // ----------------------------------------------------------------------------
 810
 811 #ifdef  __WXDEBUG__
 812
 813 void Trap()
 814 {
 815   #ifdef __WXMSW__
 816     DebugBreak();
 817   #else // Unix
 818     raise(SIGTRAP);
 819   #endif // Win/Unix
 820 }
 821
 822 // this function is called when an assert fails
 823 void wxOnAssert(const char *szFile, int nLine, const char *szMsg)
 824 {
 825   // this variable can be set to true to suppress "assert failure" messages
 826   static bool s_bNoAsserts = FALSE;
 827   static bool s_bInAssert = FALSE;
 828
 829   if ( s_bInAssert ) {
 830     // He-e-e-e-elp!! we're trapped in endless loop
 831     Trap();
 832   }
 833
 834   s_bInAssert = TRUE;
 835
 836   char szBuf[LOG_BUFFER_SIZE];
 837   sprintf(szBuf, _("Assert failed in file %s at line %d"), szFile, nLine);
 838   if ( szMsg != NULL ) {
 839     strcat(szBuf, ": ");
 840     strcat(szBuf, szMsg);
 841   }
 842   else {
 843     strcat(szBuf, ".");
 844   }
 845
 846   if ( !s_bNoAsserts ) {
 847     // send it to the normal log destination
 848     wxLogDebug(szBuf);
 849
 850     strcat(szBuf, _("\nDo you want to stop the program?"
 851                     "\nYou can also choose [Cancel] to suppress "
 852                     "further warnings."));
 853
 854     switch ( wxMessageBox(szBuf, _("Debug"),
 855                           wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
 856       case wxYES:
 857         Trap();
 858         break;
 859
 860       case wxCANCEL:
 861         s_bNoAsserts = TRUE;
 862         break;
 863
 864       //case wxNO: nothing to do
 865     }
 866   }
 867
 868   s_bInAssert = FALSE;
 869 }
 870
 871 #endif  //WXDEBUG
 872