]> git.saurik.com Git - wxWidgets.git/blob - src/common/log.cpp
don't write the strings to the stream one char at a time, it's *horribly* slow
[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 #include "wx/msgdlg.h"
40 #ifdef __WXMSW__
41 #include "wx/msw/private.h"
42 #endif
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 #if wxUSE_LOG
54
55 // other standard headers
56 #include <errno.h>
57 #include <stdlib.h>
58 #include <time.h>
59
60 #if defined(__WXMSW__)
61 #include "wx/msw/private.h" // includes windows.h for OutputDebugString
62 #endif
63
64 #if defined(__WXMAC__)
65 #include "wx/mac/private.h" // includes mac headers
66 #endif
67
68 // ----------------------------------------------------------------------------
69 // non member functions
70 // ----------------------------------------------------------------------------
71
72 // define this to enable wrapping of log messages
73 //#define LOG_PRETTY_WRAP
74
75 #ifdef LOG_PRETTY_WRAP
76 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
77 #endif
78
79 // ============================================================================
80 // implementation
81 // ============================================================================
82
83 // ----------------------------------------------------------------------------
84 // globals
85 // ----------------------------------------------------------------------------
86
87 // log functions can't allocate memory (LogError("out of memory...") should
88 // work!), so we use a static buffer for all log messages
89 #define LOG_BUFFER_SIZE (4096)
90
91 // static buffer for error messages
92 static wxChar s_szBufStatic[LOG_BUFFER_SIZE];
93
94 static wxChar *s_szBuf = s_szBufStatic;
95 static size_t s_szBufSize = WXSIZEOF( s_szBufStatic );
96
97 #if wxUSE_THREADS
98
99 // the critical section protecting the static buffer
100 static wxCriticalSection gs_csLogBuf;
101
102 #endif // wxUSE_THREADS
103
104 // return true if we have a non NULL non disabled log target
105 static inline bool IsLoggingEnabled()
106 {
107 return wxLog::IsEnabled() && (wxLog::GetActiveTarget() != NULL);
108 }
109
110 // ----------------------------------------------------------------------------
111 // implementation of Log functions
112 //
113 // NB: unfortunately we need all these distinct functions, we can't make them
114 // macros and not all compilers inline vararg functions.
115 // ----------------------------------------------------------------------------
116
117 // generic log function
118 void wxVLogGeneric(wxLogLevel level, const wxChar *szFormat, va_list argptr)
119 {
120 if ( IsLoggingEnabled() ) {
121 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
122
123 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
124
125 wxLog::OnLog(level, s_szBuf, time(NULL));
126 }
127 }
128
129 void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
130 {
131 va_list argptr;
132 va_start(argptr, szFormat);
133 wxVLogGeneric(level, szFormat, argptr);
134 va_end(argptr);
135 }
136
137 #define IMPLEMENT_LOG_FUNCTION(level) \
138 void wxVLog##level(const wxChar *szFormat, va_list argptr) \
139 { \
140 if ( IsLoggingEnabled() ) { \
141 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
142 \
143 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr); \
144 \
145 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
146 } \
147 } \
148 void wxLog##level(const wxChar *szFormat, ...) \
149 { \
150 va_list argptr; \
151 va_start(argptr, szFormat); \
152 wxVLog##level(szFormat, argptr); \
153 va_end(argptr); \
154 }
155
156 IMPLEMENT_LOG_FUNCTION(Error)
157 IMPLEMENT_LOG_FUNCTION(Warning)
158 IMPLEMENT_LOG_FUNCTION(Message)
159 IMPLEMENT_LOG_FUNCTION(Info)
160 IMPLEMENT_LOG_FUNCTION(Status)
161
162 void wxSafeShowMessage(const wxString& title, const wxString& text)
163 {
164 #ifdef __WINDOWS__
165 ::MessageBox(NULL, text, title, MB_OK | MB_ICONSTOP);
166 #else
167 wxFprintf(stderr, _T("%s: %s\n"), title.c_str(), text.c_str());
168 #endif
169 }
170
171 // fatal errors can't be suppressed nor handled by the custom log target and
172 // always terminate the program
173 void wxVLogFatalError(const wxChar *szFormat, va_list argptr)
174 {
175 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
176
177 wxSafeShowMessage(_T("Fatal Error"), s_szBuf);
178
179 abort();
180 }
181
182 void wxLogFatalError(const wxChar *szFormat, ...)
183 {
184 va_list argptr;
185 va_start(argptr, szFormat);
186 wxVLogFatalError(szFormat, argptr);
187 va_end(argptr);
188 }
189
190 // same as info, but only if 'verbose' mode is on
191 void wxVLogVerbose(const wxChar *szFormat, va_list argptr)
192 {
193 if ( IsLoggingEnabled() ) {
194 wxLog *pLog = wxLog::GetActiveTarget();
195 if ( pLog != NULL && pLog->GetVerbose() ) {
196 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
197
198 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
199
200 wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
201 }
202 }
203 }
204
205 void wxLogVerbose(const wxChar *szFormat, ...)
206 {
207 va_list argptr;
208 va_start(argptr, szFormat);
209 wxVLogVerbose(szFormat, argptr);
210 va_end(argptr);
211 }
212
213 // debug functions
214 #ifdef __WXDEBUG__
215 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
216 void wxVLog##level(const wxChar *szFormat, va_list argptr) \
217 { \
218 if ( IsLoggingEnabled() ) { \
219 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
220 \
221 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr); \
222 \
223 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
224 } \
225 } \
226 void wxLog##level(const wxChar *szFormat, ...) \
227 { \
228 va_list argptr; \
229 va_start(argptr, szFormat); \
230 wxVLog##level(szFormat, argptr); \
231 va_end(argptr); \
232 }
233
234 void wxVLogTrace(const wxChar *mask, const wxChar *szFormat, va_list argptr)
235 {
236 if ( IsLoggingEnabled() && wxLog::IsAllowedTraceMask(mask) ) {
237 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
238
239 wxChar *p = s_szBuf;
240 size_t len = s_szBufSize;
241 wxStrncpy(s_szBuf, _T("("), len);
242 len -= 1; // strlen("(")
243 p += 1;
244 wxStrncat(p, mask, len);
245 size_t lenMask = wxStrlen(mask);
246 len -= lenMask;
247 p += lenMask;
248
249 wxStrncat(p, _T(") "), len);
250 len -= 2;
251 p += 2;
252
253 wxVsnprintf(p, len, szFormat, argptr);
254
255 wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
256 }
257 }
258
259 void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
260 {
261 va_list argptr;
262 va_start(argptr, szFormat);
263 wxVLogTrace(mask, szFormat, argptr);
264 va_end(argptr);
265 }
266
267 void wxVLogTrace(wxTraceMask mask, const wxChar *szFormat, va_list argptr)
268 {
269 // we check that all of mask bits are set in the current mask, so
270 // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
271 // if both bits are set.
272 if ( IsLoggingEnabled() && ((wxLog::GetTraceMask() & mask) == mask) ) {
273 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
274
275 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
276
277 wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
278 }
279 }
280
281 void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
282 {
283 va_list argptr;
284 va_start(argptr, szFormat);
285 wxVLogTrace(mask, szFormat, argptr);
286 va_end(argptr);
287 }
288
289 #else // release
290 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
291 #endif
292
293 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
294 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
295
296 // wxLogSysError: one uses the last error code, for other you must give it
297 // explicitly
298
299 // common part of both wxLogSysError
300 void wxLogSysErrorHelper(long lErrCode)
301 {
302 wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
303 wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
304 _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
305 wxStrncat(s_szBuf, szErrMsg, s_szBufSize - wxStrlen(s_szBuf));
306
307 wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
308 }
309
310 void WXDLLEXPORT wxVLogSysError(const wxChar *szFormat, va_list argptr)
311 {
312 if ( IsLoggingEnabled() ) {
313 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
314
315 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
316
317 wxLogSysErrorHelper(wxSysErrorCode());
318 }
319 }
320
321 void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
322 {
323 va_list argptr;
324 va_start(argptr, szFormat);
325 wxVLogSysError(szFormat, argptr);
326 va_end(argptr);
327 }
328
329 void WXDLLEXPORT wxVLogSysError(long lErrCode, const wxChar *szFormat, va_list argptr)
330 {
331 if ( IsLoggingEnabled() ) {
332 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
333
334 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr);
335
336 wxLogSysErrorHelper(lErrCode);
337 }
338 }
339
340 void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
341 {
342 va_list argptr;
343 va_start(argptr, szFormat);
344 wxVLogSysError(lErrCode, szFormat, argptr);
345 va_end(argptr);
346 }
347
348 // ----------------------------------------------------------------------------
349 // wxLog class implementation
350 // ----------------------------------------------------------------------------
351
352 wxLog::wxLog()
353 {
354 m_bHasMessages = FALSE;
355 }
356
357 wxChar *wxLog::SetLogBuffer( wxChar *buf, size_t size)
358 {
359 wxChar *oldbuf = s_szBuf;
360
361 if( buf == 0 )
362 {
363 s_szBuf = s_szBufStatic;
364 s_szBufSize = WXSIZEOF( s_szBufStatic );
365 }
366 else
367 {
368 s_szBuf = buf;
369 s_szBufSize = size;
370 }
371
372 return (oldbuf == s_szBufStatic ) ? 0 : oldbuf;
373 }
374
375 wxLog *wxLog::GetActiveTarget()
376 {
377 if ( ms_bAutoCreate && ms_pLogger == NULL ) {
378 // prevent infinite recursion if someone calls wxLogXXX() from
379 // wxApp::CreateLogTarget()
380 static bool s_bInGetActiveTarget = FALSE;
381 if ( !s_bInGetActiveTarget ) {
382 s_bInGetActiveTarget = TRUE;
383
384 // ask the application to create a log target for us
385 if ( wxTheApp != NULL )
386 ms_pLogger = wxTheApp->CreateLogTarget();
387 else
388 ms_pLogger = new wxLogStderr;
389
390 s_bInGetActiveTarget = FALSE;
391
392 // do nothing if it fails - what can we do?
393 }
394 }
395
396 return ms_pLogger;
397 }
398
399 wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
400 {
401 if ( ms_pLogger != NULL ) {
402 // flush the old messages before changing because otherwise they might
403 // get lost later if this target is not restored
404 ms_pLogger->Flush();
405 }
406
407 wxLog *pOldLogger = ms_pLogger;
408 ms_pLogger = pLogger;
409
410 return pOldLogger;
411 }
412
413 void wxLog::DontCreateOnDemand()
414 {
415 ms_bAutoCreate = FALSE;
416
417 // this is usually called at the end of the program and we assume that it
418 // is *always* called at the end - so we free memory here to avoid false
419 // memory leak reports from wxWin memory tracking code
420 ClearTraceMasks();
421 }
422
423 void wxLog::RemoveTraceMask(const wxString& str)
424 {
425 int index = ms_aTraceMasks.Index(str);
426 if ( index != wxNOT_FOUND )
427 ms_aTraceMasks.Remove((size_t)index);
428 }
429
430 void wxLog::ClearTraceMasks()
431 {
432 ms_aTraceMasks.Clear();
433 }
434
435 void wxLog::TimeStamp(wxString *str)
436 {
437 if ( ms_timestamp )
438 {
439 wxChar buf[256];
440 time_t timeNow;
441 (void)time(&timeNow);
442 wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
443
444 str->Empty();
445 *str << buf << wxT(": ");
446 }
447 }
448
449 void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
450 {
451 switch ( level ) {
452 case wxLOG_FatalError:
453 DoLogString(wxString(_("Fatal error: ")) + szString, t);
454 DoLogString(_("Program aborted."), t);
455 Flush();
456 abort();
457 break;
458
459 case wxLOG_Error:
460 DoLogString(wxString(_("Error: ")) + szString, t);
461 break;
462
463 case wxLOG_Warning:
464 DoLogString(wxString(_("Warning: ")) + szString, t);
465 break;
466
467 case wxLOG_Info:
468 if ( GetVerbose() )
469 case wxLOG_Message:
470 case wxLOG_Status:
471 default: // log unknown log levels too
472 DoLogString(szString, t);
473 break;
474
475 case wxLOG_Trace:
476 case wxLOG_Debug:
477 #ifdef __WXDEBUG__
478 {
479 wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
480 : wxT("Debug: ");
481 msg << szString;
482 DoLogString(msg, t);
483 }
484 #endif // Debug
485 break;
486 }
487 }
488
489 void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
490 {
491 wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
492 }
493
494 void wxLog::Flush()
495 {
496 // remember that we don't have any more messages to show
497 m_bHasMessages = FALSE;
498 }
499
500 // ----------------------------------------------------------------------------
501 // wxLogStderr class implementation
502 // ----------------------------------------------------------------------------
503
504 wxLogStderr::wxLogStderr(FILE *fp)
505 {
506 if ( fp == NULL )
507 m_fp = stderr;
508 else
509 m_fp = fp;
510 }
511
512 #if defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ > 0x5300)
513
514 #if !TARGET_API_MAC_CARBON
515 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
516
517 #ifndef __MetroNubUtils__
518 #include "MetroNubUtils.h"
519 #endif
520
521 #ifdef __cplusplus
522 extern "C" {
523 #endif
524
525 #ifndef __GESTALT__
526 #include <Gestalt.h>
527 #endif
528
529 #ifndef true
530 #define true 1
531 #endif
532
533 #ifndef false
534 #define false 0
535 #endif
536
537 #if TARGET_API_MAC_CARBON
538
539 #include <CodeFragments.h>
540
541 EXTERN_API_C( long )
542 CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
543
544 ProcPtr gCallUniversalProc_Proc = NULL;
545
546 #endif
547
548 static MetroNubUserEntryBlock* gMetroNubEntry = NULL;
549
550 static long fRunOnce = false;
551
552 Boolean IsCompatibleVersion(short inVersion);
553
554 /* ---------------------------------------------------------------------------
555 IsCompatibleVersion
556 --------------------------------------------------------------------------- */
557
558 Boolean IsCompatibleVersion(short inVersion)
559 {
560 Boolean result = false;
561
562 if (fRunOnce)
563 {
564 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
565
566 result = (inVersion <= block->apiHiVersion);
567 }
568
569 return result;
570 }
571
572 /* ---------------------------------------------------------------------------
573 IsMetroNubInstalled
574 --------------------------------------------------------------------------- */
575
576 Boolean IsMetroNubInstalled()
577 {
578 if (!fRunOnce)
579 {
580 long result, value;
581
582 fRunOnce = true;
583 gMetroNubEntry = NULL;
584
585 if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
586 {
587 /* look for MetroNub's Gestalt selector */
588 if (Gestalt(kMetroNubUserSignature, &result) == noErr)
589 {
590
591 #if TARGET_API_MAC_CARBON
592 if (gCallUniversalProc_Proc == NULL)
593 {
594 CFragConnectionID connectionID;
595 Ptr mainAddress;
596 Str255 errorString;
597 ProcPtr symbolAddress;
598 OSErr err;
599 CFragSymbolClass symbolClass;
600
601 symbolAddress = NULL;
602 err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
603 &connectionID, &mainAddress, errorString);
604
605 if (err != noErr)
606 {
607 gCallUniversalProc_Proc = NULL;
608 goto end;
609 }
610
611 err = FindSymbol(connectionID, "\pCallUniversalProc",
612 (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
613
614 if (err != noErr)
615 {
616 gCallUniversalProc_Proc = NULL;
617 goto end;
618 }
619 }
620 #endif
621
622 {
623 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
624
625 /* make sure the version of the API is compatible */
626 if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
627 kMetroNubUserAPIVersion <= block->apiHiVersion)
628 gMetroNubEntry = block; /* success! */
629 }
630
631 }
632 }
633 }
634
635 end:
636
637 #if TARGET_API_MAC_CARBON
638 return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
639 #else
640 return (gMetroNubEntry != NULL);
641 #endif
642 }
643
644 /* ---------------------------------------------------------------------------
645 IsMWDebuggerRunning [v1 API]
646 --------------------------------------------------------------------------- */
647
648 Boolean IsMWDebuggerRunning()
649 {
650 if (IsMetroNubInstalled())
651 return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
652 else
653 return false;
654 }
655
656 /* ---------------------------------------------------------------------------
657 AmIBeingMWDebugged [v1 API]
658 --------------------------------------------------------------------------- */
659
660 Boolean AmIBeingMWDebugged()
661 {
662 if (IsMetroNubInstalled())
663 return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
664 else
665 return false;
666 }
667
668 /* ---------------------------------------------------------------------------
669 UserSetWatchPoint [v2 API]
670 --------------------------------------------------------------------------- */
671
672 OSErr UserSetWatchPoint (Ptr address, long length, WatchPointIDT* watchPointID)
673 {
674 if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion))
675 return CallUserSetWatchPointProc(gMetroNubEntry->userSetWatchPoint,
676 address, length, watchPointID);
677 else
678 return errProcessIsNotClient;
679 }
680
681 /* ---------------------------------------------------------------------------
682 ClearWatchPoint [v2 API]
683 --------------------------------------------------------------------------- */
684
685 OSErr ClearWatchPoint (WatchPointIDT watchPointID)
686 {
687 if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion))
688 return CallClearWatchPointProc(gMetroNubEntry->clearWatchPoint, watchPointID);
689 else
690 return errProcessIsNotClient;
691 }
692
693 #ifdef __cplusplus
694 }
695 #endif
696
697 #endif // !TARGET_API_MAC_CARBON
698
699 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ > 0x5300)
700
701 void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
702 {
703 wxString str;
704 TimeStamp(&str);
705 str << szString;
706
707 fputs(str.mb_str(), m_fp);
708 fputc(_T('\n'), m_fp);
709 fflush(m_fp);
710
711 // under Windows, programs usually don't have stderr at all, so show the
712 // messages also under debugger - unless it's a console program
713 #if defined(__WXMSW__) && wxUSE_GUI && !defined(__WXMICROWIN__)
714 str += wxT("\r\n") ;
715 OutputDebugString(str.c_str());
716 #endif // MSW
717 #if defined(__WXMAC__) && !defined(__DARWIN__) && wxUSE_GUI
718 Str255 pstr ;
719 strcpy( (char*) pstr , str.c_str() ) ;
720 strcat( (char*) pstr , ";g" ) ;
721 c2pstr( (char*) pstr ) ;
722
723 Boolean running = false ;
724
725 #if !TARGET_API_MAC_CARBON && (__MWERKS__ > 0x5300)
726
727 if ( IsMWDebuggerRunning() && AmIBeingMWDebugged() )
728 {
729 running = true ;
730 }
731
732 #endif
733
734 if (running)
735 {
736 #ifdef __powerc
737 DebugStr(pstr);
738 #else
739 SysBreakStr(pstr);
740 #endif
741 }
742 #endif // Mac
743 }
744
745 // ----------------------------------------------------------------------------
746 // wxLogStream implementation
747 // ----------------------------------------------------------------------------
748
749 #if wxUSE_STD_IOSTREAM
750 wxLogStream::wxLogStream(wxSTD ostream *ostr)
751 {
752 if ( ostr == NULL )
753 m_ostr = &wxSTD cerr;
754 else
755 m_ostr = ostr;
756 }
757
758 void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
759 {
760 wxString str;
761 TimeStamp(&str);
762 (*m_ostr) << str << wxConvertWX2MB(szString) << wxSTD endl;
763 }
764 #endif // wxUSE_STD_IOSTREAM
765
766 // ----------------------------------------------------------------------------
767 // wxLogChain
768 // ----------------------------------------------------------------------------
769
770 wxLogChain::wxLogChain(wxLog *logger)
771 {
772 m_bPassMessages = TRUE;
773
774 m_logNew = logger;
775 m_logOld = wxLog::SetActiveTarget(this);
776 }
777
778 wxLogChain::~wxLogChain()
779 {
780 delete m_logOld;
781
782 if ( m_logNew != this )
783 delete m_logNew;
784 }
785
786 void wxLogChain::SetLog(wxLog *logger)
787 {
788 if ( m_logNew != this )
789 delete m_logNew;
790
791 m_logNew = logger;
792 }
793
794 void wxLogChain::Flush()
795 {
796 if ( m_logOld )
797 m_logOld->Flush();
798
799 // be careful to avoid inifinite recursion
800 if ( m_logNew && m_logNew != this )
801 m_logNew->Flush();
802 }
803
804 void wxLogChain::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
805 {
806 // let the previous logger show it
807 if ( m_logOld && IsPassingMessages() )
808 {
809 // bogus cast just to access protected DoLog
810 ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
811 }
812
813 if ( m_logNew && m_logNew != this )
814 {
815 // as above...
816 ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
817 }
818 }
819
820 // ----------------------------------------------------------------------------
821 // wxLogPassThrough
822 // ----------------------------------------------------------------------------
823
824 #ifdef __VISUALC__
825 // "'this' : used in base member initializer list" - so what?
826 #pragma warning(disable:4355)
827 #endif // VC++
828
829 wxLogPassThrough::wxLogPassThrough()
830 : wxLogChain(this)
831 {
832 }
833
834 #ifdef __VISUALC__
835 #pragma warning(default:4355)
836 #endif // VC++
837
838 // ============================================================================
839 // Global functions/variables
840 // ============================================================================
841
842 // ----------------------------------------------------------------------------
843 // static variables
844 // ----------------------------------------------------------------------------
845
846 wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
847 bool wxLog::ms_doLog = TRUE;
848 bool wxLog::ms_bAutoCreate = TRUE;
849 bool wxLog::ms_bVerbose = FALSE;
850
851 size_t wxLog::ms_suspendCount = 0;
852
853 #if wxUSE_GUI
854 const wxChar *wxLog::ms_timestamp = wxT("%X"); // time only, no date
855 #else
856 const wxChar *wxLog::ms_timestamp = NULL; // save space
857 #endif
858
859 wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
860 wxArrayString wxLog::ms_aTraceMasks;
861
862 // ----------------------------------------------------------------------------
863 // stdout error logging helper
864 // ----------------------------------------------------------------------------
865
866 // helper function: wraps the message and justifies it under given position
867 // (looks more pretty on the terminal). Also adds newline at the end.
868 //
869 // TODO this is now disabled until I find a portable way of determining the
870 // terminal window size (ok, I found it but does anybody really cares?)
871 #ifdef LOG_PRETTY_WRAP
872 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
873 {
874 size_t nMax = 80; // FIXME
875 size_t nStart = strlen(pszPrefix);
876 fputs(pszPrefix, f);
877
878 size_t n;
879 while ( *psz != '\0' ) {
880 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
881 putc(*psz++, f);
882
883 // wrapped?
884 if ( *psz != '\0' ) {
885 /*putc('\n', f);*/
886 for ( n = 0; n < nStart; n++ )
887 putc(' ', f);
888
889 // as we wrapped, squeeze all white space
890 while ( isspace(*psz) )
891 psz++;
892 }
893 }
894
895 putc('\n', f);
896 }
897 #endif //LOG_PRETTY_WRAP
898
899 // ----------------------------------------------------------------------------
900 // error code/error message retrieval functions
901 // ----------------------------------------------------------------------------
902
903 // get error code from syste
904 unsigned long wxSysErrorCode()
905 {
906 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
907 #ifdef __WIN32__
908 return ::GetLastError();
909 #else //WIN16
910 // TODO what to do on Windows 3.1?
911 return 0;
912 #endif //WIN16/32
913 #else //Unix
914 return errno;
915 #endif //Win/Unix
916 }
917
918 // get error message from system
919 const wxChar *wxSysErrorMsg(unsigned long nErrCode)
920 {
921 if ( nErrCode == 0 )
922 nErrCode = wxSysErrorCode();
923
924 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
925 #ifdef __WIN32__
926 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
927
928 // get error message from system
929 LPVOID lpMsgBuf;
930 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
931 NULL, nErrCode,
932 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
933 (LPTSTR)&lpMsgBuf,
934 0, NULL);
935
936 // copy it to our buffer and free memory
937 if( lpMsgBuf != 0 ) {
938 wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
939 s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
940
941 LocalFree(lpMsgBuf);
942
943 // returned string is capitalized and ended with '\r\n' - bad
944 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
945 size_t len = wxStrlen(s_szBuf);
946 if ( len > 0 ) {
947 // truncate string
948 if ( s_szBuf[len - 2] == wxT('\r') )
949 s_szBuf[len - 2] = wxT('\0');
950 }
951 }
952 else {
953 s_szBuf[0] = wxT('\0');
954 }
955
956 return s_szBuf;
957 #else //Win16
958 // TODO
959 return NULL;
960 #endif // Win16/32
961 #else // Unix
962 #if wxUSE_UNICODE
963 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
964 wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
965 return s_szBuf;
966 #else
967 return strerror((int)nErrCode);
968 #endif
969 #endif // Win/Unix
970 }
971
972 #endif //wxUSE_LOG
973
974 // vi:sts=4:sw=4:et