]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/log.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix tracking rectangles in 64-bit build by remembering the tag as the 64-bit integer...
[wxWidgets.git] / src / common / log.cpp
... / ...
CommitLineData
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
87void 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
95void 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
105void 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
151IMPLEMENT_LOG_FUNCTION(Error)
152IMPLEMENT_LOG_FUNCTION(Warning)
153IMPLEMENT_LOG_FUNCTION(Message)
154IMPLEMENT_LOG_FUNCTION(Info)
155IMPLEMENT_LOG_FUNCTION(Status)
156
157void 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, wxS("%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
169void wxVLogFatalError(const wxString& format, va_list argptr)
170{
171 wxSafeShowMessage(wxS("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
181void 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
194void 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
207void 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
218void 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
228void 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 << wxS("(") << mask << wxS(") ") << 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
376IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
377IMPLEMENT_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
383static inline wxString wxLogSysErrorHelper(long err)
384{
385 return wxString::Format(_(" (error %ld: %s)"), err, wxSysErrorMsg(err));
386}
387
388void WXDLLIMPEXP_BASE wxVLogSysError(const wxString& format, va_list argptr)
389{
390 wxVLogSysError(wxSysErrorCode(), format, argptr);
391}
392
393#if !wxUSE_UTF8_LOCALE_ONLY
394void 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
404void 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
413void 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
423void 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
433void 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
444void 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
452void 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
460unsigned wxLog::LogLastRepeatIfNeeded()
461{
462 wxCRIT_SECT_LOCKER(lock, ms_prevCS);
463
464 return LogLastRepeatIfNeededUnlocked();
465}
466
467unsigned wxLog::LogLastRepeatIfNeededUnlocked()
468{
469 const unsigned count = ms_prevCounter;
470
471 if ( ms_prevCounter )
472 {
473 wxString msg;
474#if wxUSE_INTL
475 msg.Printf(wxPLURAL("The previous message repeated once.",
476 "The previous message repeated %lu times.",
477 ms_prevCounter),
478 ms_prevCounter);
479#else
480 msg.Printf(wxS("The previous message was repeated %lu times."),
481 ms_prevCounter);
482#endif
483 ms_prevCounter = 0;
484 ms_prevString.clear();
485 DoLog(ms_prevLevel, msg, ms_prevTimeStamp);
486 }
487
488 return count;
489}
490
491wxLog::~wxLog()
492{
493 // Flush() must be called before destroying the object as otherwise some
494 // messages could be lost
495 if ( ms_prevCounter )
496 {
497 wxMessageOutputDebug().Printf
498 (
499 wxS("Last repeated message (\"%s\", %lu times) wasn't output"),
500 ms_prevString,
501 ms_prevCounter
502 );
503 }
504}
505
506/* static */
507void wxLog::OnLog(wxLogLevel level, const wxString& szString, time_t t)
508{
509 if ( IsEnabled() && ms_logLevel >= level )
510 {
511 wxLog *pLogger = GetActiveTarget();
512 if ( pLogger )
513 {
514 if ( GetRepetitionCounting() )
515 {
516 wxCRIT_SECT_LOCKER(lock, ms_prevCS);
517
518 if ( szString == ms_prevString )
519 {
520 ms_prevCounter++;
521
522 // nothing else to do, in particular, don't log the
523 // repeated message
524 return;
525 }
526
527 pLogger->LogLastRepeatIfNeededUnlocked();
528
529 // reset repetition counter for a new message
530 ms_prevString = szString;
531 ms_prevLevel = level;
532 ms_prevTimeStamp = t;
533 }
534
535 pLogger->DoLog(level, szString, t);
536 }
537 }
538}
539
540// deprecated function
541#if WXWIN_COMPATIBILITY_2_6
542
543wxChar *wxLog::SetLogBuffer(wxChar * WXUNUSED(buf), size_t WXUNUSED(size))
544{
545 return NULL;
546}
547
548#endif // WXWIN_COMPATIBILITY_2_6
549
550#if WXWIN_COMPATIBILITY_2_8
551
552void wxLog::DoLog(wxLogLevel WXUNUSED(level),
553 const char *WXUNUSED(szString),
554 time_t WXUNUSED(t))
555{
556}
557
558void wxLog::DoLog(wxLogLevel WXUNUSED(level),
559 const wchar_t *WXUNUSED(wzString),
560 time_t WXUNUSED(t))
561{
562}
563
564#endif // WXWIN_COMPATIBILITY_2_8
565
566wxLog *wxLog::GetActiveTarget()
567{
568 if ( ms_bAutoCreate && ms_pLogger == NULL ) {
569 // prevent infinite recursion if someone calls wxLogXXX() from
570 // wxApp::CreateLogTarget()
571 static bool s_bInGetActiveTarget = false;
572 if ( !s_bInGetActiveTarget ) {
573 s_bInGetActiveTarget = true;
574
575 // ask the application to create a log target for us
576 if ( wxTheApp != NULL )
577 ms_pLogger = wxTheApp->GetTraits()->CreateLogTarget();
578 else
579 ms_pLogger = new wxLogStderr;
580
581 s_bInGetActiveTarget = false;
582
583 // do nothing if it fails - what can we do?
584 }
585 }
586
587 return ms_pLogger;
588}
589
590wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
591{
592 if ( ms_pLogger != NULL ) {
593 // flush the old messages before changing because otherwise they might
594 // get lost later if this target is not restored
595 ms_pLogger->Flush();
596 }
597
598 wxLog *pOldLogger = ms_pLogger;
599 ms_pLogger = pLogger;
600
601 return pOldLogger;
602}
603
604void wxLog::DontCreateOnDemand()
605{
606 ms_bAutoCreate = false;
607
608 // this is usually called at the end of the program and we assume that it
609 // is *always* called at the end - so we free memory here to avoid false
610 // memory leak reports from wxWin memory tracking code
611 ClearTraceMasks();
612}
613
614void wxLog::DoCreateOnDemand()
615{
616 ms_bAutoCreate = true;
617}
618
619void wxLog::RemoveTraceMask(const wxString& str)
620{
621 int index = ms_aTraceMasks.Index(str);
622 if ( index != wxNOT_FOUND )
623 ms_aTraceMasks.RemoveAt((size_t)index);
624}
625
626void wxLog::ClearTraceMasks()
627{
628 ms_aTraceMasks.Clear();
629}
630
631void wxLog::TimeStamp(wxString *str)
632{
633#if wxUSE_DATETIME
634 if ( !ms_timestamp.empty() )
635 {
636 wxChar buf[256];
637 time_t timeNow;
638 (void)time(&timeNow);
639
640 struct tm tm;
641 wxStrftime(buf, WXSIZEOF(buf),
642 ms_timestamp, wxLocaltime_r(&timeNow, &tm));
643
644 str->Empty();
645 *str << buf << wxS(": ");
646 }
647#endif // wxUSE_DATETIME
648}
649
650void wxLog::DoLog(wxLogLevel level, const wxString& szString, time_t t)
651{
652#if WXWIN_COMPATIBILITY_2_8
653 // DoLog() signature changed since 2.8, so we call the old versions here
654 // so that existing custom log classes still work:
655 DoLog(level, (const char*)szString.mb_str(), t);
656 DoLog(level, (const wchar_t*)szString.wc_str(), t);
657#endif
658
659 switch ( level ) {
660 case wxLOG_FatalError:
661 LogString(_("Fatal error: ") + szString, t);
662 LogString(_("Program aborted."), t);
663 Flush();
664#ifdef __WXWINCE__
665 ExitThread(3);
666#else
667 abort();
668#endif
669 break;
670
671 case wxLOG_Error:
672 LogString(_("Error: ") + szString, t);
673 break;
674
675 case wxLOG_Warning:
676 LogString(_("Warning: ") + szString, t);
677 break;
678
679 case wxLOG_Info:
680 if ( GetVerbose() )
681 case wxLOG_Message:
682 case wxLOG_Status:
683 default: // log unknown log levels too
684 LogString(szString, t);
685 break;
686
687 case wxLOG_Trace:
688 case wxLOG_Debug:
689#ifdef __WXDEBUG__
690 {
691 wxString msg = level == wxLOG_Trace ? wxS("Trace: ")
692 : wxS("Debug: ");
693 msg << szString;
694 LogString(msg, t);
695 }
696#endif // Debug
697 break;
698 }
699}
700
701void wxLog::DoLogString(const wxString& szString, time_t t)
702{
703#if WXWIN_COMPATIBILITY_2_8
704 // DoLogString() signature changed since 2.8, so we call the old versions
705 // here so that existing custom log classes still work; unfortunately this
706 // also means that we can't have the wxFAIL_MSG below in compat mode
707 DoLogString((const char*)szString.mb_str(), t);
708 DoLogString((const wchar_t*)szString.wc_str(), t);
709#else
710 wxFAIL_MSG(wxS("DoLogString must be overriden if it's called."));
711 wxUnusedVar(szString);
712 wxUnusedVar(t);
713#endif
714}
715
716void wxLog::Flush()
717{
718 LogLastRepeatIfNeeded();
719}
720
721/*static*/ bool wxLog::IsAllowedTraceMask(const wxString& mask)
722{
723 for ( wxArrayString::iterator it = ms_aTraceMasks.begin(),
724 en = ms_aTraceMasks.end();
725 it != en; ++it )
726 if ( *it == mask)
727 return true;
728 return false;
729}
730
731// ----------------------------------------------------------------------------
732// wxLogBuffer implementation
733// ----------------------------------------------------------------------------
734
735void wxLogBuffer::Flush()
736{
737 if ( !m_str.empty() )
738 {
739 wxMessageOutputBest out;
740 out.Printf(wxS("%s"), m_str.c_str());
741 m_str.clear();
742 }
743}
744
745void wxLogBuffer::DoLog(wxLogLevel level, const wxString& szString, time_t t)
746{
747 switch ( level )
748 {
749 case wxLOG_Trace:
750 case wxLOG_Debug:
751#ifdef __WXDEBUG__
752 // don't put debug messages in the buffer, we don't want to show
753 // them to the user in a msg box, log them immediately
754 {
755 wxString str;
756 TimeStamp(&str);
757 str += szString;
758
759 wxMessageOutputDebug dbgout;
760 dbgout.Printf(wxS("%s\n"), str.c_str());
761 }
762#endif // __WXDEBUG__
763 break;
764
765 default:
766 wxLog::DoLog(level, szString, t);
767 }
768}
769
770void wxLogBuffer::DoLogString(const wxString& szString, time_t WXUNUSED(t))
771{
772 m_str << szString << wxS("\n");
773}
774
775// ----------------------------------------------------------------------------
776// wxLogStderr class implementation
777// ----------------------------------------------------------------------------
778
779wxLogStderr::wxLogStderr(FILE *fp)
780{
781 if ( fp == NULL )
782 m_fp = stderr;
783 else
784 m_fp = fp;
785}
786
787void wxLogStderr::DoLogString(const wxString& szString, time_t WXUNUSED(t))
788{
789 wxString str;
790 TimeStamp(&str);
791 str << szString;
792
793 wxFputs(str, m_fp);
794 wxFputc(wxS('\n'), m_fp);
795 fflush(m_fp);
796
797 // under GUI systems such as Windows or Mac, programs usually don't have
798 // stderr at all, so show the messages also somewhere else, typically in
799 // the debugger window so that they go at least somewhere instead of being
800 // simply lost
801 if ( m_fp == stderr )
802 {
803 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
804 if ( traits && !traits->HasStderr() )
805 {
806 wxMessageOutputDebug dbgout;
807 dbgout.Printf(wxS("%s\n"), str.c_str());
808 }
809 }
810}
811
812// ----------------------------------------------------------------------------
813// wxLogStream implementation
814// ----------------------------------------------------------------------------
815
816#if wxUSE_STD_IOSTREAM
817#include "wx/ioswrap.h"
818wxLogStream::wxLogStream(wxSTD ostream *ostr)
819{
820 if ( ostr == NULL )
821 m_ostr = &wxSTD cerr;
822 else
823 m_ostr = ostr;
824}
825
826void wxLogStream::DoLogString(const wxString& szString, time_t WXUNUSED(t))
827{
828 wxString stamp;
829 TimeStamp(&stamp);
830 (*m_ostr) << stamp << szString << wxSTD endl;
831}
832#endif // wxUSE_STD_IOSTREAM
833
834// ----------------------------------------------------------------------------
835// wxLogChain
836// ----------------------------------------------------------------------------
837
838wxLogChain::wxLogChain(wxLog *logger)
839{
840 m_bPassMessages = true;
841
842 m_logNew = logger;
843 m_logOld = wxLog::SetActiveTarget(this);
844}
845
846wxLogChain::~wxLogChain()
847{
848 delete m_logOld;
849
850 if ( m_logNew != this )
851 delete m_logNew;
852}
853
854void wxLogChain::SetLog(wxLog *logger)
855{
856 if ( m_logNew != this )
857 delete m_logNew;
858
859 m_logNew = logger;
860}
861
862void wxLogChain::Flush()
863{
864 if ( m_logOld )
865 m_logOld->Flush();
866
867 // be careful to avoid infinite recursion
868 if ( m_logNew && m_logNew != this )
869 m_logNew->Flush();
870}
871
872void wxLogChain::DoLog(wxLogLevel level, const wxString& szString, time_t t)
873{
874 // let the previous logger show it
875 if ( m_logOld && IsPassingMessages() )
876 {
877 // bogus cast just to access protected DoLog
878 ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
879 }
880
881 if ( m_logNew && m_logNew != this )
882 {
883 // as above...
884 ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
885 }
886}
887
888#ifdef __VISUALC__
889 // "'this' : used in base member initializer list" - so what?
890 #pragma warning(disable:4355)
891#endif // VC++
892
893// ----------------------------------------------------------------------------
894// wxLogInterposer
895// ----------------------------------------------------------------------------
896
897wxLogInterposer::wxLogInterposer()
898 : wxLogChain(this)
899{
900}
901
902// ----------------------------------------------------------------------------
903// wxLogInterposerTemp
904// ----------------------------------------------------------------------------
905
906wxLogInterposerTemp::wxLogInterposerTemp()
907 : wxLogChain(this)
908{
909 DetachOldLog();
910}
911
912#ifdef __VISUALC__
913 #pragma warning(default:4355)
914#endif // VC++
915
916// ============================================================================
917// Global functions/variables
918// ============================================================================
919
920// ----------------------------------------------------------------------------
921// static variables
922// ----------------------------------------------------------------------------
923
924#if wxUSE_THREADS
925wxCriticalSection wxLog::ms_prevCS;
926#endif // wxUSE_THREADS
927bool wxLog::ms_bRepetCounting = false;
928wxString wxLog::ms_prevString;
929unsigned int wxLog::ms_prevCounter = 0;
930time_t wxLog::ms_prevTimeStamp= 0;
931wxLogLevel wxLog::ms_prevLevel;
932
933wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
934bool wxLog::ms_doLog = true;
935bool wxLog::ms_bAutoCreate = true;
936bool wxLog::ms_bVerbose = false;
937
938wxLogLevel wxLog::ms_logLevel = wxLOG_Max; // log everything by default
939
940size_t wxLog::ms_suspendCount = 0;
941
942wxString wxLog::ms_timestamp(wxS("%X")); // time only, no date
943
944wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
945wxArrayString wxLog::ms_aTraceMasks;
946
947// ----------------------------------------------------------------------------
948// stdout error logging helper
949// ----------------------------------------------------------------------------
950
951// helper function: wraps the message and justifies it under given position
952// (looks more pretty on the terminal). Also adds newline at the end.
953//
954// TODO this is now disabled until I find a portable way of determining the
955// terminal window size (ok, I found it but does anybody really cares?)
956#ifdef LOG_PRETTY_WRAP
957static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
958{
959 size_t nMax = 80; // FIXME
960 size_t nStart = strlen(pszPrefix);
961 fputs(pszPrefix, f);
962
963 size_t n;
964 while ( *psz != '\0' ) {
965 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
966 putc(*psz++, f);
967
968 // wrapped?
969 if ( *psz != '\0' ) {
970 /*putc('\n', f);*/
971 for ( n = 0; n < nStart; n++ )
972 putc(' ', f);
973
974 // as we wrapped, squeeze all white space
975 while ( isspace(*psz) )
976 psz++;
977 }
978 }
979
980 putc('\n', f);
981}
982#endif //LOG_PRETTY_WRAP
983
984// ----------------------------------------------------------------------------
985// error code/error message retrieval functions
986// ----------------------------------------------------------------------------
987
988// get error code from syste
989unsigned long wxSysErrorCode()
990{
991#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
992 return ::GetLastError();
993#else //Unix
994 return errno;
995#endif //Win/Unix
996}
997
998// get error message from system
999const wxChar *wxSysErrorMsg(unsigned long nErrCode)
1000{
1001 if ( nErrCode == 0 )
1002 nErrCode = wxSysErrorCode();
1003
1004#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
1005 static wxChar s_szBuf[1024];
1006
1007 // get error message from system
1008 LPVOID lpMsgBuf;
1009 if ( ::FormatMessage
1010 (
1011 FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
1012 NULL,
1013 nErrCode,
1014 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1015 (LPTSTR)&lpMsgBuf,
1016 0,
1017 NULL
1018 ) == 0 )
1019 {
1020 // if this happens, something is seriously wrong, so don't use _() here
1021 // for safety
1022 wxSprintf(s_szBuf, wxS("unknown error %lx"), nErrCode);
1023 return s_szBuf;
1024 }
1025
1026
1027 // copy it to our buffer and free memory
1028 // Crashes on SmartPhone (FIXME)
1029#if !defined(__SMARTPHONE__) /* of WinCE */
1030 if( lpMsgBuf != 0 )
1031 {
1032 wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
1033 s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxS('\0');
1034
1035 LocalFree(lpMsgBuf);
1036
1037 // returned string is capitalized and ended with '\r\n' - bad
1038 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
1039 size_t len = wxStrlen(s_szBuf);
1040 if ( len > 0 ) {
1041 // truncate string
1042 if ( s_szBuf[len - 2] == wxS('\r') )
1043 s_szBuf[len - 2] = wxS('\0');
1044 }
1045 }
1046 else
1047#endif // !__SMARTPHONE__
1048 {
1049 s_szBuf[0] = wxS('\0');
1050 }
1051
1052 return s_szBuf;
1053#else // !__WXMSW__
1054 #if wxUSE_UNICODE
1055 static wchar_t s_wzBuf[1024];
1056 wxConvCurrent->MB2WC(s_wzBuf, strerror((int)nErrCode),
1057 WXSIZEOF(s_wzBuf) - 1);
1058 return s_wzBuf;
1059 #else
1060 return strerror((int)nErrCode);
1061 #endif
1062#endif // __WXMSW__/!__WXMSW__
1063}
1064
1065#endif // wxUSE_LOG
wxWidgets (Impactor)