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