]> git.saurik.com Git - wxWidgets.git/blob - src/common/log.cpp
wxLogTrace doesn't give messages with two 'Trace' in the beginning
[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
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 #ifdef __WXMSW__
40 #include "wx/msw/private.h"
41 #endif
42 #include "wx/msgdlg.h"
43 #endif
44 #endif //WX_PRECOMP
45
46 #include "wx/file.h"
47 #include "wx/textfile.h"
48 #include "wx/utils.h"
49 #include "wx/wxchar.h"
50 #include "wx/log.h"
51 #include "wx/thread.h"
52
53 // other standard headers
54 #include <errno.h>
55 #include <stdlib.h>
56 #include <time.h>
57
58 #ifdef __WXMSW__
59 #include "wx/msw/private.h" // includes windows.h for OutputDebugString
60 #else //Unix
61 #include <signal.h>
62 #endif //Win/Unix
63
64 // ----------------------------------------------------------------------------
65 // non member functions
66 // ----------------------------------------------------------------------------
67
68 // define this to enable wrapping of log messages
69 //#define LOG_PRETTY_WRAP
70
71 #ifdef LOG_PRETTY_WRAP
72 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
73 #endif
74
75 // ============================================================================
76 // implementation
77 // ============================================================================
78
79 // ----------------------------------------------------------------------------
80 // globals
81 // ----------------------------------------------------------------------------
82
83 // log functions can't allocate memory (LogError("out of memory...") should
84 // work!), so we use a static buffer for all log messages
85 #define LOG_BUFFER_SIZE (4096)
86
87 // static buffer for error messages
88 static wxChar s_szBuf[LOG_BUFFER_SIZE];
89
90 #if wxUSE_THREADS
91
92 // the critical section protecting the static buffer
93 static wxCriticalSection gs_csLogBuf;
94
95 #endif // wxUSE_THREADS
96
97 // ----------------------------------------------------------------------------
98 // implementation of Log functions
99 //
100 // NB: unfortunately we need all these distinct functions, we can't make them
101 // macros and not all compilers inline vararg functions.
102 // ----------------------------------------------------------------------------
103
104 // generic log function
105 void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
106 {
107 if ( wxLog::GetActiveTarget() != NULL ) {
108 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
109
110 va_list argptr;
111 va_start(argptr, szFormat);
112 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
113 va_end(argptr);
114
115 wxLog::OnLog(level, s_szBuf, time(NULL));
116 }
117 }
118
119 #define IMPLEMENT_LOG_FUNCTION(level) \
120 void wxLog##level(const wxChar *szFormat, ...) \
121 { \
122 if ( wxLog::GetActiveTarget() != NULL ) { \
123 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
124 \
125 va_list argptr; \
126 va_start(argptr, szFormat); \
127 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr); \
128 va_end(argptr); \
129 \
130 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
131 } \
132 }
133
134 IMPLEMENT_LOG_FUNCTION(FatalError)
135 IMPLEMENT_LOG_FUNCTION(Error)
136 IMPLEMENT_LOG_FUNCTION(Warning)
137 IMPLEMENT_LOG_FUNCTION(Message)
138 IMPLEMENT_LOG_FUNCTION(Info)
139 IMPLEMENT_LOG_FUNCTION(Status)
140
141 // same as info, but only if 'verbose' mode is on
142 void wxLogVerbose(const wxChar *szFormat, ...)
143 {
144 wxLog *pLog = wxLog::GetActiveTarget();
145 if ( pLog != NULL && pLog->GetVerbose() ) {
146 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
147
148 va_list argptr;
149 va_start(argptr, szFormat);
150 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
151 va_end(argptr);
152
153 wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
154 }
155 }
156
157 // debug functions
158 #ifdef __WXDEBUG__
159 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
160 void wxLog##level(const wxChar *szFormat, ...) \
161 { \
162 if ( wxLog::GetActiveTarget() != NULL ) { \
163 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
164 \
165 va_list argptr; \
166 va_start(argptr, szFormat); \
167 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr); \
168 va_end(argptr); \
169 \
170 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
171 } \
172 }
173
174 void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
175 {
176 wxLog *pLog = wxLog::GetActiveTarget();
177
178 if ( pLog != NULL && wxLog::IsAllowedTraceMask(mask) ) {
179 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
180
181 wxChar *p = s_szBuf;
182 size_t len = WXSIZEOF(s_szBuf);
183 strncpy(s_szBuf, _T("("), len);
184 len -= 2; // strlen("(")
185 p += 2;
186 strncat(p, mask, len);
187 size_t lenMask = wxStrlen(mask);
188 len -= lenMask;
189 p += lenMask;
190
191 strncat(p, _T("): "), len);
192 len -= 3;
193 p += 3;
194
195 va_list argptr;
196 va_start(argptr, szFormat);
197 wxVsnprintf(p, len, szFormat, argptr);
198 va_end(argptr);
199
200 wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
201 }
202 }
203
204 void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
205 {
206 wxLog *pLog = wxLog::GetActiveTarget();
207
208 // we check that all of mask bits are set in the current mask, so
209 // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
210 // if both bits are set.
211 if ( pLog != NULL && ((pLog->GetTraceMask() & mask) == mask) ) {
212 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
213
214 va_list argptr;
215 va_start(argptr, szFormat);
216 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
217 va_end(argptr);
218
219 wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
220 }
221 }
222
223 #else // release
224 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
225 #endif
226
227 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
228 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
229
230 // wxLogSysError: one uses the last error code, for other you must give it
231 // explicitly
232
233 // common part of both wxLogSysError
234 void wxLogSysErrorHelper(long lErrCode)
235 {
236 wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
237 wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
238 _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
239 wxStrncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - wxStrlen(s_szBuf));
240
241 wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
242 }
243
244 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
245 {
246 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
247
248 va_list argptr;
249 va_start(argptr, szFormat);
250 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
251 va_end(argptr);
252
253 wxLogSysErrorHelper(wxSysErrorCode());
254 }
255
256 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
257 {
258 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
259
260 va_list argptr;
261 va_start(argptr, szFormat);
262 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
263 va_end(argptr);
264
265 wxLogSysErrorHelper(lErrCode);
266 }
267
268 // ----------------------------------------------------------------------------
269 // wxLog class implementation
270 // ----------------------------------------------------------------------------
271
272 wxLog::wxLog()
273 {
274 m_bHasMessages = FALSE;
275
276 // enable verbose messages by default in the debug builds
277 #ifdef __WXDEBUG__
278 m_bVerbose = TRUE;
279 #else // release
280 m_bVerbose = FALSE;
281 #endif // debug/release
282 }
283
284 wxLog *wxLog::GetActiveTarget()
285 {
286 if ( ms_bAutoCreate && ms_pLogger == NULL ) {
287 // prevent infinite recursion if someone calls wxLogXXX() from
288 // wxApp::CreateLogTarget()
289 static bool s_bInGetActiveTarget = FALSE;
290 if ( !s_bInGetActiveTarget ) {
291 s_bInGetActiveTarget = TRUE;
292
293 // ask the application to create a log target for us
294 if ( wxTheApp != NULL )
295 ms_pLogger = wxTheApp->CreateLogTarget();
296 else
297 ms_pLogger = new wxLogStderr;
298
299 s_bInGetActiveTarget = FALSE;
300
301 // do nothing if it fails - what can we do?
302 }
303 }
304
305 return ms_pLogger;
306 }
307
308 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
309 {
310 if ( ms_pLogger != NULL ) {
311 // flush the old messages before changing because otherwise they might
312 // get lost later if this target is not restored
313 ms_pLogger->Flush();
314 }
315
316 wxLog *pOldLogger = ms_pLogger;
317 ms_pLogger = pLogger;
318
319 return pOldLogger;
320 }
321
322 void wxLog::RemoveTraceMask(const wxString& str)
323 {
324 int index = ms_aTraceMasks.Index(str);
325 if ( index != wxNOT_FOUND )
326 ms_aTraceMasks.Remove((size_t)index);
327 }
328
329 void wxLog::TimeStamp(wxString *str)
330 {
331 if ( ms_timestamp )
332 {
333 wxChar buf[256];
334 time_t timeNow;
335 (void)time(&timeNow);
336 wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
337
338 str->Empty();
339 *str << buf << wxT(": ");
340 }
341 }
342
343 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
344 {
345 switch ( level ) {
346 case wxLOG_FatalError:
347 DoLogString(wxString(_("Fatal error: ")) + szString, t);
348 DoLogString(_("Program aborted."), t);
349 Flush();
350 abort();
351 break;
352
353 case wxLOG_Error:
354 DoLogString(wxString(_("Error: ")) + szString, t);
355 break;
356
357 case wxLOG_Warning:
358 DoLogString(wxString(_("Warning: ")) + szString, t);
359 break;
360
361 case wxLOG_Info:
362 if ( GetVerbose() )
363 case wxLOG_Message:
364 case wxLOG_Status:
365 default: // log unknown log levels too
366 DoLogString(szString, t);
367 break;
368
369 case wxLOG_Trace:
370 case wxLOG_Debug:
371 #ifdef __WXDEBUG__
372 {
373 wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
374 : wxT("Debug: "),
375 msg << szString;
376 DoLogString(msg, t);
377 }
378 #endif // Debug
379 break;
380 }
381 }
382
383 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
384 {
385 wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
386 }
387
388 void wxLog::Flush()
389 {
390 // do nothing
391 }
392
393 // ----------------------------------------------------------------------------
394 // wxLogStderr class implementation
395 // ----------------------------------------------------------------------------
396
397 wxLogStderr::wxLogStderr(FILE *fp)
398 {
399 if ( fp == NULL )
400 m_fp = stderr;
401 else
402 m_fp = fp;
403 }
404
405 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
406 {
407 wxString str;
408 TimeStamp(&str);
409 str << szString;
410
411 fputs(str.mb_str(), m_fp);
412 fputc(_T('\n'), m_fp);
413 fflush(m_fp);
414
415 // under Windows, programs usually don't have stderr at all, so show the
416 // messages also under debugger - unless it's a console program
417 #if defined(__WXMSW__) && wxUSE_GUI
418 OutputDebugString(str + wxT("\r\n"));
419 #endif // MSW
420 #if defined(__WXMAC__) && wxUSE_GUI
421 debugstr(str + wxT("\r\n"));
422 #endif // MSW
423 }
424
425 // ----------------------------------------------------------------------------
426 // wxLogStream implementation
427 // ----------------------------------------------------------------------------
428
429 #if wxUSE_STD_IOSTREAM
430 wxLogStream::wxLogStream(ostream *ostr)
431 {
432 if ( ostr == NULL )
433 m_ostr = &cerr;
434 else
435 m_ostr = ostr;
436 }
437
438 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
439 {
440 (*m_ostr) << wxConvertWX2MB(szString) << endl;
441 }
442 #endif // wxUSE_STD_IOSTREAM
443
444 // ============================================================================
445 // Global functions/variables
446 // ============================================================================
447
448 // ----------------------------------------------------------------------------
449 // static variables
450 // ----------------------------------------------------------------------------
451
452 wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
453 bool wxLog::ms_doLog = TRUE;
454 bool wxLog::ms_bAutoCreate = TRUE;
455
456 size_t wxLog::ms_suspendCount = 0;
457
458 #if wxUSE_GUI
459 const wxChar *wxLog::ms_timestamp = wxT("%X"); // time only, no date
460 #else
461 const wxChar *wxLog::ms_timestamp = NULL; // save space
462 #endif
463
464 wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
465 wxArrayString wxLog::ms_aTraceMasks;
466
467 // ----------------------------------------------------------------------------
468 // stdout error logging helper
469 // ----------------------------------------------------------------------------
470
471 // helper function: wraps the message and justifies it under given position
472 // (looks more pretty on the terminal). Also adds newline at the end.
473 //
474 // TODO this is now disabled until I find a portable way of determining the
475 // terminal window size (ok, I found it but does anybody really cares?)
476 #ifdef LOG_PRETTY_WRAP
477 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
478 {
479 size_t nMax = 80; // FIXME
480 size_t nStart = strlen(pszPrefix);
481 fputs(pszPrefix, f);
482
483 size_t n;
484 while ( *psz != '\0' ) {
485 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
486 putc(*psz++, f);
487
488 // wrapped?
489 if ( *psz != '\0' ) {
490 /*putc('\n', f);*/
491 for ( n = 0; n < nStart; n++ )
492 putc(' ', f);
493
494 // as we wrapped, squeeze all white space
495 while ( isspace(*psz) )
496 psz++;
497 }
498 }
499
500 putc('\n', f);
501 }
502 #endif //LOG_PRETTY_WRAP
503
504 // ----------------------------------------------------------------------------
505 // error code/error message retrieval functions
506 // ----------------------------------------------------------------------------
507
508 // get error code from syste
509 unsigned long wxSysErrorCode()
510 {
511 #ifdef __WXMSW__
512 #ifdef __WIN32__
513 return ::GetLastError();
514 #else //WIN16
515 // TODO what to do on Windows 3.1?
516 return 0;
517 #endif //WIN16/32
518 #else //Unix
519 return errno;
520 #endif //Win/Unix
521 }
522
523 // get error message from system
524 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
525 {
526 if ( nErrCode == 0 )
527 nErrCode = wxSysErrorCode();
528
529 #ifdef __WXMSW__
530 #ifdef __WIN32__
531 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
532
533 // get error message from system
534 LPVOID lpMsgBuf;
535 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
536 NULL, nErrCode,
537 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
538 (LPTSTR)&lpMsgBuf,
539 0, NULL);
540
541 // copy it to our buffer and free memory
542 wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
543 s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
544 LocalFree(lpMsgBuf);
545
546 // returned string is capitalized and ended with '\r\n' - bad
547 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
548 size_t len = wxStrlen(s_szBuf);
549 if ( len > 0 ) {
550 // truncate string
551 if ( s_szBuf[len - 2] == wxT('\r') )
552 s_szBuf[len - 2] = wxT('\0');
553 }
554
555 return s_szBuf;
556 #else //Win16
557 // TODO
558 return NULL;
559 #endif // Win16/32
560 #else // Unix
561 #if wxUSE_UNICODE
562 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
563 wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
564 return s_szBuf;
565 #else
566 return strerror((int)nErrCode);
567 #endif
568 #endif // Win/Unix
569 }
570
571 // ----------------------------------------------------------------------------
572 // debug helper
573 // ----------------------------------------------------------------------------
574
575 #ifdef __WXDEBUG__
576
577 // break into the debugger
578 void Trap()
579 {
580 #ifdef __WXMSW__
581 DebugBreak();
582 #elif defined(__WXMAC__)
583 #if __powerc
584 Debugger();
585 #else
586 SysBreak();
587 #endif
588 #elif defined(__UNIX__)
589 raise(SIGTRAP);
590 #else
591 // TODO
592 #endif // Win/Unix
593 }
594
595 // this function is called when an assert fails
596 void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
597 {
598 // this variable can be set to true to suppress "assert failure" messages
599 static bool s_bNoAsserts = FALSE;
600 static bool s_bInAssert = FALSE; // FIXME MT-unsafe
601
602 if ( s_bInAssert ) {
603 // He-e-e-e-elp!! we're trapped in endless loop
604 Trap();
605
606 s_bInAssert = FALSE;
607
608 return;
609 }
610
611 s_bInAssert = TRUE;
612
613 wxChar szBuf[LOG_BUFFER_SIZE];
614
615 // make life easier for people using VC++ IDE: clicking on the message
616 // will take us immediately to the place of the failed assert
617 wxSnprintf(szBuf, WXSIZEOF(szBuf),
618 #ifdef __VISUALC__
619 wxT("%s(%d): assert failed"),
620 #else // !VC++
621 // make the error message more clear for all the others
622 wxT("Assert failed in file %s at line %d"),
623 #endif // VC/!VC
624 szFile, nLine);
625
626 if ( szMsg != NULL ) {
627 wxStrcat(szBuf, wxT(": "));
628 wxStrcat(szBuf, szMsg);
629 }
630 else {
631 wxStrcat(szBuf, wxT("."));
632 }
633
634 if ( !s_bNoAsserts ) {
635 // send it to the normal log destination
636 wxLogDebug(szBuf);
637
638 #if wxUSE_GUI || defined(__WXMSW__)
639 // this message is intentionally not translated - it is for
640 // developpers only
641 wxStrcat(szBuf, wxT("\nDo you want to stop the program?"
642 "\nYou can also choose [Cancel] to suppress "
643 "further warnings."));
644
645 #if wxUSE_GUI
646 switch ( wxMessageBox(szBuf, "Debug",
647 wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
648 case wxYES:
649 Trap();
650 break;
651
652 case wxCANCEL:
653 s_bNoAsserts = TRUE;
654 break;
655
656 //case wxNO: nothing to do
657 }
658 #else // !GUI, but MSW
659 switch ( ::MessageBox(NULL, szBuf, "Debug",
660 MB_YESNOCANCEL | MB_ICONSTOP ) ) {
661 case IDYES:
662 Trap();
663 break;
664
665 case IDCANCEL:
666 s_bNoAsserts = TRUE;
667 break;
668
669 //case IDNO: nothing to do
670 }
671 #endif // GUI or MSW
672
673 #else // !GUI
674 Trap();
675 #endif // GUI/!GUI
676 }
677
678 s_bInAssert = FALSE;
679 }
680
681 #endif //WXDEBUG
682