1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "log.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/string.h"
38 #include "wx/window.h"
40 #include "wx/msw/private.h"
42 #include "wx/msgdlg.h"
47 #include "wx/textfile.h"
49 #include "wx/wxchar.h"
51 #include "wx/thread.h"
55 // other standard headers
60 #if defined(__WXMSW__)
61 #include "wx/msw/private.h" // includes windows.h for OutputDebugString
64 #if !defined(__WXMSW__) || defined(__WXMICROWIN__)
68 // ----------------------------------------------------------------------------
69 // non member functions
70 // ----------------------------------------------------------------------------
72 // define this to enable wrapping of log messages
73 //#define LOG_PRETTY_WRAP
75 #ifdef LOG_PRETTY_WRAP
76 static void wxLogWrap(FILE *f
, const char *pszPrefix
, const char *psz
);
79 // ============================================================================
81 // ============================================================================
83 // ----------------------------------------------------------------------------
85 // ----------------------------------------------------------------------------
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)
91 // static buffer for error messages
92 static wxChar s_szBuf
[LOG_BUFFER_SIZE
];
96 // the critical section protecting the static buffer
97 static wxCriticalSection gs_csLogBuf
;
99 #endif // wxUSE_THREADS
101 // return true if we have a non NULL non disabled log target
102 static inline bool IsLoggingEnabled()
104 return wxLog::IsEnabled() && (wxLog::GetActiveTarget() != NULL
);
107 // ----------------------------------------------------------------------------
108 // implementation of Log functions
110 // NB: unfortunately we need all these distinct functions, we can't make them
111 // macros and not all compilers inline vararg functions.
112 // ----------------------------------------------------------------------------
114 // generic log function
115 void wxLogGeneric(wxLogLevel level
, const wxChar
*szFormat
, ...)
117 if ( IsLoggingEnabled() ) {
118 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
121 va_start(argptr
, szFormat
);
122 wxVsnprintf(s_szBuf
, WXSIZEOF(s_szBuf
), szFormat
, argptr
);
125 wxLog::OnLog(level
, s_szBuf
, time(NULL
));
129 #define IMPLEMENT_LOG_FUNCTION(level) \
130 void wxLog##level(const wxChar *szFormat, ...) \
132 if ( IsLoggingEnabled() ) { \
133 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
136 va_start(argptr, szFormat); \
137 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr); \
140 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
144 IMPLEMENT_LOG_FUNCTION(FatalError
)
145 IMPLEMENT_LOG_FUNCTION(Error
)
146 IMPLEMENT_LOG_FUNCTION(Warning
)
147 IMPLEMENT_LOG_FUNCTION(Message
)
148 IMPLEMENT_LOG_FUNCTION(Info
)
149 IMPLEMENT_LOG_FUNCTION(Status
)
151 // same as info, but only if 'verbose' mode is on
152 void wxLogVerbose(const wxChar
*szFormat
, ...)
154 if ( IsLoggingEnabled() ) {
155 wxLog
*pLog
= wxLog::GetActiveTarget();
156 if ( pLog
!= NULL
&& pLog
->GetVerbose() ) {
157 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
160 va_start(argptr
, szFormat
);
161 wxVsnprintf(s_szBuf
, WXSIZEOF(s_szBuf
), szFormat
, argptr
);
164 wxLog::OnLog(wxLOG_Info
, s_szBuf
, time(NULL
));
171 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
172 void wxLog##level(const wxChar *szFormat, ...) \
174 if ( IsLoggingEnabled() ) { \
175 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
178 va_start(argptr, szFormat); \
179 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr); \
182 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
186 void wxLogTrace(const wxChar
*mask
, const wxChar
*szFormat
, ...)
188 if ( IsLoggingEnabled() && wxLog::IsAllowedTraceMask(mask
) ) {
189 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
192 size_t len
= WXSIZEOF(s_szBuf
);
193 wxStrncpy(s_szBuf
, _T("("), len
);
194 len
-= 1; // strlen("(")
196 wxStrncat(p
, mask
, len
);
197 size_t lenMask
= wxStrlen(mask
);
201 wxStrncat(p
, _T(") "), len
);
206 va_start(argptr
, szFormat
);
207 wxVsnprintf(p
, len
, szFormat
, argptr
);
210 wxLog::OnLog(wxLOG_Trace
, s_szBuf
, time(NULL
));
214 void wxLogTrace(wxTraceMask mask
, const wxChar
*szFormat
, ...)
216 // we check that all of mask bits are set in the current mask, so
217 // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
218 // if both bits are set.
219 if ( IsLoggingEnabled() && ((wxLog::GetTraceMask() & mask
) == mask
) ) {
220 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
223 va_start(argptr
, szFormat
);
224 wxVsnprintf(s_szBuf
, WXSIZEOF(s_szBuf
), szFormat
, argptr
);
227 wxLog::OnLog(wxLOG_Trace
, s_szBuf
, time(NULL
));
232 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
235 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug
)
236 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace
)
238 // wxLogSysError: one uses the last error code, for other you must give it
241 // common part of both wxLogSysError
242 void wxLogSysErrorHelper(long lErrCode
)
244 wxChar szErrMsg
[LOG_BUFFER_SIZE
/ 2];
245 wxSnprintf(szErrMsg
, WXSIZEOF(szErrMsg
),
246 _(" (error %ld: %s)"), lErrCode
, wxSysErrorMsg(lErrCode
));
247 wxStrncat(s_szBuf
, szErrMsg
, WXSIZEOF(s_szBuf
) - wxStrlen(s_szBuf
));
249 wxLog::OnLog(wxLOG_Error
, s_szBuf
, time(NULL
));
252 void WXDLLEXPORT
wxLogSysError(const wxChar
*szFormat
, ...)
254 if ( IsLoggingEnabled() ) {
255 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
258 va_start(argptr
, szFormat
);
259 wxVsnprintf(s_szBuf
, WXSIZEOF(s_szBuf
), szFormat
, argptr
);
262 wxLogSysErrorHelper(wxSysErrorCode());
266 void WXDLLEXPORT
wxLogSysError(long lErrCode
, const wxChar
*szFormat
, ...)
268 if ( IsLoggingEnabled() ) {
269 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
272 va_start(argptr
, szFormat
);
273 wxVsnprintf(s_szBuf
, WXSIZEOF(s_szBuf
), szFormat
, argptr
);
276 wxLogSysErrorHelper(lErrCode
);
280 // ----------------------------------------------------------------------------
281 // wxLog class implementation
282 // ----------------------------------------------------------------------------
286 m_bHasMessages
= FALSE
;
289 wxLog
*wxLog::GetActiveTarget()
291 if ( ms_bAutoCreate
&& ms_pLogger
== NULL
) {
292 // prevent infinite recursion if someone calls wxLogXXX() from
293 // wxApp::CreateLogTarget()
294 static bool s_bInGetActiveTarget
= FALSE
;
295 if ( !s_bInGetActiveTarget
) {
296 s_bInGetActiveTarget
= TRUE
;
298 // ask the application to create a log target for us
299 if ( wxTheApp
!= NULL
)
300 ms_pLogger
= wxTheApp
->CreateLogTarget();
302 ms_pLogger
= new wxLogStderr
;
304 s_bInGetActiveTarget
= FALSE
;
306 // do nothing if it fails - what can we do?
313 wxLog
*wxLog::SetActiveTarget(wxLog
*pLogger
)
315 if ( ms_pLogger
!= NULL
) {
316 // flush the old messages before changing because otherwise they might
317 // get lost later if this target is not restored
321 wxLog
*pOldLogger
= ms_pLogger
;
322 ms_pLogger
= pLogger
;
327 void wxLog::DontCreateOnDemand()
329 ms_bAutoCreate
= FALSE
;
331 // this is usually called at the end of the program and we assume that it
332 // is *always* called at the end - so we free memory here to avoid false
333 // memory leak reports from wxWin memory tracking code
337 void wxLog::RemoveTraceMask(const wxString
& str
)
339 int index
= ms_aTraceMasks
.Index(str
);
340 if ( index
!= wxNOT_FOUND
)
341 ms_aTraceMasks
.Remove((size_t)index
);
344 void wxLog::ClearTraceMasks()
346 ms_aTraceMasks
.Clear();
349 void wxLog::TimeStamp(wxString
*str
)
355 (void)time(&timeNow
);
356 wxStrftime(buf
, WXSIZEOF(buf
), ms_timestamp
, localtime(&timeNow
));
359 *str
<< buf
<< wxT(": ");
363 void wxLog::DoLog(wxLogLevel level
, const wxChar
*szString
, time_t t
)
366 case wxLOG_FatalError
:
367 DoLogString(wxString(_("Fatal error: ")) + szString
, t
);
368 DoLogString(_("Program aborted."), t
);
374 DoLogString(wxString(_("Error: ")) + szString
, t
);
378 DoLogString(wxString(_("Warning: ")) + szString
, t
);
385 default: // log unknown log levels too
386 DoLogString(szString
, t
);
393 wxString msg
= level
== wxLOG_Trace
? wxT("Trace: ")
403 void wxLog::DoLogString(const wxChar
*WXUNUSED(szString
), time_t WXUNUSED(t
))
405 wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
413 // ----------------------------------------------------------------------------
414 // wxLogStderr class implementation
415 // ----------------------------------------------------------------------------
417 wxLogStderr::wxLogStderr(FILE *fp
)
425 #if defined(__WXMAC__) && !defined(__UNIX__)
426 #define kDebuggerSignature 'MWDB'
428 static Boolean
FindProcessBySignature(OSType signature
, ProcessInfoRec
* info
)
431 ProcessSerialNumber psn
;
432 Boolean found
= false;
433 psn
.highLongOfPSN
= 0;
434 psn
.lowLongOfPSN
= kNoProcess
;
436 if (!info
) return false;
438 info
->processInfoLength
= sizeof(ProcessInfoRec
);
439 info
->processName
= NULL
;
440 info
->processAppSpec
= NULL
;
443 while (!found
&& err
== noErr
)
445 err
= GetNextProcess(&psn
);
448 err
= GetProcessInformation(&psn
, info
);
449 found
= err
== noErr
&& info
->processSignature
== signature
;
455 pascal Boolean
MWDebuggerIsRunning(void)
458 return FindProcessBySignature(kDebuggerSignature
, &info
);
461 pascal OSErr
AmIBeingMWDebugged(Boolean
* result
)
464 ProcessSerialNumber psn
;
465 OSType sig
= kDebuggerSignature
;
466 AppleEvent theAE
= {typeNull
, NULL
};
467 AppleEvent theReply
= {typeNull
, NULL
};
468 AEAddressDesc addr
= {typeNull
, NULL
};
472 if (!result
) return paramErr
;
474 err
= AECreateDesc(typeApplSignature
, &sig
, sizeof(sig
), &addr
);
475 if (err
!= noErr
) goto exit
;
477 err
= AECreateAppleEvent('MWDB', 'Dbg?', &addr
,
478 kAutoGenerateReturnID
, kAnyTransactionID
, &theAE
);
479 if (err
!= noErr
) goto exit
;
481 GetCurrentProcess(&psn
);
482 err
= AEPutParamPtr(&theAE
, keyDirectObject
, typeProcessSerialNumber
,
484 if (err
!= noErr
) goto exit
;
486 err
= AESend(&theAE
, &theReply
, kAEWaitReply
, kAENormalPriority
,
487 kAEDefaultTimeout
, NULL
, NULL
);
488 if (err
!= noErr
) goto exit
;
490 err
= AEGetParamPtr(&theReply
, keyAEResult
, typeBoolean
, &actualType
, result
,
491 sizeof(Boolean
), &actualSize
);
495 AEDisposeDesc(&addr
);
496 if (theAE
.dataHandle
)
497 AEDisposeDesc(&theAE
);
498 if (theReply
.dataHandle
)
499 AEDisposeDesc(&theReply
);
505 void wxLogStderr::DoLogString(const wxChar
*szString
, time_t WXUNUSED(t
))
511 fputs(str
.mb_str(), m_fp
);
512 fputc(_T('\n'), m_fp
);
515 // under Windows, programs usually don't have stderr at all, so show the
516 // messages also under debugger - unless it's a console program
517 #if defined(__WXMSW__) && wxUSE_GUI && !defined(__WXMICROWIN__)
519 OutputDebugString(str
.c_str());
521 #if defined(__WXMAC__) && !defined(__WXMAC_X__) && wxUSE_GUI
523 strcpy( (char*) pstr
, str
.c_str() ) ;
524 strcat( (char*) pstr
, ";g" ) ;
525 c2pstr( (char*) pstr
) ;
527 Boolean running
= false ;
530 if ( MWDebuggerIsRunning() )
532 AmIBeingMWDebugged( &running ) ;
555 // ----------------------------------------------------------------------------
556 // wxLogStream implementation
557 // ----------------------------------------------------------------------------
559 #if wxUSE_STD_IOSTREAM
560 wxLogStream::wxLogStream(wxSTD ostream
*ostr
)
563 m_ostr
= &wxSTD cerr
;
568 void wxLogStream::DoLogString(const wxChar
*szString
, time_t WXUNUSED(t
))
572 (*m_ostr
) << str
<< wxConvertWX2MB(szString
) << wxSTD endl
;
574 #endif // wxUSE_STD_IOSTREAM
576 // ============================================================================
577 // Global functions/variables
578 // ============================================================================
580 // ----------------------------------------------------------------------------
582 // ----------------------------------------------------------------------------
584 wxLog
*wxLog::ms_pLogger
= (wxLog
*)NULL
;
585 bool wxLog::ms_doLog
= TRUE
;
586 bool wxLog::ms_bAutoCreate
= TRUE
;
587 bool wxLog::ms_bVerbose
= FALSE
;
589 size_t wxLog::ms_suspendCount
= 0;
592 const wxChar
*wxLog::ms_timestamp
= wxT("%X"); // time only, no date
594 const wxChar
*wxLog::ms_timestamp
= NULL
; // save space
597 wxTraceMask
wxLog::ms_ulTraceMask
= (wxTraceMask
)0;
598 wxArrayString
wxLog::ms_aTraceMasks
;
600 // ----------------------------------------------------------------------------
601 // stdout error logging helper
602 // ----------------------------------------------------------------------------
604 // helper function: wraps the message and justifies it under given position
605 // (looks more pretty on the terminal). Also adds newline at the end.
607 // TODO this is now disabled until I find a portable way of determining the
608 // terminal window size (ok, I found it but does anybody really cares?)
609 #ifdef LOG_PRETTY_WRAP
610 static void wxLogWrap(FILE *f
, const char *pszPrefix
, const char *psz
)
612 size_t nMax
= 80; // FIXME
613 size_t nStart
= strlen(pszPrefix
);
617 while ( *psz
!= '\0' ) {
618 for ( n
= nStart
; (n
< nMax
) && (*psz
!= '\0'); n
++ )
622 if ( *psz
!= '\0' ) {
624 for ( n
= 0; n
< nStart
; n
++ )
627 // as we wrapped, squeeze all white space
628 while ( isspace(*psz
) )
635 #endif //LOG_PRETTY_WRAP
637 // ----------------------------------------------------------------------------
638 // error code/error message retrieval functions
639 // ----------------------------------------------------------------------------
641 // get error code from syste
642 unsigned long wxSysErrorCode()
644 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
646 return ::GetLastError();
648 // TODO what to do on Windows 3.1?
656 // get error message from system
657 const wxChar
*wxSysErrorMsg(unsigned long nErrCode
)
660 nErrCode
= wxSysErrorCode();
662 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
664 static wxChar s_szBuf
[LOG_BUFFER_SIZE
/ 2];
666 // get error message from system
668 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
670 MAKELANGID(LANG_NEUTRAL
, SUBLANG_DEFAULT
),
674 // copy it to our buffer and free memory
675 wxStrncpy(s_szBuf
, (const wxChar
*)lpMsgBuf
, WXSIZEOF(s_szBuf
) - 1);
676 s_szBuf
[WXSIZEOF(s_szBuf
) - 1] = wxT('\0');
679 // returned string is capitalized and ended with '\r\n' - bad
680 s_szBuf
[0] = (wxChar
)wxTolower(s_szBuf
[0]);
681 size_t len
= wxStrlen(s_szBuf
);
684 if ( s_szBuf
[len
- 2] == wxT('\r') )
685 s_szBuf
[len
- 2] = wxT('\0');
695 static wxChar s_szBuf
[LOG_BUFFER_SIZE
/ 2];
696 wxConvCurrent
->MB2WC(s_szBuf
, strerror(nErrCode
), WXSIZEOF(s_szBuf
) -1);
699 return strerror((int)nErrCode
);
704 // ----------------------------------------------------------------------------
706 // ----------------------------------------------------------------------------
711 bool wxAssertIsEqual(int x
, int y
)
716 // break into the debugger
719 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
721 #elif defined(__WXMAC__)
727 #elif defined(__UNIX__)
734 // this function is called when an assert fails
735 void wxOnAssert(const wxChar
*szFile
, int nLine
, const wxChar
*szMsg
)
737 // this variable can be set to true to suppress "assert failure" messages
738 static bool s_bNoAsserts
= FALSE
;
739 static bool s_bInAssert
= FALSE
; // FIXME MT-unsafe
742 // He-e-e-e-elp!! we're trapped in endless loop
752 wxChar szBuf
[LOG_BUFFER_SIZE
];
754 // make life easier for people using VC++ IDE: clicking on the message
755 // will take us immediately to the place of the failed assert
756 wxSnprintf(szBuf
, WXSIZEOF(szBuf
),
758 wxT("%s(%d): assert failed"),
760 // make the error message more clear for all the others
761 wxT("Assert failed in file %s at line %d"),
765 if ( szMsg
!= NULL
) {
766 wxStrcat(szBuf
, wxT(": "));
767 wxStrcat(szBuf
, szMsg
);
770 wxStrcat(szBuf
, wxT("."));
773 if ( !s_bNoAsserts
) {
774 // send it to the normal log destination
777 #if (wxUSE_GUI && wxUSE_MSGDLG) || defined(__WXMSW__)
778 // this message is intentionally not translated - it is for
780 wxStrcat(szBuf
, wxT("\nDo you want to stop the program?\nYou can also choose [Cancel] to suppress further warnings."));
782 // use the native message box if available: this is more robust than
784 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
785 switch ( ::MessageBox(NULL
, szBuf
, _T("Debug"),
786 MB_YESNOCANCEL
| MB_ICONSTOP
) ) {
795 //case IDNO: nothing to do
798 switch ( wxMessageBox(szBuf
, wxT("Debug"),
799 wxYES_NO
| wxCANCEL
| wxICON_STOP
) ) {
808 //case wxNO: nothing to do