]> 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
wxChar -> char
[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, _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
169void 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
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 << _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
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 WXDLLEXPORT wxVLogSysError(const wxString& format, va_list argptr)
389{
390 wxVLogSysError(wxSysErrorCode(), format, argptr);
391}
392
393#if !wxUSE_UTF8_LOCALE_ONLY
394void WXDLLEXPORT 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 WXDLLEXPORT 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 WXDLLEXPORT 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 WXDLLEXPORT 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 WXDLLEXPORT 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 WXDLLEXPORT 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 WXDLLEXPORT 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::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
486wxLog::~wxLog()
487{
488 LogLastRepetitionCountIfNeeded();
489}
490
491/* static */
492void 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
528wxChar *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
537void wxLog::DoLog(wxLogLevel WXUNUSED(level),
538 const char *WXUNUSED(szString),
539 time_t WXUNUSED(t))
540{
541}
542
543void 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
551wxLog *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
575wxLog *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
589void 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
599void wxLog::DoCreateOnDemand()
600{
601 ms_bAutoCreate = true;
602}
603
604void 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
611void wxLog::ClearTraceMasks()
612{
613 ms_aTraceMasks.Clear();
614}
615
616void 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
635void 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
686void 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
701void 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
720void 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
730void 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
755void 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
764wxLogStderr::wxLogStderr(FILE *fp)
765{
766 if ( fp == NULL )
767 m_fp = stderr;
768 else
769 m_fp = fp;
770}
771
772void 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"
803wxLogStream::wxLogStream(wxSTD ostream *ostr)
804{
805 if ( ostr == NULL )
806 m_ostr = &wxSTD cerr;
807 else
808 m_ostr = ostr;
809}
810
811void 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
823wxLogChain::wxLogChain(wxLog *logger)
824{
825 m_bPassMessages = true;
826
827 m_logNew = logger;
828 m_logOld = wxLog::SetActiveTarget(this);
829}
830
831wxLogChain::~wxLogChain()
832{
833 delete m_logOld;
834
835 if ( m_logNew != this )
836 delete m_logNew;
837}
838
839void wxLogChain::SetLog(wxLog *logger)
840{
841 if ( m_logNew != this )
842 delete m_logNew;
843
844 m_logNew = logger;
845}
846
847void 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
857void 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
882wxLogInterposer::wxLogInterposer()
883 : wxLogChain(this)
884{
885}
886
887// ----------------------------------------------------------------------------
888// wxLogInterposerTemp
889// ----------------------------------------------------------------------------
890
891wxLogInterposerTemp::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
910wxCriticalSection wxLog::ms_prevCS;
911#endif // wxUSE_THREADS
912bool wxLog::ms_bRepetCounting = false;
913wxString wxLog::ms_prevString;
914unsigned int wxLog::ms_prevCounter = 0;
915time_t wxLog::ms_prevTimeStamp= 0;
916wxLogLevel wxLog::ms_prevLevel;
917
918wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
919bool wxLog::ms_doLog = true;
920bool wxLog::ms_bAutoCreate = true;
921bool wxLog::ms_bVerbose = false;
922
923wxLogLevel wxLog::ms_logLevel = wxLOG_Max; // log everything by default
924
925size_t wxLog::ms_suspendCount = 0;
926
927wxString wxLog::ms_timestamp(wxT("%X")); // time only, no date
928
929wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
930wxArrayString 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
942static 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
974unsigned 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
984const 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
wxWidgets (Impactor)