]> git.saurik.com Git - wxWidgets.git/blob - src/common/log.cpp
add MutexGuiEnter/Leave to wxAppTraits, integrate native GTK+ GUI locking
[wxWidgets.git] / src / common / log.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/log.cpp
3 // Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_LOG
28
29 // wxWidgets
30 #ifndef WX_PRECOMP
31 #include "wx/log.h"
32 #include "wx/app.h"
33 #include "wx/arrstr.h"
34 #include "wx/intl.h"
35 #include "wx/string.h"
36 #include "wx/utils.h"
37 #endif //WX_PRECOMP
38
39 #include "wx/apptrait.h"
40 #include "wx/datetime.h"
41 #include "wx/file.h"
42 #include "wx/msgout.h"
43 #include "wx/textfile.h"
44 #include "wx/thread.h"
45 #include "wx/crt.h"
46
47 // other standard headers
48 #ifndef __WXWINCE__
49 #include <errno.h>
50 #endif
51
52 #include <stdlib.h>
53
54 #ifndef __WXWINCE__
55 #include <time.h>
56 #else
57 #include "wx/msw/wince/time.h"
58 #endif
59
60 #if defined(__WINDOWS__)
61 #include "wx/msw/private.h" // includes windows.h
62 #endif
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 // implementation of Log functions
81 //
82 // NB: unfortunately we need all these distinct functions, we can't make them
83 // macros and not all compilers inline vararg functions.
84 // ----------------------------------------------------------------------------
85
86 // generic log function
87 void wxVLogGeneric(wxLogLevel level, const wxString& format, va_list argptr)
88 {
89 if ( wxLog::IsEnabled() ) {
90 wxLog::OnLog(level, wxString::FormatV(format, argptr), time(NULL));
91 }
92 }
93
94 #if !wxUSE_UTF8_LOCALE_ONLY
95 void wxDoLogGenericWchar(wxLogLevel level, const wxChar *format, ...)
96 {
97 va_list argptr;
98 va_start(argptr, format);
99 wxVLogGeneric(level, format, argptr);
100 va_end(argptr);
101 }
102 #endif // wxUSE_UTF8_LOCALE_ONLY
103
104 #if wxUSE_UNICODE_UTF8
105 void wxDoLogGenericUtf8(wxLogLevel level, const char *format, ...)
106 {
107 va_list argptr;
108 va_start(argptr, format);
109 wxVLogGeneric(level, format, argptr);
110 va_end(argptr);
111 }
112 #endif // wxUSE_UNICODE_UTF8
113
114 #if !wxUSE_UTF8_LOCALE_ONLY
115 #define IMPLEMENT_LOG_FUNCTION_WCHAR(level) \
116 void wxDoLog##level##Wchar(const wxChar *format, ...) \
117 { \
118 va_list argptr; \
119 va_start(argptr, format); \
120 wxVLog##level(format, argptr); \
121 va_end(argptr); \
122 }
123 #else
124 #define IMPLEMENT_LOG_FUNCTION_WCHAR(level)
125 #endif
126
127 #if wxUSE_UNICODE_UTF8
128 #define IMPLEMENT_LOG_FUNCTION_UTF8(level) \
129 void wxDoLog##level##Utf8(const char *format, ...) \
130 { \
131 va_list argptr; \
132 va_start(argptr, format); \
133 wxVLog##level(format, argptr); \
134 va_end(argptr); \
135 }
136 #else
137 #define IMPLEMENT_LOG_FUNCTION_UTF8(level)
138 #endif
139
140 #define IMPLEMENT_LOG_FUNCTION(level) \
141 void wxVLog##level(const wxString& format, va_list argptr) \
142 { \
143 if ( wxLog::IsEnabled() ) { \
144 wxLog::OnLog(wxLOG_##level, \
145 wxString::FormatV(format, argptr), time(NULL)); \
146 } \
147 } \
148 IMPLEMENT_LOG_FUNCTION_WCHAR(level) \
149 IMPLEMENT_LOG_FUNCTION_UTF8(level)
150
151 IMPLEMENT_LOG_FUNCTION(Error)
152 IMPLEMENT_LOG_FUNCTION(Warning)
153 IMPLEMENT_LOG_FUNCTION(Message)
154 IMPLEMENT_LOG_FUNCTION(Info)
155 IMPLEMENT_LOG_FUNCTION(Status)
156
157 void wxSafeShowMessage(const wxString& title, const wxString& text)
158 {
159 #ifdef __WINDOWS__
160 ::MessageBox(NULL, text.wx_str(), title.wx_str(), MB_OK | MB_ICONSTOP);
161 #else
162 wxFprintf(stderr, _T("%s: %s\n"), title.c_str(), text.c_str());
163 fflush(stderr);
164 #endif
165 }
166
167 // fatal errors can't be suppressed nor handled by the custom log target and
168 // always terminate the program
169 void wxVLogFatalError(const wxString& format, va_list argptr)
170 {
171 wxSafeShowMessage(_T("Fatal Error"), wxString::FormatV(format, argptr));
172
173 #ifdef __WXWINCE__
174 ExitThread(3);
175 #else
176 abort();
177 #endif
178 }
179
180 #if !wxUSE_UTF8_LOCALE_ONLY
181 void wxDoLogFatalErrorWchar(const wxChar *format, ...)
182 {
183 va_list argptr;
184 va_start(argptr, format);
185 wxVLogFatalError(format, argptr);
186
187 // some compilers warn about unreachable code and it shouldn't matter
188 // for the others anyhow...
189 //va_end(argptr);
190 }
191 #endif // wxUSE_UTF8_LOCALE_ONLY
192
193 #if wxUSE_UNICODE_UTF8
194 void wxDoLogFatalErrorUtf8(const char *format, ...)
195 {
196 va_list argptr;
197 va_start(argptr, format);
198 wxVLogFatalError(format, argptr);
199
200 // some compilers warn about unreachable code and it shouldn't matter
201 // for the others anyhow...
202 //va_end(argptr);
203 }
204 #endif // wxUSE_UNICODE_UTF8
205
206 // same as info, but only if 'verbose' mode is on
207 void wxVLogVerbose(const wxString& format, va_list argptr)
208 {
209 if ( wxLog::IsEnabled() ) {
210 if ( wxLog::GetActiveTarget() != NULL && wxLog::GetVerbose() ) {
211 wxLog::OnLog(wxLOG_Info,
212 wxString::FormatV(format, argptr), time(NULL));
213 }
214 }
215 }
216
217 #if !wxUSE_UTF8_LOCALE_ONLY
218 void wxDoLogVerboseWchar(const wxChar *format, ...)
219 {
220 va_list argptr;
221 va_start(argptr, format);
222 wxVLogVerbose(format, argptr);
223 va_end(argptr);
224 }
225 #endif // !wxUSE_UTF8_LOCALE_ONLY
226
227 #if wxUSE_UNICODE_UTF8
228 void wxDoLogVerboseUtf8(const char *format, ...)
229 {
230 va_list argptr;
231 va_start(argptr, format);
232 wxVLogVerbose(format, argptr);
233 va_end(argptr);
234 }
235 #endif // wxUSE_UNICODE_UTF8
236
237 // debug functions
238 #ifdef __WXDEBUG__
239
240 #if !wxUSE_UTF8_LOCALE_ONLY
241 #define IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \
242 void wxDoLog##level##Wchar(const wxChar *format, ...) \
243 { \
244 va_list argptr; \
245 va_start(argptr, format); \
246 wxVLog##level(format, argptr); \
247 va_end(argptr); \
248 }
249 #else
250 #define IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level)
251 #endif
252
253 #if wxUSE_UNICODE_UTF8
254 #define IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level) \
255 void wxDoLog##level##Utf8(const char *format, ...) \
256 { \
257 va_list argptr; \
258 va_start(argptr, format); \
259 wxVLog##level(format, argptr); \
260 va_end(argptr); \
261 }
262 #else
263 #define IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level)
264 #endif
265
266 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
267 void wxVLog##level(const wxString& format, va_list argptr) \
268 { \
269 if ( wxLog::IsEnabled() ) { \
270 wxLog::OnLog(wxLOG_##level, \
271 wxString::FormatV(format, argptr), time(NULL)); \
272 } \
273 } \
274 IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \
275 IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level)
276
277
278 void wxVLogTrace(const wxString& mask, const wxString& format, va_list argptr)
279 {
280 if ( wxLog::IsEnabled() && wxLog::IsAllowedTraceMask(mask) ) {
281 wxString msg;
282 msg << _T("(") << mask << _T(") ") << wxString::FormatV(format, argptr);
283
284 wxLog::OnLog(wxLOG_Trace, msg, time(NULL));
285 }
286 }
287
288 #if !wxUSE_UTF8_LOCALE_ONLY
289 void wxDoLogTraceWchar(const wxString& mask, const wxChar *format, ...)
290 {
291 va_list argptr;
292 va_start(argptr, format);
293 wxVLogTrace(mask, format, argptr);
294 va_end(argptr);
295 }
296 #endif // !wxUSE_UTF8_LOCALE_ONLY
297
298 #if wxUSE_UNICODE_UTF8
299 void wxDoLogTraceUtf8(const wxString& mask, const char *format, ...)
300 {
301 va_list argptr;
302 va_start(argptr, format);
303 wxVLogTrace(mask, format, argptr);
304 va_end(argptr);
305 }
306 #endif // wxUSE_UNICODE_UTF8
307
308 void wxVLogTrace(wxTraceMask mask, const wxString& format, va_list argptr)
309 {
310 // we check that all of mask bits are set in the current mask, so
311 // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
312 // if both bits are set.
313 if ( wxLog::IsEnabled() && ((wxLog::GetTraceMask() & mask) == mask) ) {
314 wxLog::OnLog(wxLOG_Trace, wxString::FormatV(format, argptr), time(NULL));
315 }
316 }
317
318 #if !wxUSE_UTF8_LOCALE_ONLY
319 void wxDoLogTraceWchar(wxTraceMask mask, const wxChar *format, ...)
320 {
321 va_list argptr;
322 va_start(argptr, format);
323 wxVLogTrace(mask, format, argptr);
324 va_end(argptr);
325 }
326 #endif // !wxUSE_UTF8_LOCALE_ONLY
327
328 #if wxUSE_UNICODE_UTF8
329 void wxDoLogTraceUtf8(wxTraceMask mask, const char *format, ...)
330 {
331 va_list argptr;
332 va_start(argptr, format);
333 wxVLogTrace(mask, format, argptr);
334 va_end(argptr);
335 }
336 #endif // wxUSE_UNICODE_UTF8
337
338 #ifdef __WATCOMC__
339 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
340 void wxDoLogTraceWchar(int mask, const wxChar *format, ...)
341 {
342 va_list argptr;
343 va_start(argptr, format);
344 wxVLogTrace(mask, format, argptr);
345 va_end(argptr);
346 }
347
348 void wxDoLogTraceWchar(const char *mask, const wxChar *format, ...)
349 {
350 va_list argptr;
351 va_start(argptr, format);
352 wxVLogTrace(mask, format, argptr);
353 va_end(argptr);
354 }
355
356 void wxDoLogTraceWchar(const wchar_t *mask, const wxChar *format, ...)
357 {
358 va_list argptr;
359 va_start(argptr, format);
360 wxVLogTrace(mask, format, argptr);
361 va_end(argptr);
362 }
363
364 void wxVLogTrace(int mask, const wxString& format, va_list argptr)
365 { wxVLogTrace((wxTraceMask)mask, format, argptr); }
366 void wxVLogTrace(const char *mask, const wxString& format, va_list argptr)
367 { wxVLogTrace(wxString(mask), format, argptr); }
368 void wxVLogTrace(const wchar_t *mask, const wxString& format, va_list argptr)
369 { wxVLogTrace(wxString(mask), format, argptr); }
370 #endif // __WATCOMC__
371
372 #else // release
373 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
374 #endif
375
376 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
377 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
378
379 // wxLogSysError: one uses the last error code, for other you must give it
380 // explicitly
381
382 // return the system error message description
383 static inline wxString wxLogSysErrorHelper(long err)
384 {
385 return wxString::Format(_(" (error %ld: %s)"), err, wxSysErrorMsg(err));
386 }
387
388 void WXDLLIMPEXP_BASE wxVLogSysError(const wxString& format, va_list argptr)
389 {
390 wxVLogSysError(wxSysErrorCode(), format, argptr);
391 }
392
393 #if !wxUSE_UTF8_LOCALE_ONLY
394 void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(const wxChar *format, ...)
395 {
396 va_list argptr;
397 va_start(argptr, format);
398 wxVLogSysError(format, argptr);
399 va_end(argptr);
400 }
401 #endif // !wxUSE_UTF8_LOCALE_ONLY
402
403 #if wxUSE_UNICODE_UTF8
404 void WXDLLIMPEXP_BASE wxDoLogSysErrorUtf8(const char *format, ...)
405 {
406 va_list argptr;
407 va_start(argptr, format);
408 wxVLogSysError(format, argptr);
409 va_end(argptr);
410 }
411 #endif // wxUSE_UNICODE_UTF8
412
413 void WXDLLIMPEXP_BASE wxVLogSysError(long err, const wxString& format, va_list argptr)
414 {
415 if ( wxLog::IsEnabled() ) {
416 wxLog::OnLog(wxLOG_Error,
417 wxString::FormatV(format, argptr) + wxLogSysErrorHelper(err),
418 time(NULL));
419 }
420 }
421
422 #if !wxUSE_UTF8_LOCALE_ONLY
423 void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(long lErrCode, const wxChar *format, ...)
424 {
425 va_list argptr;
426 va_start(argptr, format);
427 wxVLogSysError(lErrCode, format, argptr);
428 va_end(argptr);
429 }
430 #endif // !wxUSE_UTF8_LOCALE_ONLY
431
432 #if wxUSE_UNICODE_UTF8
433 void WXDLLIMPEXP_BASE wxDoLogSysErrorUtf8(long lErrCode, const char *format, ...)
434 {
435 va_list argptr;
436 va_start(argptr, format);
437 wxVLogSysError(lErrCode, format, argptr);
438 va_end(argptr);
439 }
440 #endif // wxUSE_UNICODE_UTF8
441
442 #ifdef __WATCOMC__
443 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
444 void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(unsigned long lErrCode, const wxChar *format, ...)
445 {
446 va_list argptr;
447 va_start(argptr, format);
448 wxVLogSysError(lErrCode, format, argptr);
449 va_end(argptr);
450 }
451
452 void WXDLLIMPEXP_BASE wxVLogSysError(unsigned long err, const wxString& format, va_list argptr)
453 { wxVLogSysError((long)err, format, argptr); }
454 #endif // __WATCOMC__
455
456 // ----------------------------------------------------------------------------
457 // wxLog class implementation
458 // ----------------------------------------------------------------------------
459
460 unsigned wxLog::LogLastRepetitionCountIfNeeded()
461 {
462 wxCRIT_SECT_LOCKER(lock, ms_prevCS);
463
464 const unsigned count = ms_prevCounter;
465
466 if ( ms_prevCounter )
467 {
468 wxString msg;
469 #if wxUSE_INTL
470 msg.Printf(wxPLURAL("The previous message repeated once.",
471 "The previous message repeated %lu times.",
472 ms_prevCounter),
473 ms_prevCounter);
474 #else
475 msg.Printf(wxT("The previous message was repeated %lu times."),
476 ms_prevCounter);
477 #endif
478 ms_prevCounter = 0;
479 ms_prevString.clear();
480 DoLog(ms_prevLevel, msg, ms_prevTimeStamp);
481 }
482
483 return count;
484 }
485
486 wxLog::~wxLog()
487 {
488 LogLastRepetitionCountIfNeeded();
489 }
490
491 /* static */
492 void wxLog::OnLog(wxLogLevel level, const wxString& szString, time_t t)
493 {
494 if ( IsEnabled() && ms_logLevel >= level )
495 {
496 wxLog *pLogger = GetActiveTarget();
497 if ( pLogger )
498 {
499 if ( GetRepetitionCounting() )
500 {
501 wxCRIT_SECT_LOCKER(lock, ms_prevCS);
502
503 if ( szString == ms_prevString )
504 {
505 ms_prevCounter++;
506
507 // nothing else to do, in particular, don't log the
508 // repeated message
509 return;
510 }
511
512 pLogger->LogLastRepetitionCountIfNeeded();
513
514 // reset repetition counter for a new message
515 ms_prevString = szString;
516 ms_prevLevel = level;
517 ms_prevTimeStamp = t;
518 }
519
520 pLogger->DoLog(level, szString, t);
521 }
522 }
523 }
524
525 // deprecated function
526 #if WXWIN_COMPATIBILITY_2_6
527
528 wxChar *wxLog::SetLogBuffer(wxChar * WXUNUSED(buf), size_t WXUNUSED(size))
529 {
530 return NULL;
531 }
532
533 #endif // WXWIN_COMPATIBILITY_2_6
534
535 #if WXWIN_COMPATIBILITY_2_8
536
537 void wxLog::DoLog(wxLogLevel WXUNUSED(level),
538 const char *WXUNUSED(szString),
539 time_t WXUNUSED(t))
540 {
541 }
542
543 void wxLog::DoLog(wxLogLevel WXUNUSED(level),
544 const wchar_t *WXUNUSED(wzString),
545 time_t WXUNUSED(t))
546 {
547 }
548
549 #endif // WXWIN_COMPATIBILITY_2_8
550
551 wxLog *wxLog::GetActiveTarget()
552 {
553 if ( ms_bAutoCreate && ms_pLogger == NULL ) {
554 // prevent infinite recursion if someone calls wxLogXXX() from
555 // wxApp::CreateLogTarget()
556 static bool s_bInGetActiveTarget = false;
557 if ( !s_bInGetActiveTarget ) {
558 s_bInGetActiveTarget = true;
559
560 // ask the application to create a log target for us
561 if ( wxTheApp != NULL )
562 ms_pLogger = wxTheApp->GetTraits()->CreateLogTarget();
563 else
564 ms_pLogger = new wxLogStderr;
565
566 s_bInGetActiveTarget = false;
567
568 // do nothing if it fails - what can we do?
569 }
570 }
571
572 return ms_pLogger;
573 }
574
575 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
576 {
577 if ( ms_pLogger != NULL ) {
578 // flush the old messages before changing because otherwise they might
579 // get lost later if this target is not restored
580 ms_pLogger->Flush();
581 }
582
583 wxLog *pOldLogger = ms_pLogger;
584 ms_pLogger = pLogger;
585
586 return pOldLogger;
587 }
588
589 void wxLog::DontCreateOnDemand()
590 {
591 ms_bAutoCreate = false;
592
593 // this is usually called at the end of the program and we assume that it
594 // is *always* called at the end - so we free memory here to avoid false
595 // memory leak reports from wxWin memory tracking code
596 ClearTraceMasks();
597 }
598
599 void wxLog::DoCreateOnDemand()
600 {
601 ms_bAutoCreate = true;
602 }
603
604 void wxLog::RemoveTraceMask(const wxString& str)
605 {
606 int index = ms_aTraceMasks.Index(str);
607 if ( index != wxNOT_FOUND )
608 ms_aTraceMasks.RemoveAt((size_t)index);
609 }
610
611 void wxLog::ClearTraceMasks()
612 {
613 ms_aTraceMasks.Clear();
614 }
615
616 void wxLog::TimeStamp(wxString *str)
617 {
618 #if wxUSE_DATETIME
619 if ( !ms_timestamp.empty() )
620 {
621 wxChar buf[256];
622 time_t timeNow;
623 (void)time(&timeNow);
624
625 struct tm tm;
626 wxStrftime(buf, WXSIZEOF(buf),
627 ms_timestamp, wxLocaltime_r(&timeNow, &tm));
628
629 str->Empty();
630 *str << buf << wxT(": ");
631 }
632 #endif // wxUSE_DATETIME
633 }
634
635 void wxLog::DoLog(wxLogLevel level, const wxString& szString, time_t t)
636 {
637 #if WXWIN_COMPATIBILITY_2_8
638 // DoLog() signature changed since 2.8, so we call the old versions here
639 // so that existing custom log classes still work:
640 DoLog(level, (const char*)szString.mb_str(), t);
641 DoLog(level, (const wchar_t*)szString.wc_str(), t);
642 #endif
643
644 switch ( level ) {
645 case wxLOG_FatalError:
646 LogString(_("Fatal error: ") + szString, t);
647 LogString(_("Program aborted."), t);
648 Flush();
649 #ifdef __WXWINCE__
650 ExitThread(3);
651 #else
652 abort();
653 #endif
654 break;
655
656 case wxLOG_Error:
657 LogString(_("Error: ") + szString, t);
658 break;
659
660 case wxLOG_Warning:
661 LogString(_("Warning: ") + szString, t);
662 break;
663
664 case wxLOG_Info:
665 if ( GetVerbose() )
666 case wxLOG_Message:
667 case wxLOG_Status:
668 default: // log unknown log levels too
669 LogString(szString, t);
670 break;
671
672 case wxLOG_Trace:
673 case wxLOG_Debug:
674 #ifdef __WXDEBUG__
675 {
676 wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
677 : wxT("Debug: ");
678 msg << szString;
679 LogString(msg, t);
680 }
681 #endif // Debug
682 break;
683 }
684 }
685
686 void wxLog::DoLogString(const wxString& szString, time_t t)
687 {
688 #if WXWIN_COMPATIBILITY_2_8
689 // DoLogString() signature changed since 2.8, so we call the old versions
690 // here so that existing custom log classes still work; unfortunately this
691 // also means that we can't have the wxFAIL_MSG below in compat mode
692 DoLogString((const char*)szString.mb_str(), t);
693 DoLogString((const wchar_t*)szString.wc_str(), t);
694 #else
695 wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
696 wxUnusedVar(szString);
697 wxUnusedVar(t);
698 #endif
699 }
700
701 void wxLog::Flush()
702 {
703 // nothing to do here
704 }
705
706 /*static*/ bool wxLog::IsAllowedTraceMask(const wxString& mask)
707 {
708 for ( wxArrayString::iterator it = ms_aTraceMasks.begin(),
709 en = ms_aTraceMasks.end();
710 it != en; ++it )
711 if ( *it == mask)
712 return true;
713 return false;
714 }
715
716 // ----------------------------------------------------------------------------
717 // wxLogBuffer implementation
718 // ----------------------------------------------------------------------------
719
720 void wxLogBuffer::Flush()
721 {
722 if ( !m_str.empty() )
723 {
724 wxMessageOutputBest out;
725 out.Printf(_T("%s"), m_str.c_str());
726 m_str.clear();
727 }
728 }
729
730 void wxLogBuffer::DoLog(wxLogLevel level, const wxString& szString, time_t t)
731 {
732 switch ( level )
733 {
734 case wxLOG_Trace:
735 case wxLOG_Debug:
736 #ifdef __WXDEBUG__
737 // don't put debug messages in the buffer, we don't want to show
738 // them to the user in a msg box, log them immediately
739 {
740 wxString str;
741 TimeStamp(&str);
742 str += szString;
743
744 wxMessageOutputDebug dbgout;
745 dbgout.Printf(_T("%s\n"), str.c_str());
746 }
747 #endif // __WXDEBUG__
748 break;
749
750 default:
751 wxLog::DoLog(level, szString, t);
752 }
753 }
754
755 void wxLogBuffer::DoLogString(const wxString& szString, time_t WXUNUSED(t))
756 {
757 m_str << szString << _T("\n");
758 }
759
760 // ----------------------------------------------------------------------------
761 // wxLogStderr class implementation
762 // ----------------------------------------------------------------------------
763
764 wxLogStderr::wxLogStderr(FILE *fp)
765 {
766 if ( fp == NULL )
767 m_fp = stderr;
768 else
769 m_fp = fp;
770 }
771
772 void wxLogStderr::DoLogString(const wxString& szString, time_t WXUNUSED(t))
773 {
774 wxString str;
775 TimeStamp(&str);
776 str << szString;
777
778 wxFputs(str, m_fp);
779 wxFputc(_T('\n'), m_fp);
780 fflush(m_fp);
781
782 // under GUI systems such as Windows or Mac, programs usually don't have
783 // stderr at all, so show the messages also somewhere else, typically in
784 // the debugger window so that they go at least somewhere instead of being
785 // simply lost
786 if ( m_fp == stderr )
787 {
788 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
789 if ( traits && !traits->HasStderr() )
790 {
791 wxMessageOutputDebug dbgout;
792 dbgout.Printf(_T("%s\n"), str.c_str());
793 }
794 }
795 }
796
797 // ----------------------------------------------------------------------------
798 // wxLogStream implementation
799 // ----------------------------------------------------------------------------
800
801 #if wxUSE_STD_IOSTREAM
802 #include "wx/ioswrap.h"
803 wxLogStream::wxLogStream(wxSTD ostream *ostr)
804 {
805 if ( ostr == NULL )
806 m_ostr = &wxSTD cerr;
807 else
808 m_ostr = ostr;
809 }
810
811 void wxLogStream::DoLogString(const wxString& szString, time_t WXUNUSED(t))
812 {
813 wxString stamp;
814 TimeStamp(&stamp);
815 (*m_ostr) << stamp << szString << wxSTD endl;
816 }
817 #endif // wxUSE_STD_IOSTREAM
818
819 // ----------------------------------------------------------------------------
820 // wxLogChain
821 // ----------------------------------------------------------------------------
822
823 wxLogChain::wxLogChain(wxLog *logger)
824 {
825 m_bPassMessages = true;
826
827 m_logNew = logger;
828 m_logOld = wxLog::SetActiveTarget(this);
829 }
830
831 wxLogChain::~wxLogChain()
832 {
833 delete m_logOld;
834
835 if ( m_logNew != this )
836 delete m_logNew;
837 }
838
839 void wxLogChain::SetLog(wxLog *logger)
840 {
841 if ( m_logNew != this )
842 delete m_logNew;
843
844 m_logNew = logger;
845 }
846
847 void wxLogChain::Flush()
848 {
849 if ( m_logOld )
850 m_logOld->Flush();
851
852 // be careful to avoid infinite recursion
853 if ( m_logNew && m_logNew != this )
854 m_logNew->Flush();
855 }
856
857 void wxLogChain::DoLog(wxLogLevel level, const wxString& szString, time_t t)
858 {
859 // let the previous logger show it
860 if ( m_logOld && IsPassingMessages() )
861 {
862 // bogus cast just to access protected DoLog
863 ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
864 }
865
866 if ( m_logNew && m_logNew != this )
867 {
868 // as above...
869 ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
870 }
871 }
872
873 #ifdef __VISUALC__
874 // "'this' : used in base member initializer list" - so what?
875 #pragma warning(disable:4355)
876 #endif // VC++
877
878 // ----------------------------------------------------------------------------
879 // wxLogInterposer
880 // ----------------------------------------------------------------------------
881
882 wxLogInterposer::wxLogInterposer()
883 : wxLogChain(this)
884 {
885 }
886
887 // ----------------------------------------------------------------------------
888 // wxLogInterposerTemp
889 // ----------------------------------------------------------------------------
890
891 wxLogInterposerTemp::wxLogInterposerTemp()
892 : wxLogChain(this)
893 {
894 DetachOldLog();
895 }
896
897 #ifdef __VISUALC__
898 #pragma warning(default:4355)
899 #endif // VC++
900
901 // ============================================================================
902 // Global functions/variables
903 // ============================================================================
904
905 // ----------------------------------------------------------------------------
906 // static variables
907 // ----------------------------------------------------------------------------
908
909 #if wxUSE_THREADS
910 wxCriticalSection wxLog::ms_prevCS;
911 #endif // wxUSE_THREADS
912 bool wxLog::ms_bRepetCounting = false;
913 wxString wxLog::ms_prevString;
914 unsigned int wxLog::ms_prevCounter = 0;
915 time_t wxLog::ms_prevTimeStamp= 0;
916 wxLogLevel wxLog::ms_prevLevel;
917
918 wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
919 bool wxLog::ms_doLog = true;
920 bool wxLog::ms_bAutoCreate = true;
921 bool wxLog::ms_bVerbose = false;
922
923 wxLogLevel wxLog::ms_logLevel = wxLOG_Max; // log everything by default
924
925 size_t wxLog::ms_suspendCount = 0;
926
927 wxString wxLog::ms_timestamp(wxT("%X")); // time only, no date
928
929 wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
930 wxArrayString wxLog::ms_aTraceMasks;
931
932 // ----------------------------------------------------------------------------
933 // stdout error logging helper
934 // ----------------------------------------------------------------------------
935
936 // helper function: wraps the message and justifies it under given position
937 // (looks more pretty on the terminal). Also adds newline at the end.
938 //
939 // TODO this is now disabled until I find a portable way of determining the
940 // terminal window size (ok, I found it but does anybody really cares?)
941 #ifdef LOG_PRETTY_WRAP
942 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
943 {
944 size_t nMax = 80; // FIXME
945 size_t nStart = strlen(pszPrefix);
946 fputs(pszPrefix, f);
947
948 size_t n;
949 while ( *psz != '\0' ) {
950 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
951 putc(*psz++, f);
952
953 // wrapped?
954 if ( *psz != '\0' ) {
955 /*putc('\n', f);*/
956 for ( n = 0; n < nStart; n++ )
957 putc(' ', f);
958
959 // as we wrapped, squeeze all white space
960 while ( isspace(*psz) )
961 psz++;
962 }
963 }
964
965 putc('\n', f);
966 }
967 #endif //LOG_PRETTY_WRAP
968
969 // ----------------------------------------------------------------------------
970 // error code/error message retrieval functions
971 // ----------------------------------------------------------------------------
972
973 // get error code from syste
974 unsigned long wxSysErrorCode()
975 {
976 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
977 return ::GetLastError();
978 #else //Unix
979 return errno;
980 #endif //Win/Unix
981 }
982
983 // get error message from system
984 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
985 {
986 if ( nErrCode == 0 )
987 nErrCode = wxSysErrorCode();
988
989 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
990 static wxChar s_szBuf[1024];
991
992 // get error message from system
993 LPVOID lpMsgBuf;
994 if ( ::FormatMessage
995 (
996 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
997 NULL,
998 nErrCode,
999 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1000 (LPTSTR)&lpMsgBuf,
1001 0,
1002 NULL
1003 ) == 0 )
1004 {
1005 // if this happens, something is seriously wrong, so don't use _() here
1006 // for safety
1007 wxSprintf(s_szBuf, _T("unknown error %lx"), nErrCode);
1008 return s_szBuf;
1009 }
1010
1011
1012 // copy it to our buffer and free memory
1013 // Crashes on SmartPhone (FIXME)
1014 #if !defined(__SMARTPHONE__) /* of WinCE */
1015 if( lpMsgBuf != 0 )
1016 {
1017 wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
1018 s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
1019
1020 LocalFree(lpMsgBuf);
1021
1022 // returned string is capitalized and ended with '\r\n' - bad
1023 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
1024 size_t len = wxStrlen(s_szBuf);
1025 if ( len > 0 ) {
1026 // truncate string
1027 if ( s_szBuf[len - 2] == wxT('\r') )
1028 s_szBuf[len - 2] = wxT('\0');
1029 }
1030 }
1031 else
1032 #endif // !__SMARTPHONE__
1033 {
1034 s_szBuf[0] = wxT('\0');
1035 }
1036
1037 return s_szBuf;
1038 #else // !__WXMSW__
1039 #if wxUSE_UNICODE
1040 static wchar_t s_wzBuf[1024];
1041 wxConvCurrent->MB2WC(s_wzBuf, strerror((int)nErrCode),
1042 WXSIZEOF(s_wzBuf) - 1);
1043 return s_wzBuf;
1044 #else
1045 return strerror((int)nErrCode);
1046 #endif
1047 #endif // __WXMSW__/!__WXMSW__
1048 }
1049
1050 #endif // wxUSE_LOG