]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/log.cpp
Updated wxvc_dll.dsp and memory.h to make VC++ compile in DLL mode again
[wxWidgets.git] / src / common / log.cpp
... / ...
CommitLineData
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 #ifdef __WXMSW__
40 #include "wx/msw/private.h"
41 #endif
42 #include "wx/msgdlg.h"
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// other standard headers
54#include <errno.h>
55#include <stdlib.h>
56#include <time.h>
57
58#ifdef __WXMSW__
59 #include "wx/msw/private.h" // includes windows.h for OutputDebugString
60#else //Unix
61 #include <signal.h>
62#endif //Win/Unix
63
64// ----------------------------------------------------------------------------
65// non member functions
66// ----------------------------------------------------------------------------
67
68// define this to enable wrapping of log messages
69//#define LOG_PRETTY_WRAP
70
71#ifdef LOG_PRETTY_WRAP
72 static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz);
73#endif
74
75// ============================================================================
76// implementation
77// ============================================================================
78
79// ----------------------------------------------------------------------------
80// globals
81// ----------------------------------------------------------------------------
82
83// log functions can't allocate memory (LogError("out of memory...") should
84// work!), so we use a static buffer for all log messages
85#define LOG_BUFFER_SIZE (4096)
86
87// static buffer for error messages
88static wxChar s_szBuf[LOG_BUFFER_SIZE];
89
90#if wxUSE_THREADS
91
92// the critical section protecting the static buffer
93static wxCriticalSection gs_csLogBuf;
94
95#endif // wxUSE_THREADS
96
97// ----------------------------------------------------------------------------
98// implementation of Log functions
99//
100// NB: unfortunately we need all these distinct functions, we can't make them
101// macros and not all compilers inline vararg functions.
102// ----------------------------------------------------------------------------
103
104// generic log function
105void wxLogGeneric(wxLogLevel level, const wxChar *szFormat, ...)
106{
107 if ( wxLog::GetActiveTarget() != NULL ) {
108 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
109
110 va_list argptr;
111 va_start(argptr, szFormat);
112 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
113 va_end(argptr);
114
115 wxLog::OnLog(level, s_szBuf, time(NULL));
116 }
117}
118
119#define IMPLEMENT_LOG_FUNCTION(level) \
120 void wxLog##level(const wxChar *szFormat, ...) \
121 { \
122 if ( wxLog::GetActiveTarget() != NULL ) { \
123 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
124 \
125 va_list argptr; \
126 va_start(argptr, szFormat); \
127 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr); \
128 va_end(argptr); \
129 \
130 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
131 } \
132 }
133
134IMPLEMENT_LOG_FUNCTION(FatalError)
135IMPLEMENT_LOG_FUNCTION(Error)
136IMPLEMENT_LOG_FUNCTION(Warning)
137IMPLEMENT_LOG_FUNCTION(Message)
138IMPLEMENT_LOG_FUNCTION(Info)
139IMPLEMENT_LOG_FUNCTION(Status)
140
141// same as info, but only if 'verbose' mode is on
142void wxLogVerbose(const wxChar *szFormat, ...)
143{
144 wxLog *pLog = wxLog::GetActiveTarget();
145 if ( pLog != NULL && pLog->GetVerbose() ) {
146 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
147
148 va_list argptr;
149 va_start(argptr, szFormat);
150 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
151 va_end(argptr);
152
153 wxLog::OnLog(wxLOG_Info, s_szBuf, time(NULL));
154 }
155}
156
157// debug functions
158#ifdef __WXDEBUG__
159#define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
160 void wxLog##level(const wxChar *szFormat, ...) \
161 { \
162 if ( wxLog::GetActiveTarget() != NULL ) { \
163 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf); \
164 \
165 va_list argptr; \
166 va_start(argptr, szFormat); \
167 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr); \
168 va_end(argptr); \
169 \
170 wxLog::OnLog(wxLOG_##level, s_szBuf, time(NULL)); \
171 } \
172 }
173
174 void wxLogTrace(const wxChar *mask, const wxChar *szFormat, ...)
175 {
176 wxLog *pLog = wxLog::GetActiveTarget();
177
178 if ( pLog != NULL && wxLog::IsAllowedTraceMask(mask) ) {
179 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
180
181 va_list argptr;
182 va_start(argptr, szFormat);
183 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
184 va_end(argptr);
185
186 wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
187 }
188 }
189
190 void wxLogTrace(wxTraceMask mask, const wxChar *szFormat, ...)
191 {
192 wxLog *pLog = wxLog::GetActiveTarget();
193
194 // we check that all of mask bits are set in the current mask, so
195 // that wxLogTrace(wxTraceRefCount | wxTraceOle) will only do something
196 // if both bits are set.
197 if ( pLog != NULL && ((pLog->GetTraceMask() & mask) == mask) ) {
198 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
199
200 va_list argptr;
201 va_start(argptr, szFormat);
202 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
203 va_end(argptr);
204
205 wxLog::OnLog(wxLOG_Trace, s_szBuf, time(NULL));
206 }
207 }
208
209#else // release
210 #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
211#endif
212
213IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
214IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
215
216// wxLogSysError: one uses the last error code, for other you must give it
217// explicitly
218
219// common part of both wxLogSysError
220void wxLogSysErrorHelper(long lErrCode)
221{
222 wxChar szErrMsg[LOG_BUFFER_SIZE / 2];
223 wxSnprintf(szErrMsg, WXSIZEOF(szErrMsg),
224 _(" (error %ld: %s)"), lErrCode, wxSysErrorMsg(lErrCode));
225 wxStrncat(s_szBuf, szErrMsg, WXSIZEOF(s_szBuf) - wxStrlen(s_szBuf));
226
227 wxLog::OnLog(wxLOG_Error, s_szBuf, time(NULL));
228}
229
230void WXDLLEXPORT wxLogSysError(const wxChar *szFormat, ...)
231{
232 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
233
234 va_list argptr;
235 va_start(argptr, szFormat);
236 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
237 va_end(argptr);
238
239 wxLogSysErrorHelper(wxSysErrorCode());
240}
241
242void WXDLLEXPORT wxLogSysError(long lErrCode, const wxChar *szFormat, ...)
243{
244 wxCRIT_SECT_LOCKER(locker, gs_csLogBuf);
245
246 va_list argptr;
247 va_start(argptr, szFormat);
248 wxVsnprintf(s_szBuf, WXSIZEOF(s_szBuf), szFormat, argptr);
249 va_end(argptr);
250
251 wxLogSysErrorHelper(lErrCode);
252}
253
254// ----------------------------------------------------------------------------
255// wxLog class implementation
256// ----------------------------------------------------------------------------
257
258wxLog::wxLog()
259{
260 m_bHasMessages = FALSE;
261
262 // enable verbose messages by default in the debug builds
263#ifdef __WXDEBUG__
264 m_bVerbose = TRUE;
265#else // release
266 m_bVerbose = FALSE;
267#endif // debug/release
268}
269
270wxLog *wxLog::GetActiveTarget()
271{
272 if ( ms_bAutoCreate && ms_pLogger == NULL ) {
273 // prevent infinite recursion if someone calls wxLogXXX() from
274 // wxApp::CreateLogTarget()
275 static bool s_bInGetActiveTarget = FALSE;
276 if ( !s_bInGetActiveTarget ) {
277 s_bInGetActiveTarget = TRUE;
278
279 // ask the application to create a log target for us
280 if ( wxTheApp != NULL )
281 ms_pLogger = wxTheApp->CreateLogTarget();
282 else
283 ms_pLogger = new wxLogStderr;
284
285 s_bInGetActiveTarget = FALSE;
286
287 // do nothing if it fails - what can we do?
288 }
289 }
290
291 return ms_pLogger;
292}
293
294wxLog *wxLog::SetActiveTarget(wxLog *pLogger)
295{
296 if ( ms_pLogger != NULL ) {
297 // flush the old messages before changing because otherwise they might
298 // get lost later if this target is not restored
299 ms_pLogger->Flush();
300 }
301
302 wxLog *pOldLogger = ms_pLogger;
303 ms_pLogger = pLogger;
304
305 return pOldLogger;
306}
307
308void wxLog::RemoveTraceMask(const wxString& str)
309{
310 int index = ms_aTraceMasks.Index(str);
311 if ( index != wxNOT_FOUND )
312 ms_aTraceMasks.Remove((size_t)index);
313}
314
315void wxLog::TimeStamp(wxString *str)
316{
317 if ( ms_timestamp )
318 {
319 wxChar buf[256];
320 time_t timeNow;
321 (void)time(&timeNow);
322 wxStrftime(buf, WXSIZEOF(buf), ms_timestamp, localtime(&timeNow));
323
324 str->Empty();
325 *str << buf << wxT(": ");
326 }
327}
328
329void wxLog::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
330{
331 switch ( level ) {
332 case wxLOG_FatalError:
333 DoLogString(wxString(_("Fatal error: ")) + szString, t);
334 DoLogString(_("Program aborted."), t);
335 Flush();
336 abort();
337 break;
338
339 case wxLOG_Error:
340 DoLogString(wxString(_("Error: ")) + szString, t);
341 break;
342
343 case wxLOG_Warning:
344 DoLogString(wxString(_("Warning: ")) + szString, t);
345 break;
346
347 case wxLOG_Info:
348 if ( GetVerbose() )
349 case wxLOG_Message:
350 case wxLOG_Status:
351 default: // log unknown log levels too
352 DoLogString(szString, t);
353 break;
354
355 case wxLOG_Trace:
356 case wxLOG_Debug:
357#ifdef __WXDEBUG__
358 DoLogString(szString, t);
359#endif
360 break;
361 }
362}
363
364void wxLog::DoLogString(const wxChar *WXUNUSED(szString), time_t WXUNUSED(t))
365{
366 wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
367}
368
369void wxLog::Flush()
370{
371 // do nothing
372}
373
374// ----------------------------------------------------------------------------
375// wxLogStderr class implementation
376// ----------------------------------------------------------------------------
377
378wxLogStderr::wxLogStderr(FILE *fp)
379{
380 if ( fp == NULL )
381 m_fp = stderr;
382 else
383 m_fp = fp;
384}
385
386void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
387{
388 wxString str;
389 TimeStamp(&str);
390 str << szString;
391
392 fputs(str.mb_str(), m_fp);
393 fputc(_T('\n'), m_fp);
394 fflush(m_fp);
395
396 // under Windows, programs usually don't have stderr at all, so show the
397 // messages also under debugger - unless it's a console program
398#if defined(__WXMSW__) && wxUSE_GUI
399 OutputDebugString(str + wxT("\r\n"));
400#endif // MSW
401}
402
403// ----------------------------------------------------------------------------
404// wxLogStream implementation
405// ----------------------------------------------------------------------------
406
407#if wxUSE_STD_IOSTREAM
408wxLogStream::wxLogStream(ostream *ostr)
409{
410 if ( ostr == NULL )
411 m_ostr = &cerr;
412 else
413 m_ostr = ostr;
414}
415
416void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
417{
418 (*m_ostr) << wxConvertWX2MB(szString) << endl;
419}
420#endif // wxUSE_STD_IOSTREAM
421
422// ============================================================================
423// Global functions/variables
424// ============================================================================
425
426// ----------------------------------------------------------------------------
427// static variables
428// ----------------------------------------------------------------------------
429
430wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
431bool wxLog::ms_doLog = TRUE;
432bool wxLog::ms_bAutoCreate = TRUE;
433
434const wxChar *wxLog::ms_timestamp = wxT("%X"); // time only, no date
435
436wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
437wxArrayString wxLog::ms_aTraceMasks;
438
439// ----------------------------------------------------------------------------
440// stdout error logging helper
441// ----------------------------------------------------------------------------
442
443// helper function: wraps the message and justifies it under given position
444// (looks more pretty on the terminal). Also adds newline at the end.
445//
446// TODO this is now disabled until I find a portable way of determining the
447// terminal window size (ok, I found it but does anybody really cares?)
448#ifdef LOG_PRETTY_WRAP
449static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
450{
451 size_t nMax = 80; // FIXME
452 size_t nStart = strlen(pszPrefix);
453 fputs(pszPrefix, f);
454
455 size_t n;
456 while ( *psz != '\0' ) {
457 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
458 putc(*psz++, f);
459
460 // wrapped?
461 if ( *psz != '\0' ) {
462 /*putc('\n', f);*/
463 for ( n = 0; n < nStart; n++ )
464 putc(' ', f);
465
466 // as we wrapped, squeeze all white space
467 while ( isspace(*psz) )
468 psz++;
469 }
470 }
471
472 putc('\n', f);
473}
474#endif //LOG_PRETTY_WRAP
475
476// ----------------------------------------------------------------------------
477// error code/error message retrieval functions
478// ----------------------------------------------------------------------------
479
480// get error code from syste
481unsigned long wxSysErrorCode()
482{
483#ifdef __WXMSW__
484#ifdef __WIN32__
485 return ::GetLastError();
486#else //WIN16
487 // TODO what to do on Windows 3.1?
488 return 0;
489#endif //WIN16/32
490#else //Unix
491 return errno;
492#endif //Win/Unix
493}
494
495// get error message from system
496const wxChar *wxSysErrorMsg(unsigned long nErrCode)
497{
498 if ( nErrCode == 0 )
499 nErrCode = wxSysErrorCode();
500
501#ifdef __WXMSW__
502#ifdef __WIN32__
503 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
504
505 // get error message from system
506 LPVOID lpMsgBuf;
507 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
508 NULL, nErrCode,
509 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
510 (LPTSTR)&lpMsgBuf,
511 0, NULL);
512
513 // copy it to our buffer and free memory
514 wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
515 s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
516 LocalFree(lpMsgBuf);
517
518 // returned string is capitalized and ended with '\r\n' - bad
519 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
520 size_t len = wxStrlen(s_szBuf);
521 if ( len > 0 ) {
522 // truncate string
523 if ( s_szBuf[len - 2] == wxT('\r') )
524 s_szBuf[len - 2] = wxT('\0');
525 }
526
527 return s_szBuf;
528#else //Win16
529 // TODO
530 return NULL;
531#endif // Win16/32
532#else // Unix
533#if wxUSE_UNICODE
534 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
535 wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
536 return s_szBuf;
537#else
538 return strerror((int)nErrCode);
539#endif
540#endif // Win/Unix
541}
542
543// ----------------------------------------------------------------------------
544// debug helper
545// ----------------------------------------------------------------------------
546
547#ifdef __WXDEBUG__
548
549// break into the debugger
550void Trap()
551{
552#ifdef __WXMSW__
553 DebugBreak();
554#elif defined(__WXMAC__)
555#if __powerc
556 Debugger();
557#else
558 SysBreak();
559#endif
560#elif defined(__UNIX__)
561 raise(SIGTRAP);
562#else
563 // TODO
564#endif // Win/Unix
565}
566
567// this function is called when an assert fails
568void wxOnAssert(const wxChar *szFile, int nLine, const wxChar *szMsg)
569{
570 // this variable can be set to true to suppress "assert failure" messages
571 static bool s_bNoAsserts = FALSE;
572 static bool s_bInAssert = FALSE; // FIXME MT-unsafe
573
574 if ( s_bInAssert ) {
575 // He-e-e-e-elp!! we're trapped in endless loop
576 Trap();
577
578 s_bInAssert = FALSE;
579
580 return;
581 }
582
583 s_bInAssert = TRUE;
584
585 wxChar szBuf[LOG_BUFFER_SIZE];
586
587 // make life easier for people using VC++ IDE: clicking on the message
588 // will take us immediately to the place of the failed assert
589 wxSnprintf(szBuf, WXSIZEOF(szBuf),
590#ifdef __VISUALC__
591 wxT("%s(%d): assert failed"),
592#else // !VC++
593 // make the error message more clear for all the others
594 wxT("Assert failed in file %s at line %d"),
595#endif // VC/!VC
596 szFile, nLine);
597
598 if ( szMsg != NULL ) {
599 wxStrcat(szBuf, wxT(": "));
600 wxStrcat(szBuf, szMsg);
601 }
602 else {
603 wxStrcat(szBuf, wxT("."));
604 }
605
606 if ( !s_bNoAsserts ) {
607 // send it to the normal log destination
608 wxLogDebug(szBuf);
609
610#if wxUSE_GUI || defined(__WXMSW__)
611 // this message is intentionally not translated - it is for
612 // developpers only
613 wxStrcat(szBuf, wxT("\nDo you want to stop the program?"
614 "\nYou can also choose [Cancel] to suppress "
615 "further warnings."));
616
617#if wxUSE_GUI
618 switch ( wxMessageBox(szBuf, "Debug",
619 wxYES_NO | wxCANCEL | wxICON_STOP ) ) {
620 case wxYES:
621 Trap();
622 break;
623
624 case wxCANCEL:
625 s_bNoAsserts = TRUE;
626 break;
627
628 //case wxNO: nothing to do
629 }
630#else // !GUI, but MSW
631 switch ( ::MessageBox(NULL, szBuf, "Debug",
632 MB_YESNOCANCEL | MB_ICONSTOP ) ) {
633 case IDYES:
634 Trap();
635 break;
636
637 case IDCANCEL:
638 s_bNoAsserts = TRUE;
639 break;
640
641 //case IDNO: nothing to do
642 }
643#endif // GUI or MSW
644
645#else // !GUI
646 Trap();
647#endif // GUI/!GUI
648 }
649
650 s_bInAssert = FALSE;
651}
652
653#endif //WXDEBUG
654