]>
Commit | Line | Data |
---|---|---|
c801d85f | 1 | ///////////////////////////////////////////////////////////////////////////// |
e4db172a | 2 | // Name: src/common/log.cpp |
c801d85f KB |
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> | |
65571936 | 9 | // Licence: wxWindows licence |
c801d85f KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
dd85fc6b | 19 | |
c801d85f KB |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
e2478fde | 24 | #pragma hdrstop |
c801d85f KB |
25 | #endif |
26 | ||
e2478fde VZ |
27 | #if wxUSE_LOG |
28 | ||
77ffb593 | 29 | // wxWidgets |
c801d85f | 30 | #ifndef WX_PRECOMP |
e4db172a | 31 | #include "wx/log.h" |
e90c1d2a | 32 | #include "wx/app.h" |
df5168c4 | 33 | #include "wx/arrstr.h" |
e2478fde VZ |
34 | #include "wx/intl.h" |
35 | #include "wx/string.h" | |
de6185e2 | 36 | #include "wx/utils.h" |
9ef3052c | 37 | #endif //WX_PRECOMP |
c801d85f | 38 | |
e2478fde | 39 | #include "wx/apptrait.h" |
7b2d1c74 | 40 | #include "wx/datetime.h" |
e2478fde | 41 | #include "wx/file.h" |
e2478fde VZ |
42 | #include "wx/msgout.h" |
43 | #include "wx/textfile.h" | |
44 | #include "wx/thread.h" | |
3a3dde0d | 45 | #include "wx/crt.h" |
f94dfb38 | 46 | |
c801d85f | 47 | // other standard headers |
1c193821 | 48 | #ifndef __WXWINCE__ |
e2478fde | 49 | #include <errno.h> |
1c193821 JS |
50 | #endif |
51 | ||
e2478fde | 52 | #include <stdlib.h> |
1c193821 JS |
53 | |
54 | #ifndef __WXWINCE__ | |
e2478fde | 55 | #include <time.h> |
1c193821 JS |
56 | #else |
57 | #include "wx/msw/wince/time.h" | |
58 | #endif | |
31907d03 | 59 | |
9cce3be7 VS |
60 | #if defined(__WINDOWS__) |
61 | #include "wx/msw/private.h" // includes windows.h | |
62 | #endif | |
63 | ||
c801d85f KB |
64 | // ---------------------------------------------------------------------------- |
65 | // non member functions | |
66 | // ---------------------------------------------------------------------------- | |
67 | ||
68 | // define this to enable wrapping of log messages | |
69 | //#define LOG_PRETTY_WRAP | |
70 | ||
9ef3052c | 71 | #ifdef LOG_PRETTY_WRAP |
c801d85f KB |
72 | static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz); |
73 | #endif | |
74 | ||
75 | // ============================================================================ | |
76 | // implementation | |
77 | // ============================================================================ | |
78 | ||
b568d04f VZ |
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 | ||
c801d85f | 86 | // generic log function |
81727065 | 87 | void wxVLogGeneric(wxLogLevel level, const wxString& format, va_list argptr) |
c801d85f | 88 | { |
d68d8590 | 89 | if ( wxLog::IsEnabled() ) { |
81727065 | 90 | wxLog::OnLog(level, wxString::FormatV(format, argptr), time(NULL)); |
807a903e | 91 | } |
c801d85f KB |
92 | } |
93 | ||
d1f6e2cf VS |
94 | #if !wxUSE_UTF8_LOCALE_ONLY |
95 | void wxDoLogGenericWchar(wxLogLevel level, const wxChar *format, ...) | |
ea44a631 GD |
96 | { |
97 | va_list argptr; | |
2523e9b7 VS |
98 | va_start(argptr, format); |
99 | wxVLogGeneric(level, format, argptr); | |
ea44a631 GD |
100 | va_end(argptr); |
101 | } | |
d1f6e2cf VS |
102 | #endif // wxUSE_UTF8_LOCALE_ONLY |
103 | ||
104 | #if wxUSE_UNICODE_UTF8 | |
105 | void 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 | |
ea44a631 | 139 | |
807a903e | 140 | #define IMPLEMENT_LOG_FUNCTION(level) \ |
81727065 | 141 | void wxVLog##level(const wxString& format, va_list argptr) \ |
807a903e | 142 | { \ |
d68d8590 | 143 | if ( wxLog::IsEnabled() ) { \ |
2e7f3845 | 144 | wxLog::OnLog(wxLOG_##level, \ |
81727065 | 145 | wxString::FormatV(format, argptr), time(NULL)); \ |
807a903e | 146 | } \ |
ea44a631 | 147 | } \ |
d1f6e2cf VS |
148 | IMPLEMENT_LOG_FUNCTION_WCHAR(level) \ |
149 | IMPLEMENT_LOG_FUNCTION_UTF8(level) | |
c801d85f | 150 | |
c801d85f KB |
151 | IMPLEMENT_LOG_FUNCTION(Error) |
152 | IMPLEMENT_LOG_FUNCTION(Warning) | |
153 | IMPLEMENT_LOG_FUNCTION(Message) | |
154 | IMPLEMENT_LOG_FUNCTION(Info) | |
155 | IMPLEMENT_LOG_FUNCTION(Status) | |
156 | ||
c11d62a6 VZ |
157 | void wxSafeShowMessage(const wxString& title, const wxString& text) |
158 | { | |
159 | #ifdef __WINDOWS__ | |
e0a050e3 | 160 | ::MessageBox(NULL, text.wx_str(), title.wx_str(), MB_OK | MB_ICONSTOP); |
c11d62a6 VZ |
161 | #else |
162 | wxFprintf(stderr, _T("%s: %s\n"), title.c_str(), text.c_str()); | |
65f06384 | 163 | fflush(stderr); |
c11d62a6 VZ |
164 | #endif |
165 | } | |
166 | ||
1800689f VZ |
167 | // fatal errors can't be suppressed nor handled by the custom log target and |
168 | // always terminate the program | |
81727065 | 169 | void wxVLogFatalError(const wxString& format, va_list argptr) |
1800689f | 170 | { |
81727065 | 171 | wxSafeShowMessage(_T("Fatal Error"), wxString::FormatV(format, argptr)); |
1800689f | 172 | |
1c193821 JS |
173 | #ifdef __WXWINCE__ |
174 | ExitThread(3); | |
175 | #else | |
1800689f | 176 | abort(); |
1c193821 | 177 | #endif |
1800689f VZ |
178 | } |
179 | ||
d1f6e2cf VS |
180 | #if !wxUSE_UTF8_LOCALE_ONLY |
181 | void wxDoLogFatalErrorWchar(const wxChar *format, ...) | |
1800689f VZ |
182 | { |
183 | va_list argptr; | |
2523e9b7 VS |
184 | va_start(argptr, format); |
185 | wxVLogFatalError(format, argptr); | |
5e475383 VZ |
186 | |
187 | // some compilers warn about unreachable code and it shouldn't matter | |
188 | // for the others anyhow... | |
189 | //va_end(argptr); | |
1800689f | 190 | } |
d1f6e2cf VS |
191 | #endif // wxUSE_UTF8_LOCALE_ONLY |
192 | ||
193 | #if wxUSE_UNICODE_UTF8 | |
194 | void 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 | |
1800689f | 205 | |
9ef3052c | 206 | // same as info, but only if 'verbose' mode is on |
81727065 | 207 | void wxVLogVerbose(const wxString& format, va_list argptr) |
9ef3052c | 208 | { |
d68d8590 | 209 | if ( wxLog::IsEnabled() ) { |
2a1f999f | 210 | if ( wxLog::GetActiveTarget() != NULL && wxLog::GetVerbose() ) { |
2e7f3845 | 211 | wxLog::OnLog(wxLOG_Info, |
81727065 | 212 | wxString::FormatV(format, argptr), time(NULL)); |
807a903e VZ |
213 | } |
214 | } | |
9ef3052c VZ |
215 | } |
216 | ||
d1f6e2cf VS |
217 | #if !wxUSE_UTF8_LOCALE_ONLY |
218 | void wxDoLogVerboseWchar(const wxChar *format, ...) | |
ea44a631 GD |
219 | { |
220 | va_list argptr; | |
2523e9b7 VS |
221 | va_start(argptr, format); |
222 | wxVLogVerbose(format, argptr); | |
ea44a631 GD |
223 | va_end(argptr); |
224 | } | |
d1f6e2cf VS |
225 | #endif // !wxUSE_UTF8_LOCALE_ONLY |
226 | ||
227 | #if wxUSE_UNICODE_UTF8 | |
228 | void 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 | |
ea44a631 | 236 | |
9ef3052c | 237 | // debug functions |
b2aef89b | 238 | #ifdef __WXDEBUG__ |
d1f6e2cf VS |
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 | ||
807a903e | 266 | #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \ |
2523e9b7 | 267 | void wxVLog##level(const wxString& format, va_list argptr) \ |
807a903e | 268 | { \ |
d68d8590 | 269 | if ( wxLog::IsEnabled() ) { \ |
2e7f3845 | 270 | wxLog::OnLog(wxLOG_##level, \ |
2523e9b7 | 271 | wxString::FormatV(format, argptr), time(NULL)); \ |
807a903e | 272 | } \ |
ea44a631 | 273 | } \ |
d1f6e2cf VS |
274 | IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \ |
275 | IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level) | |
276 | ||
c801d85f | 277 | |
81727065 | 278 | void wxVLogTrace(const wxString& mask, const wxString& format, va_list argptr) |
0fb67cd1 | 279 | { |
d68d8590 | 280 | if ( wxLog::IsEnabled() && wxLog::IsAllowedTraceMask(mask) ) { |
2e7f3845 | 281 | wxString msg; |
81727065 | 282 | msg << _T("(") << mask << _T(") ") << wxString::FormatV(format, argptr); |
c9f78968 | 283 | |
2e7f3845 | 284 | wxLog::OnLog(wxLOG_Trace, msg, time(NULL)); |
0fb67cd1 VZ |
285 | } |
286 | } | |
287 | ||
d1f6e2cf VS |
288 | #if !wxUSE_UTF8_LOCALE_ONLY |
289 | void wxDoLogTraceWchar(const wxString& mask, const wxChar *format, ...) | |
ea44a631 GD |
290 | { |
291 | va_list argptr; | |
2523e9b7 VS |
292 | va_start(argptr, format); |
293 | wxVLogTrace(mask, format, argptr); | |
ea44a631 GD |
294 | va_end(argptr); |
295 | } | |
d1f6e2cf VS |
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 | |
ea44a631 | 307 | |
81727065 | 308 | void wxVLogTrace(wxTraceMask mask, const wxString& format, va_list argptr) |
9ef3052c | 309 | { |
9ef3052c VZ |
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. | |
d68d8590 | 313 | if ( wxLog::IsEnabled() && ((wxLog::GetTraceMask() & mask) == mask) ) { |
81727065 | 314 | wxLog::OnLog(wxLOG_Trace, wxString::FormatV(format, argptr), time(NULL)); |
9ef3052c VZ |
315 | } |
316 | } | |
317 | ||
8bd37efc | 318 | #if !wxUSE_UTF8_LOCALE_ONLY |
d1f6e2cf VS |
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 | } | |
8bd37efc | 326 | #endif // !wxUSE_UTF8_LOCALE_ONLY |
d1f6e2cf VS |
327 | |
328 | #if wxUSE_UNICODE_UTF8 | |
329 | void wxDoLogTraceUtf8(wxTraceMask mask, const char *format, ...) | |
2523e9b7 VS |
330 | { |
331 | va_list argptr; | |
332 | va_start(argptr, format); | |
333 | wxVLogTrace(mask, format, argptr); | |
334 | va_end(argptr); | |
335 | } | |
d1f6e2cf | 336 | #endif // wxUSE_UNICODE_UTF8 |
2523e9b7 VS |
337 | |
338 | #ifdef __WATCOMC__ | |
339 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
59a14f69 | 340 | void wxDoLogTraceWchar(int mask, const wxChar *format, ...) |
2523e9b7 VS |
341 | { |
342 | va_list argptr; | |
343 | va_start(argptr, format); | |
344 | wxVLogTrace(mask, format, argptr); | |
345 | va_end(argptr); | |
346 | } | |
347 | ||
59a14f69 | 348 | void wxDoLogTraceWchar(const char *mask, const wxChar *format, ...) |
ea44a631 GD |
349 | { |
350 | va_list argptr; | |
2523e9b7 VS |
351 | va_start(argptr, format); |
352 | wxVLogTrace(mask, format, argptr); | |
ea44a631 GD |
353 | va_end(argptr); |
354 | } | |
355 | ||
59a14f69 | 356 | void wxDoLogTraceWchar(const wchar_t *mask, const wxChar *format, ...) |
2523e9b7 VS |
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 | ||
9ef3052c VZ |
372 | #else // release |
373 | #define IMPLEMENT_LOG_DEBUG_FUNCTION(level) | |
374 | #endif | |
375 | ||
376 | IMPLEMENT_LOG_DEBUG_FUNCTION(Debug) | |
377 | IMPLEMENT_LOG_DEBUG_FUNCTION(Trace) | |
378 | ||
379 | // wxLogSysError: one uses the last error code, for other you must give it | |
380 | // explicitly | |
381 | ||
2e7f3845 VZ |
382 | // return the system error message description |
383 | static inline wxString wxLogSysErrorHelper(long err) | |
c801d85f | 384 | { |
2e7f3845 | 385 | return wxString::Format(_(" (error %ld: %s)"), err, wxSysErrorMsg(err)); |
9ef3052c | 386 | } |
c801d85f | 387 | |
163b3ad7 | 388 | void WXDLLIMPEXP_BASE wxVLogSysError(const wxString& format, va_list argptr) |
9ef3052c | 389 | { |
81727065 | 390 | wxVLogSysError(wxSysErrorCode(), format, argptr); |
c801d85f KB |
391 | } |
392 | ||
d1f6e2cf | 393 | #if !wxUSE_UTF8_LOCALE_ONLY |
163b3ad7 | 394 | void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(const wxChar *format, ...) |
ea44a631 GD |
395 | { |
396 | va_list argptr; | |
2523e9b7 VS |
397 | va_start(argptr, format); |
398 | wxVLogSysError(format, argptr); | |
ea44a631 GD |
399 | va_end(argptr); |
400 | } | |
d1f6e2cf VS |
401 | #endif // !wxUSE_UTF8_LOCALE_ONLY |
402 | ||
403 | #if wxUSE_UNICODE_UTF8 | |
163b3ad7 | 404 | void WXDLLIMPEXP_BASE wxDoLogSysErrorUtf8(const char *format, ...) |
d1f6e2cf VS |
405 | { |
406 | va_list argptr; | |
407 | va_start(argptr, format); | |
408 | wxVLogSysError(format, argptr); | |
409 | va_end(argptr); | |
410 | } | |
411 | #endif // wxUSE_UNICODE_UTF8 | |
ea44a631 | 412 | |
163b3ad7 | 413 | void WXDLLIMPEXP_BASE wxVLogSysError(long err, const wxString& format, va_list argptr) |
c801d85f | 414 | { |
d68d8590 | 415 | if ( wxLog::IsEnabled() ) { |
2e7f3845 | 416 | wxLog::OnLog(wxLOG_Error, |
81727065 | 417 | wxString::FormatV(format, argptr) + wxLogSysErrorHelper(err), |
2e7f3845 | 418 | time(NULL)); |
807a903e | 419 | } |
c801d85f KB |
420 | } |
421 | ||
d1f6e2cf | 422 | #if !wxUSE_UTF8_LOCALE_ONLY |
163b3ad7 | 423 | void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(long lErrCode, const wxChar *format, ...) |
d1f6e2cf VS |
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 | |
163b3ad7 | 433 | void WXDLLIMPEXP_BASE wxDoLogSysErrorUtf8(long lErrCode, const char *format, ...) |
ea44a631 GD |
434 | { |
435 | va_list argptr; | |
2523e9b7 VS |
436 | va_start(argptr, format); |
437 | wxVLogSysError(lErrCode, format, argptr); | |
ea44a631 GD |
438 | va_end(argptr); |
439 | } | |
d1f6e2cf | 440 | #endif // wxUSE_UNICODE_UTF8 |
ea44a631 | 441 | |
2523e9b7 VS |
442 | #ifdef __WATCOMC__ |
443 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
163b3ad7 | 444 | void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(unsigned long lErrCode, const wxChar *format, ...) |
2523e9b7 VS |
445 | { |
446 | va_list argptr; | |
447 | va_start(argptr, format); | |
448 | wxVLogSysError(lErrCode, format, argptr); | |
449 | va_end(argptr); | |
450 | } | |
451 | ||
163b3ad7 | 452 | void WXDLLIMPEXP_BASE wxVLogSysError(unsigned long err, const wxString& format, va_list argptr) |
2523e9b7 VS |
453 | { wxVLogSysError((long)err, format, argptr); } |
454 | #endif // __WATCOMC__ | |
455 | ||
c801d85f KB |
456 | // ---------------------------------------------------------------------------- |
457 | // wxLog class implementation | |
458 | // ---------------------------------------------------------------------------- | |
459 | ||
0250efd6 | 460 | unsigned wxLog::LogLastRepetitionCountIfNeeded() |
f9837791 | 461 | { |
a2d38265 VZ |
462 | wxCRIT_SECT_LOCKER(lock, ms_prevCS); |
463 | ||
0250efd6 VZ |
464 | const unsigned count = ms_prevCounter; |
465 | ||
c1f80bc0 | 466 | if ( ms_prevCounter ) |
f9837791 VZ |
467 | { |
468 | wxString msg; | |
459b97df | 469 | #if wxUSE_INTL |
f9837791 VZ |
470 | msg.Printf(wxPLURAL("The previous message repeated once.", |
471 | "The previous message repeated %lu times.", | |
472 | ms_prevCounter), | |
473 | ms_prevCounter); | |
459b97df | 474 | #else |
2064113c VZ |
475 | msg.Printf(wxT("The previous message was repeated %lu times."), |
476 | ms_prevCounter); | |
459b97df | 477 | #endif |
f9837791 VZ |
478 | ms_prevCounter = 0; |
479 | ms_prevString.clear(); | |
c1f80bc0 | 480 | DoLog(ms_prevLevel, msg, ms_prevTimeStamp); |
f9837791 | 481 | } |
0250efd6 VZ |
482 | |
483 | return count; | |
f9837791 VZ |
484 | } |
485 | ||
486 | wxLog::~wxLog() | |
487 | { | |
2064113c | 488 | LogLastRepetitionCountIfNeeded(); |
f9837791 VZ |
489 | } |
490 | ||
491 | /* static */ | |
5a20d2ce | 492 | void wxLog::OnLog(wxLogLevel level, const wxString& szString, time_t t) |
f9837791 VZ |
493 | { |
494 | if ( IsEnabled() && ms_logLevel >= level ) | |
495 | { | |
496 | wxLog *pLogger = GetActiveTarget(); | |
497 | if ( pLogger ) | |
498 | { | |
2064113c | 499 | if ( GetRepetitionCounting() ) |
f9837791 | 500 | { |
a2d38265 VZ |
501 | wxCRIT_SECT_LOCKER(lock, ms_prevCS); |
502 | ||
2064113c | 503 | if ( szString == ms_prevString ) |
f9837791 | 504 | { |
2064113c VZ |
505 | ms_prevCounter++; |
506 | ||
507 | // nothing else to do, in particular, don't log the | |
508 | // repeated message | |
509 | return; | |
f9837791 | 510 | } |
2064113c | 511 | |
c1f80bc0 | 512 | pLogger->LogLastRepetitionCountIfNeeded(); |
2064113c VZ |
513 | |
514 | // reset repetition counter for a new message | |
f9837791 VZ |
515 | ms_prevString = szString; |
516 | ms_prevLevel = level; | |
517 | ms_prevTimeStamp = t; | |
f9837791 | 518 | } |
2064113c VZ |
519 | |
520 | pLogger->DoLog(level, szString, t); | |
f9837791 VZ |
521 | } |
522 | } | |
523 | } | |
524 | ||
2e7f3845 | 525 | // deprecated function |
dcc40ba5 VZ |
526 | #if WXWIN_COMPATIBILITY_2_6 |
527 | ||
2e7f3845 | 528 | wxChar *wxLog::SetLogBuffer(wxChar * WXUNUSED(buf), size_t WXUNUSED(size)) |
04662def | 529 | { |
2e7f3845 | 530 | return NULL; |
04662def RL |
531 | } |
532 | ||
dcc40ba5 VZ |
533 | #endif // WXWIN_COMPATIBILITY_2_6 |
534 | ||
5d88a6b5 VZ |
535 | #if WXWIN_COMPATIBILITY_2_8 |
536 | ||
537 | void wxLog::DoLog(wxLogLevel WXUNUSED(level), | |
538 | const char *WXUNUSED(szString), | |
539 | time_t WXUNUSED(t)) | |
540 | { | |
541 | } | |
542 | ||
543 | void 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 | ||
9ec05cc9 VZ |
551 | wxLog *wxLog::GetActiveTarget() |
552 | { | |
0fb67cd1 VZ |
553 | if ( ms_bAutoCreate && ms_pLogger == NULL ) { |
554 | // prevent infinite recursion if someone calls wxLogXXX() from | |
555 | // wxApp::CreateLogTarget() | |
f644b28c | 556 | static bool s_bInGetActiveTarget = false; |
0fb67cd1 | 557 | if ( !s_bInGetActiveTarget ) { |
f644b28c | 558 | s_bInGetActiveTarget = true; |
0fb67cd1 | 559 | |
0fb67cd1 VZ |
560 | // ask the application to create a log target for us |
561 | if ( wxTheApp != NULL ) | |
dc6d5e38 | 562 | ms_pLogger = wxTheApp->GetTraits()->CreateLogTarget(); |
0fb67cd1 VZ |
563 | else |
564 | ms_pLogger = new wxLogStderr; | |
0fb67cd1 | 565 | |
f644b28c | 566 | s_bInGetActiveTarget = false; |
0fb67cd1 VZ |
567 | |
568 | // do nothing if it fails - what can we do? | |
569 | } | |
275bf4c1 | 570 | } |
c801d85f | 571 | |
0fb67cd1 | 572 | return ms_pLogger; |
c801d85f KB |
573 | } |
574 | ||
c085e333 | 575 | wxLog *wxLog::SetActiveTarget(wxLog *pLogger) |
9ec05cc9 | 576 | { |
0fb67cd1 VZ |
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 | } | |
c801d85f | 582 | |
0fb67cd1 VZ |
583 | wxLog *pOldLogger = ms_pLogger; |
584 | ms_pLogger = pLogger; | |
c085e333 | 585 | |
0fb67cd1 | 586 | return pOldLogger; |
c801d85f KB |
587 | } |
588 | ||
36bd6902 VZ |
589 | void wxLog::DontCreateOnDemand() |
590 | { | |
f644b28c | 591 | ms_bAutoCreate = false; |
36bd6902 VZ |
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 | ||
e94cd97d DE |
599 | void wxLog::DoCreateOnDemand() |
600 | { | |
601 | ms_bAutoCreate = true; | |
602 | } | |
603 | ||
0fb67cd1 | 604 | void wxLog::RemoveTraceMask(const wxString& str) |
c801d85f | 605 | { |
0fb67cd1 VZ |
606 | int index = ms_aTraceMasks.Index(str); |
607 | if ( index != wxNOT_FOUND ) | |
dc6d5e38 | 608 | ms_aTraceMasks.RemoveAt((size_t)index); |
0fb67cd1 | 609 | } |
c801d85f | 610 | |
36bd6902 VZ |
611 | void wxLog::ClearTraceMasks() |
612 | { | |
613 | ms_aTraceMasks.Clear(); | |
614 | } | |
615 | ||
d2e1ef19 VZ |
616 | void wxLog::TimeStamp(wxString *str) |
617 | { | |
7b2d1c74 | 618 | #if wxUSE_DATETIME |
cb296f30 | 619 | if ( !ms_timestamp.empty() ) |
d2e1ef19 VZ |
620 | { |
621 | wxChar buf[256]; | |
622 | time_t timeNow; | |
623 | (void)time(&timeNow); | |
83e8b44c VZ |
624 | |
625 | struct tm tm; | |
626 | wxStrftime(buf, WXSIZEOF(buf), | |
627 | ms_timestamp, wxLocaltime_r(&timeNow, &tm)); | |
d2e1ef19 VZ |
628 | |
629 | str->Empty(); | |
223d09f6 | 630 | *str << buf << wxT(": "); |
d2e1ef19 | 631 | } |
7b2d1c74 | 632 | #endif // wxUSE_DATETIME |
d2e1ef19 VZ |
633 | } |
634 | ||
5a20d2ce | 635 | void wxLog::DoLog(wxLogLevel level, const wxString& szString, time_t t) |
0fb67cd1 | 636 | { |
5a20d2ce VS |
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 | ||
0fb67cd1 VZ |
644 | switch ( level ) { |
645 | case wxLOG_FatalError: | |
5a20d2ce VS |
646 | LogString(_("Fatal error: ") + szString, t); |
647 | LogString(_("Program aborted."), t); | |
0fb67cd1 | 648 | Flush(); |
1c193821 JS |
649 | #ifdef __WXWINCE__ |
650 | ExitThread(3); | |
651 | #else | |
0fb67cd1 | 652 | abort(); |
1c193821 | 653 | #endif |
0fb67cd1 VZ |
654 | break; |
655 | ||
656 | case wxLOG_Error: | |
5a20d2ce | 657 | LogString(_("Error: ") + szString, t); |
0fb67cd1 VZ |
658 | break; |
659 | ||
660 | case wxLOG_Warning: | |
5a20d2ce | 661 | LogString(_("Warning: ") + szString, t); |
0fb67cd1 VZ |
662 | break; |
663 | ||
664 | case wxLOG_Info: | |
0fb67cd1 | 665 | if ( GetVerbose() ) |
37278984 | 666 | case wxLOG_Message: |
87a1e308 | 667 | case wxLOG_Status: |
786855a1 | 668 | default: // log unknown log levels too |
5a20d2ce | 669 | LogString(szString, t); |
0fb67cd1 VZ |
670 | break; |
671 | ||
672 | case wxLOG_Trace: | |
673 | case wxLOG_Debug: | |
674 | #ifdef __WXDEBUG__ | |
0131687b VZ |
675 | { |
676 | wxString msg = level == wxLOG_Trace ? wxT("Trace: ") | |
54a8f42b | 677 | : wxT("Debug: "); |
0131687b | 678 | msg << szString; |
5a20d2ce | 679 | LogString(msg, t); |
0131687b VZ |
680 | } |
681 | #endif // Debug | |
0fb67cd1 | 682 | break; |
0fb67cd1 | 683 | } |
c801d85f KB |
684 | } |
685 | ||
5a20d2ce | 686 | void wxLog::DoLogString(const wxString& szString, time_t t) |
c801d85f | 687 | { |
5a20d2ce VS |
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 | |
223d09f6 | 695 | wxFAIL_MSG(wxT("DoLogString must be overriden if it's called.")); |
5a20d2ce VS |
696 | wxUnusedVar(szString); |
697 | wxUnusedVar(t); | |
698 | #endif | |
c801d85f KB |
699 | } |
700 | ||
701 | void wxLog::Flush() | |
702 | { | |
1ec5cbf3 | 703 | // nothing to do here |
c801d85f KB |
704 | } |
705 | ||
5a20d2ce | 706 | /*static*/ bool wxLog::IsAllowedTraceMask(const wxString& mask) |
df5168c4 MB |
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 | ||
d3fc1755 VZ |
716 | // ---------------------------------------------------------------------------- |
717 | // wxLogBuffer implementation | |
718 | // ---------------------------------------------------------------------------- | |
719 | ||
720 | void wxLogBuffer::Flush() | |
721 | { | |
a23bbe93 VZ |
722 | if ( !m_str.empty() ) |
723 | { | |
724 | wxMessageOutputBest out; | |
725 | out.Printf(_T("%s"), m_str.c_str()); | |
726 | m_str.clear(); | |
727 | } | |
d3fc1755 VZ |
728 | } |
729 | ||
5a20d2ce | 730 | void wxLogBuffer::DoLog(wxLogLevel level, const wxString& szString, time_t t) |
83250f1a VZ |
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 | ||
c4b401b6 WS |
744 | wxMessageOutputDebug dbgout; |
745 | dbgout.Printf(_T("%s\n"), str.c_str()); | |
83250f1a VZ |
746 | } |
747 | #endif // __WXDEBUG__ | |
748 | break; | |
749 | ||
750 | default: | |
751 | wxLog::DoLog(level, szString, t); | |
752 | } | |
753 | } | |
754 | ||
5a20d2ce | 755 | void wxLogBuffer::DoLogString(const wxString& szString, time_t WXUNUSED(t)) |
d3fc1755 VZ |
756 | { |
757 | m_str << szString << _T("\n"); | |
758 | } | |
759 | ||
c801d85f KB |
760 | // ---------------------------------------------------------------------------- |
761 | // wxLogStderr class implementation | |
762 | // ---------------------------------------------------------------------------- | |
763 | ||
764 | wxLogStderr::wxLogStderr(FILE *fp) | |
765 | { | |
0fb67cd1 VZ |
766 | if ( fp == NULL ) |
767 | m_fp = stderr; | |
768 | else | |
769 | m_fp = fp; | |
c801d85f KB |
770 | } |
771 | ||
5a20d2ce | 772 | void wxLogStderr::DoLogString(const wxString& szString, time_t WXUNUSED(t)) |
c801d85f | 773 | { |
d2e1ef19 VZ |
774 | wxString str; |
775 | TimeStamp(&str); | |
b568d04f | 776 | str << szString; |
1e8a4bc2 | 777 | |
14ff7a59 VZ |
778 | wxFputs(str, m_fp); |
779 | wxFputc(_T('\n'), m_fp); | |
0fb67cd1 | 780 | fflush(m_fp); |
1e8a4bc2 | 781 | |
e2478fde VZ |
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 | |
1ec5cbf3 VZ |
786 | if ( m_fp == stderr ) |
787 | { | |
e2478fde VZ |
788 | wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL; |
789 | if ( traits && !traits->HasStderr() ) | |
790 | { | |
254a2129 | 791 | wxMessageOutputDebug dbgout; |
30413fd0 | 792 | dbgout.Printf(_T("%s\n"), str.c_str()); |
e2478fde | 793 | } |
03147cd0 | 794 | } |
c801d85f KB |
795 | } |
796 | ||
797 | // ---------------------------------------------------------------------------- | |
798 | // wxLogStream implementation | |
799 | // ---------------------------------------------------------------------------- | |
800 | ||
4bf78aae | 801 | #if wxUSE_STD_IOSTREAM |
65f19af1 | 802 | #include "wx/ioswrap.h" |
dd107c50 | 803 | wxLogStream::wxLogStream(wxSTD ostream *ostr) |
c801d85f | 804 | { |
0fb67cd1 | 805 | if ( ostr == NULL ) |
dd107c50 | 806 | m_ostr = &wxSTD cerr; |
0fb67cd1 VZ |
807 | else |
808 | m_ostr = ostr; | |
c801d85f KB |
809 | } |
810 | ||
5a20d2ce | 811 | void wxLogStream::DoLogString(const wxString& szString, time_t WXUNUSED(t)) |
c801d85f | 812 | { |
5a20d2ce VS |
813 | wxString stamp; |
814 | TimeStamp(&stamp); | |
815 | (*m_ostr) << stamp << szString << wxSTD endl; | |
c801d85f | 816 | } |
0fb67cd1 | 817 | #endif // wxUSE_STD_IOSTREAM |
c801d85f | 818 | |
03147cd0 VZ |
819 | // ---------------------------------------------------------------------------- |
820 | // wxLogChain | |
821 | // ---------------------------------------------------------------------------- | |
822 | ||
823 | wxLogChain::wxLogChain(wxLog *logger) | |
824 | { | |
f644b28c | 825 | m_bPassMessages = true; |
71debe95 | 826 | |
03147cd0 VZ |
827 | m_logNew = logger; |
828 | m_logOld = wxLog::SetActiveTarget(this); | |
829 | } | |
830 | ||
199e91fb VZ |
831 | wxLogChain::~wxLogChain() |
832 | { | |
e95f8fde VZ |
833 | delete m_logOld; |
834 | ||
835 | if ( m_logNew != this ) | |
836 | delete m_logNew; | |
199e91fb VZ |
837 | } |
838 | ||
03147cd0 VZ |
839 | void wxLogChain::SetLog(wxLog *logger) |
840 | { | |
841 | if ( m_logNew != this ) | |
842 | delete m_logNew; | |
843 | ||
03147cd0 VZ |
844 | m_logNew = logger; |
845 | } | |
846 | ||
847 | void wxLogChain::Flush() | |
848 | { | |
849 | if ( m_logOld ) | |
850 | m_logOld->Flush(); | |
851 | ||
1ec5cbf3 | 852 | // be careful to avoid infinite recursion |
03147cd0 VZ |
853 | if ( m_logNew && m_logNew != this ) |
854 | m_logNew->Flush(); | |
855 | } | |
856 | ||
5a20d2ce | 857 | void wxLogChain::DoLog(wxLogLevel level, const wxString& szString, time_t t) |
03147cd0 VZ |
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 | ||
93d4c1d0 VZ |
873 | #ifdef __VISUALC__ |
874 | // "'this' : used in base member initializer list" - so what? | |
875 | #pragma warning(disable:4355) | |
876 | #endif // VC++ | |
877 | ||
47fe7ff3 JS |
878 | // ---------------------------------------------------------------------------- |
879 | // wxLogInterposer | |
880 | // ---------------------------------------------------------------------------- | |
881 | ||
882 | wxLogInterposer::wxLogInterposer() | |
883 | : wxLogChain(this) | |
884 | { | |
885 | } | |
886 | ||
887 | // ---------------------------------------------------------------------------- | |
888 | // wxLogInterposerTemp | |
889 | // ---------------------------------------------------------------------------- | |
890 | ||
891 | wxLogInterposerTemp::wxLogInterposerTemp() | |
93d4c1d0 VZ |
892 | : wxLogChain(this) |
893 | { | |
47fe7ff3 | 894 | DetachOldLog(); |
93d4c1d0 VZ |
895 | } |
896 | ||
897 | #ifdef __VISUALC__ | |
898 | #pragma warning(default:4355) | |
899 | #endif // VC++ | |
900 | ||
c801d85f KB |
901 | // ============================================================================ |
902 | // Global functions/variables | |
903 | // ============================================================================ | |
904 | ||
905 | // ---------------------------------------------------------------------------- | |
906 | // static variables | |
907 | // ---------------------------------------------------------------------------- | |
0fb67cd1 | 908 | |
0250efd6 VZ |
909 | #if wxUSE_THREADS |
910 | wxCriticalSection wxLog::ms_prevCS; | |
911 | #endif // wxUSE_THREADS | |
f9837791 VZ |
912 | bool wxLog::ms_bRepetCounting = false; |
913 | wxString wxLog::ms_prevString; | |
374b4f1c | 914 | unsigned int wxLog::ms_prevCounter = 0; |
f9837791 VZ |
915 | time_t wxLog::ms_prevTimeStamp= 0; |
916 | wxLogLevel wxLog::ms_prevLevel; | |
917 | ||
0fb67cd1 | 918 | wxLog *wxLog::ms_pLogger = (wxLog *)NULL; |
f644b28c WS |
919 | bool wxLog::ms_doLog = true; |
920 | bool wxLog::ms_bAutoCreate = true; | |
921 | bool wxLog::ms_bVerbose = false; | |
d2e1ef19 | 922 | |
edc73852 RD |
923 | wxLogLevel wxLog::ms_logLevel = wxLOG_Max; // log everything by default |
924 | ||
2ed3265e VZ |
925 | size_t wxLog::ms_suspendCount = 0; |
926 | ||
d993e05b | 927 | wxString wxLog::ms_timestamp(wxT("%X")); // time only, no date |
d2e1ef19 | 928 | |
0fb67cd1 VZ |
929 | wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0; |
930 | wxArrayString wxLog::ms_aTraceMasks; | |
c801d85f KB |
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 | // | |
0fb67cd1 VZ |
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 | |
c801d85f KB |
942 | static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz) |
943 | { | |
0fb67cd1 VZ |
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 | } | |
c801d85f | 963 | } |
c801d85f | 964 | |
0fb67cd1 | 965 | putc('\n', f); |
c801d85f KB |
966 | } |
967 | #endif //LOG_PRETTY_WRAP | |
968 | ||
969 | // ---------------------------------------------------------------------------- | |
970 | // error code/error message retrieval functions | |
971 | // ---------------------------------------------------------------------------- | |
972 | ||
973 | // get error code from syste | |
974 | unsigned long wxSysErrorCode() | |
975 | { | |
8cb172b4 | 976 | #if defined(__WXMSW__) && !defined(__WXMICROWIN__) |
0fb67cd1 | 977 | return ::GetLastError(); |
0fb67cd1 | 978 | #else //Unix |
c801d85f | 979 | return errno; |
0fb67cd1 | 980 | #endif //Win/Unix |
c801d85f KB |
981 | } |
982 | ||
983 | // get error message from system | |
50920146 | 984 | const wxChar *wxSysErrorMsg(unsigned long nErrCode) |
c801d85f | 985 | { |
0fb67cd1 VZ |
986 | if ( nErrCode == 0 ) |
987 | nErrCode = wxSysErrorCode(); | |
988 | ||
8cb172b4 | 989 | #if defined(__WXMSW__) && !defined(__WXMICROWIN__) |
2e7f3845 | 990 | static wxChar s_szBuf[1024]; |
0fb67cd1 VZ |
991 | |
992 | // get error message from system | |
993 | LPVOID lpMsgBuf; | |
d0822e56 VZ |
994 | if ( ::FormatMessage |
995 | ( | |
996 | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, | |
997 | NULL, | |
998 | nErrCode, | |
0fb67cd1 VZ |
999 | MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), |
1000 | (LPTSTR)&lpMsgBuf, | |
d0822e56 VZ |
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); | |
c4b401b6 | 1008 | return s_szBuf; |
d0822e56 VZ |
1009 | } |
1010 | ||
0fb67cd1 VZ |
1011 | |
1012 | // copy it to our buffer and free memory | |
d0822e56 | 1013 | // Crashes on SmartPhone (FIXME) |
0c44ec97 | 1014 | #if !defined(__SMARTPHONE__) /* of WinCE */ |
7448de8d WS |
1015 | if( lpMsgBuf != 0 ) |
1016 | { | |
8c5b1f0f | 1017 | wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1); |
251244a0 VZ |
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 | } | |
a9928e9d | 1031 | else |
2e7f3845 | 1032 | #endif // !__SMARTPHONE__ |
a9928e9d | 1033 | { |
8c5b1f0f | 1034 | s_szBuf[0] = wxT('\0'); |
0fb67cd1 VZ |
1035 | } |
1036 | ||
1037 | return s_szBuf; | |
2e7f3845 VZ |
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__ | |
c801d85f KB |
1048 | } |
1049 | ||
e2478fde | 1050 | #endif // wxUSE_LOG |