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