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 licence
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"
39 #include "wx/msgdlg.h"
41 #include "wx/msw/private.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(__WXMAC__)
65 #include "wx/mac/private.h" // includes mac headers
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_szBufStatic
[LOG_BUFFER_SIZE
];
94 static wxChar
*s_szBuf
= s_szBufStatic
;
95 static size_t s_szBufSize
= WXSIZEOF( s_szBufStatic
);
99 // the critical section protecting the static buffer
100 static wxCriticalSection gs_csLogBuf
;
102 #endif // wxUSE_THREADS
104 // return true if we have a non NULL non disabled log target
105 static inline bool IsLoggingEnabled()
107 return wxLog::IsEnabled() && (wxLog::GetActiveTarget() != NULL
);
110 // ----------------------------------------------------------------------------
111 // implementation of Log functions
113 // NB: unfortunately we need all these distinct functions, we can't make them
114 // macros and not all compilers inline vararg functions.
115 // ----------------------------------------------------------------------------
117 // generic log function
118 void wxVLogGeneric(wxLogLevel level
, const wxChar
*szFormat
, va_list argptr
)
120 if ( IsLoggingEnabled() ) {
121 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
123 wxVsnprintf(s_szBuf
, s_szBufSize
, szFormat
, argptr
);
125 wxLog::OnLog(level
, s_szBuf
, time(NULL
));
129 void wxLogGeneric(wxLogLevel level
, const wxChar
*szFormat
, ...)
132 va_start(argptr
, szFormat
);
133 wxVLogGeneric(level
, szFormat
, argptr
);
137 #define IMPLEMENT_LOG_FUNCTION(level) \
138 void wxVLog##level(const wxChar *szFormat, va_list argptr) \
140 if ( IsLoggingEnabled() ) { \
141 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
143 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr); \
145 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
148 void wxLog##level(const wxChar *szFormat, ...) \
151 va_start(argptr, szFormat); \
152 wxVLog##level(szFormat, argptr); \
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
)
162 void wxSafeShowMessage(const wxString
& title
, const wxString
& text
)
165 ::MessageBox(NULL
, text
, title
, MB_OK
| MB_ICONSTOP
);
167 wxFprintf(stderr
, _T("%s: %s\n"), title
.c_str(), text
.c_str());
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
)
175 wxVsnprintf(s_szBuf
, s_szBufSize
, szFormat
, argptr
);
177 wxSafeShowMessage(_T("Fatal Error"), s_szBuf
);
182 void wxLogFatalError(const wxChar
*szFormat
, ...)
185 va_start(argptr
, szFormat
);
186 wxVLogFatalError(szFormat
, argptr
);
190 // same as info, but only if 'verbose' mode is on
191 void wxVLogVerbose(const wxChar
*szFormat
, va_list argptr
)
193 if ( IsLoggingEnabled() ) {
194 wxLog
*pLog
= wxLog::GetActiveTarget();
195 if ( pLog
!= NULL
&& pLog
->GetVerbose() ) {
196 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
198 wxVsnprintf(s_szBuf
, s_szBufSize
, szFormat
, argptr
);
200 wxLog::OnLog(wxLOG_Info
, s_szBuf
, time(NULL
));
205 void wxLogVerbose(const wxChar
*szFormat
, ...)
208 va_start(argptr
, szFormat
);
209 wxVLogVerbose(szFormat
, argptr
);
215 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
216 void wxVLog##level(const wxChar *szFormat, va_list argptr) \
218 if ( IsLoggingEnabled() ) { \
219 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
221 wxVsnprintf(s_szBuf, s_szBufSize, szFormat, argptr); \
223 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
226 void wxLog##level(const wxChar *szFormat, ...) \
229 va_start(argptr, szFormat); \
230 wxVLog##level(szFormat, argptr); \
234 void wxVLogTrace(const wxChar
*mask
, const wxChar
*szFormat
, va_list argptr
)
236 if ( IsLoggingEnabled() && wxLog::IsAllowedTraceMask(mask
) ) {
237 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
240 size_t len
= s_szBufSize
;
241 wxStrncpy(s_szBuf
, _T("("), len
);
242 len
-= 1; // strlen("(")
244 wxStrncat(p
, mask
, len
);
245 size_t lenMask
= wxStrlen(mask
);
249 wxStrncat(p
, _T(") "), len
);
253 wxVsnprintf(p
, len
, szFormat
, argptr
);
255 wxLog::OnLog(wxLOG_Trace
, s_szBuf
, time(NULL
));
259 void wxLogTrace(const wxChar
*mask
, const wxChar
*szFormat
, ...)
262 va_start(argptr
, szFormat
);
263 wxVLogTrace(mask
, szFormat
, argptr
);
267 void wxVLogTrace(wxTraceMask mask
, const wxChar
*szFormat
, va_list argptr
)
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
);
275 wxVsnprintf(s_szBuf
, s_szBufSize
, szFormat
, argptr
);
277 wxLog::OnLog(wxLOG_Trace
, s_szBuf
, time(NULL
));
281 void wxLogTrace(wxTraceMask mask
, const wxChar
*szFormat
, ...)
284 va_start(argptr
, szFormat
);
285 wxVLogTrace(mask
, szFormat
, argptr
);
290 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
293 IMPLEMENT_LOG_DEBUG_FUNCTION(Debug
)
294 IMPLEMENT_LOG_DEBUG_FUNCTION(Trace
)
296 // wxLogSysError: one uses the last error code, for other you must give it
299 // common part of both wxLogSysError
300 void wxLogSysErrorHelper(long lErrCode
)
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
));
307 wxLog::OnLog(wxLOG_Error
, s_szBuf
, time(NULL
));
310 void WXDLLEXPORT
wxVLogSysError(const wxChar
*szFormat
, va_list argptr
)
312 if ( IsLoggingEnabled() ) {
313 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
315 wxVsnprintf(s_szBuf
, s_szBufSize
, szFormat
, argptr
);
317 wxLogSysErrorHelper(wxSysErrorCode());
321 void WXDLLEXPORT
wxLogSysError(const wxChar
*szFormat
, ...)
324 va_start(argptr
, szFormat
);
325 wxVLogSysError(szFormat
, argptr
);
329 void WXDLLEXPORT
wxVLogSysError(long lErrCode
, const wxChar
*szFormat
, va_list argptr
)
331 if ( IsLoggingEnabled() ) {
332 wxCRIT_SECT_LOCKER(locker
, gs_csLogBuf
);
334 wxVsnprintf(s_szBuf
, s_szBufSize
, szFormat
, argptr
);
336 wxLogSysErrorHelper(lErrCode
);
340 void WXDLLEXPORT
wxLogSysError(long lErrCode
, const wxChar
*szFormat
, ...)
343 va_start(argptr
, szFormat
);
344 wxVLogSysError(lErrCode
, szFormat
, argptr
);
348 // ----------------------------------------------------------------------------
349 // wxLog class implementation
350 // ----------------------------------------------------------------------------
356 wxChar
*wxLog::SetLogBuffer( wxChar
*buf
, size_t size
)
358 wxChar
*oldbuf
= s_szBuf
;
362 s_szBuf
= s_szBufStatic
;
363 s_szBufSize
= WXSIZEOF( s_szBufStatic
);
371 return (oldbuf
== s_szBufStatic
) ? 0 : oldbuf
;
374 wxLog
*wxLog::GetActiveTarget()
376 if ( ms_bAutoCreate
&& ms_pLogger
== NULL
) {
377 // prevent infinite recursion if someone calls wxLogXXX() from
378 // wxApp::CreateLogTarget()
379 static bool s_bInGetActiveTarget
= FALSE
;
380 if ( !s_bInGetActiveTarget
) {
381 s_bInGetActiveTarget
= TRUE
;
383 // ask the application to create a log target for us
384 if ( wxTheApp
!= NULL
)
385 ms_pLogger
= wxTheApp
->CreateLogTarget();
387 ms_pLogger
= new wxLogStderr
;
389 s_bInGetActiveTarget
= FALSE
;
391 // do nothing if it fails - what can we do?
398 wxLog
*wxLog::SetActiveTarget(wxLog
*pLogger
)
400 if ( ms_pLogger
!= NULL
) {
401 // flush the old messages before changing because otherwise they might
402 // get lost later if this target is not restored
406 wxLog
*pOldLogger
= ms_pLogger
;
407 ms_pLogger
= pLogger
;
412 void wxLog::DontCreateOnDemand()
414 ms_bAutoCreate
= FALSE
;
416 // this is usually called at the end of the program and we assume that it
417 // is *always* called at the end - so we free memory here to avoid false
418 // memory leak reports from wxWin memory tracking code
422 void wxLog::RemoveTraceMask(const wxString
& str
)
424 int index
= ms_aTraceMasks
.Index(str
);
425 if ( index
!= wxNOT_FOUND
)
426 ms_aTraceMasks
.Remove((size_t)index
);
429 void wxLog::ClearTraceMasks()
431 ms_aTraceMasks
.Clear();
434 void wxLog::TimeStamp(wxString
*str
)
440 (void)time(&timeNow
);
441 wxStrftime(buf
, WXSIZEOF(buf
), ms_timestamp
, localtime(&timeNow
));
444 *str
<< buf
<< wxT(": ");
448 void wxLog::DoLog(wxLogLevel level
, const wxChar
*szString
, time_t t
)
451 case wxLOG_FatalError
:
452 DoLogString(wxString(_("Fatal error: ")) + szString
, t
);
453 DoLogString(_("Program aborted."), t
);
459 DoLogString(wxString(_("Error: ")) + szString
, t
);
463 DoLogString(wxString(_("Warning: ")) + szString
, t
);
470 default: // log unknown log levels too
471 DoLogString(szString
, t
);
478 wxString msg
= level
== wxLOG_Trace
? wxT("Trace: ")
488 void wxLog::DoLogString(const wxChar
*WXUNUSED(szString
), time_t WXUNUSED(t
))
490 wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
495 // nothing to do here
498 // ----------------------------------------------------------------------------
499 // wxLogStderr class implementation
500 // ----------------------------------------------------------------------------
502 wxLogStderr::wxLogStderr(FILE *fp
)
510 #if defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
512 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
514 #ifndef __MetroNubUtils__
515 #include "MetroNubUtils.h"
534 #if TARGET_API_MAC_CARBON
536 #include <CodeFragments.h>
539 CallUniversalProc(UniversalProcPtr theProcPtr
, ProcInfoType procInfo
, ...);
541 ProcPtr gCallUniversalProc_Proc
= NULL
;
545 static MetroNubUserEntryBlock
* gMetroNubEntry
= NULL
;
547 static long fRunOnce
= false;
549 Boolean
IsCompatibleVersion(short inVersion
);
551 /* ---------------------------------------------------------------------------
553 --------------------------------------------------------------------------- */
555 Boolean
IsCompatibleVersion(short inVersion
)
557 Boolean result
= false;
561 MetroNubUserEntryBlock
* block
= (MetroNubUserEntryBlock
*)result
;
563 result
= (inVersion
<= block
->apiHiVersion
);
569 /* ---------------------------------------------------------------------------
571 --------------------------------------------------------------------------- */
573 Boolean
IsMetroNubInstalled()
580 gMetroNubEntry
= NULL
;
582 if (Gestalt(gestaltSystemVersion
, &value
) == noErr
&& value
< 0x1000)
584 /* look for MetroNub's Gestalt selector */
585 if (Gestalt(kMetroNubUserSignature
, &result
) == noErr
)
588 #if TARGET_API_MAC_CARBON
589 if (gCallUniversalProc_Proc
== NULL
)
591 CFragConnectionID connectionID
;
594 ProcPtr symbolAddress
;
596 CFragSymbolClass symbolClass
;
598 symbolAddress
= NULL
;
599 err
= GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch
, kFindCFrag
,
600 &connectionID
, &mainAddress
, errorString
);
604 gCallUniversalProc_Proc
= NULL
;
608 err
= FindSymbol(connectionID
, "\pCallUniversalProc",
609 (Ptr
*) &gCallUniversalProc_Proc
, &symbolClass
);
613 gCallUniversalProc_Proc
= NULL
;
620 MetroNubUserEntryBlock
* block
= (MetroNubUserEntryBlock
*)result
;
622 /* make sure the version of the API is compatible */
623 if (block
->apiLowVersion
<= kMetroNubUserAPIVersion
&&
624 kMetroNubUserAPIVersion
<= block
->apiHiVersion
)
625 gMetroNubEntry
= block
; /* success! */
634 #if TARGET_API_MAC_CARBON
635 return (gMetroNubEntry
!= NULL
&& gCallUniversalProc_Proc
!= NULL
);
637 return (gMetroNubEntry
!= NULL
);
641 /* ---------------------------------------------------------------------------
642 IsMWDebuggerRunning [v1 API]
643 --------------------------------------------------------------------------- */
645 Boolean
IsMWDebuggerRunning()
647 if (IsMetroNubInstalled())
648 return CallIsDebuggerRunningProc(gMetroNubEntry
->isDebuggerRunning
);
653 /* ---------------------------------------------------------------------------
654 AmIBeingMWDebugged [v1 API]
655 --------------------------------------------------------------------------- */
657 Boolean
AmIBeingMWDebugged()
659 if (IsMetroNubInstalled())
660 return CallAmIBeingDebuggedProc(gMetroNubEntry
->amIBeingDebugged
);
665 /* ---------------------------------------------------------------------------
666 UserSetWatchPoint [v2 API]
667 --------------------------------------------------------------------------- */
669 OSErr
UserSetWatchPoint (Ptr address
, long length
, WatchPointIDT
* watchPointID
)
671 if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion
))
672 return CallUserSetWatchPointProc(gMetroNubEntry
->userSetWatchPoint
,
673 address
, length
, watchPointID
);
675 return errProcessIsNotClient
;
678 /* ---------------------------------------------------------------------------
679 ClearWatchPoint [v2 API]
680 --------------------------------------------------------------------------- */
682 OSErr
ClearWatchPoint (WatchPointIDT watchPointID
)
684 if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion
))
685 return CallClearWatchPointProc(gMetroNubEntry
->clearWatchPoint
, watchPointID
);
687 return errProcessIsNotClient
;
694 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
696 void wxLogStderr::DoLogString(const wxChar
*szString
, time_t WXUNUSED(t
))
702 fputs(str
.mb_str(), m_fp
);
703 fputc(_T('\n'), m_fp
);
706 // under Windows, programs usually don't have stderr at all, so show the
707 // messages also under debugger (unless it's a console program which does
708 // have stderr or unless this is a file logger which doesn't use stderr at
710 #if defined(__WXMSW__) && wxUSE_GUI && !defined(__WXMICROWIN__)
711 if ( m_fp
== stderr
)
714 OutputDebugString(str
.c_str());
718 #if defined(__WXMAC__) && !defined(__DARWIN__) && wxUSE_GUI
720 wxString output
= str
+ wxT(";g") ;
721 wxMacStringToPascal( output
.c_str() , pstr
) ;
723 Boolean running
= false ;
725 #if defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
727 if ( IsMWDebuggerRunning() && AmIBeingMWDebugged() )
745 // ----------------------------------------------------------------------------
746 // wxLogStream implementation
747 // ----------------------------------------------------------------------------
749 #if wxUSE_STD_IOSTREAM
750 #include "wx/ioswrap.h"
751 wxLogStream::wxLogStream(wxSTD ostream
*ostr
)
754 m_ostr
= &wxSTD cerr
;
759 void wxLogStream::DoLogString(const wxChar
*szString
, time_t WXUNUSED(t
))
763 (*m_ostr
) << str
<< wxConvertWX2MB(szString
) << wxSTD endl
;
765 #endif // wxUSE_STD_IOSTREAM
767 // ----------------------------------------------------------------------------
769 // ----------------------------------------------------------------------------
771 wxLogChain::wxLogChain(wxLog
*logger
)
773 m_bPassMessages
= TRUE
;
776 m_logOld
= wxLog::SetActiveTarget(this);
779 wxLogChain::~wxLogChain()
783 if ( m_logNew
!= this )
787 void wxLogChain::SetLog(wxLog
*logger
)
789 if ( m_logNew
!= this )
795 void wxLogChain::Flush()
800 // be careful to avoid infinite recursion
801 if ( m_logNew
&& m_logNew
!= this )
805 void wxLogChain::DoLog(wxLogLevel level
, const wxChar
*szString
, time_t t
)
807 // let the previous logger show it
808 if ( m_logOld
&& IsPassingMessages() )
810 // bogus cast just to access protected DoLog
811 ((wxLogChain
*)m_logOld
)->DoLog(level
, szString
, t
);
814 if ( m_logNew
&& m_logNew
!= this )
817 ((wxLogChain
*)m_logNew
)->DoLog(level
, szString
, t
);
821 // ----------------------------------------------------------------------------
823 // ----------------------------------------------------------------------------
826 // "'this' : used in base member initializer list" - so what?
827 #pragma warning(disable:4355)
830 wxLogPassThrough::wxLogPassThrough()
836 #pragma warning(default:4355)
839 // ============================================================================
840 // Global functions/variables
841 // ============================================================================
843 // ----------------------------------------------------------------------------
845 // ----------------------------------------------------------------------------
847 wxLog
*wxLog::ms_pLogger
= (wxLog
*)NULL
;
848 bool wxLog::ms_doLog
= TRUE
;
849 bool wxLog::ms_bAutoCreate
= TRUE
;
850 bool wxLog::ms_bVerbose
= FALSE
;
852 wxLogLevel
wxLog::ms_logLevel
= wxLOG_Max
; // log everything by default
854 size_t wxLog::ms_suspendCount
= 0;
857 const wxChar
*wxLog::ms_timestamp
= wxT("%X"); // time only, no date
859 const wxChar
*wxLog::ms_timestamp
= NULL
; // save space
862 wxTraceMask
wxLog::ms_ulTraceMask
= (wxTraceMask
)0;
863 wxArrayString
wxLog::ms_aTraceMasks
;
865 // ----------------------------------------------------------------------------
866 // stdout error logging helper
867 // ----------------------------------------------------------------------------
869 // helper function: wraps the message and justifies it under given position
870 // (looks more pretty on the terminal). Also adds newline at the end.
872 // TODO this is now disabled until I find a portable way of determining the
873 // terminal window size (ok, I found it but does anybody really cares?)
874 #ifdef LOG_PRETTY_WRAP
875 static void wxLogWrap(FILE *f
, const char *pszPrefix
, const char *psz
)
877 size_t nMax
= 80; // FIXME
878 size_t nStart
= strlen(pszPrefix
);
882 while ( *psz
!= '\0' ) {
883 for ( n
= nStart
; (n
< nMax
) && (*psz
!= '\0'); n
++ )
887 if ( *psz
!= '\0' ) {
889 for ( n
= 0; n
< nStart
; n
++ )
892 // as we wrapped, squeeze all white space
893 while ( isspace(*psz
) )
900 #endif //LOG_PRETTY_WRAP
902 // ----------------------------------------------------------------------------
903 // error code/error message retrieval functions
904 // ----------------------------------------------------------------------------
906 // get error code from syste
907 unsigned long wxSysErrorCode()
909 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
911 return ::GetLastError();
913 // TODO what to do on Windows 3.1?
921 // get error message from system
922 const wxChar
*wxSysErrorMsg(unsigned long nErrCode
)
925 nErrCode
= wxSysErrorCode();
927 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
929 static wxChar s_szBuf
[LOG_BUFFER_SIZE
/ 2];
931 // get error message from system
933 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
935 MAKELANGID(LANG_NEUTRAL
, SUBLANG_DEFAULT
),
939 // copy it to our buffer and free memory
940 if( lpMsgBuf
!= 0 ) {
941 wxStrncpy(s_szBuf
, (const wxChar
*)lpMsgBuf
, WXSIZEOF(s_szBuf
) - 1);
942 s_szBuf
[WXSIZEOF(s_szBuf
) - 1] = wxT('\0');
946 // returned string is capitalized and ended with '\r\n' - bad
947 s_szBuf
[0] = (wxChar
)wxTolower(s_szBuf
[0]);
948 size_t len
= wxStrlen(s_szBuf
);
951 if ( s_szBuf
[len
- 2] == wxT('\r') )
952 s_szBuf
[len
- 2] = wxT('\0');
956 s_szBuf
[0] = wxT('\0');
966 static wxChar s_szBuf
[LOG_BUFFER_SIZE
/ 2];
967 wxConvCurrent
->MB2WC(s_szBuf
, strerror(nErrCode
), WXSIZEOF(s_szBuf
) -1);
970 return strerror((int)nErrCode
);