]> git.saurik.com Git - wxWidgets.git/blame - src/common/log.cpp
Applied patch [ 605189 ] add edit cancel notify to wxTreeEvent
[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
5c922642 512#if defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ > 0x5300)
7d610b90 513
5c922642 514#if !TARGET_API_MAC_CARBON
925ee99f
GD
515// MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
516
0adad2d7
SC
517#ifndef __MetroNubUtils__
518#include "MetroNubUtils.h"
519#endif
520
521#ifdef __cplusplus
04662def 522 extern "C" {
0adad2d7
SC
523#endif
524
525#ifndef __GESTALT__
526#include <Gestalt.h>
527#endif
528
529#ifndef true
530#define true 1
531#endif
532
533#ifndef false
534#define false 0
535#endif
536
537#if TARGET_API_MAC_CARBON
538
04662def
RL
539 #include <CodeFragments.h>
540
541 EXTERN_API_C( long )
542 CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
0adad2d7 543
04662def 544 ProcPtr gCallUniversalProc_Proc = NULL;
0adad2d7 545
0adad2d7
SC
546#endif
547
04662def 548static MetroNubUserEntryBlock* gMetroNubEntry = NULL;
0adad2d7
SC
549
550static long fRunOnce = false;
551
552Boolean IsCompatibleVersion(short inVersion);
553
554/* ---------------------------------------------------------------------------
04662def 555 IsCompatibleVersion
0adad2d7
SC
556 --------------------------------------------------------------------------- */
557
558Boolean IsCompatibleVersion(short inVersion)
03147cd0 559{
04662def
RL
560 Boolean result = false;
561
562 if (fRunOnce)
563 {
564 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
565
566 result = (inVersion <= block->apiHiVersion);
567 }
568
d91535c4 569 return result;
0adad2d7 570}
03147cd0 571
0adad2d7 572/* ---------------------------------------------------------------------------
04662def 573 IsMetroNubInstalled
0adad2d7 574 --------------------------------------------------------------------------- */
03147cd0 575
0adad2d7
SC
576Boolean IsMetroNubInstalled()
577{
04662def
RL
578 if (!fRunOnce)
579 {
580 long result, value;
581
582 fRunOnce = true;
583 gMetroNubEntry = NULL;
584
585 if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
586 {
587 /* look for MetroNub's Gestalt selector */
588 if (Gestalt(kMetroNubUserSignature, &result) == noErr)
589 {
590
591 #if TARGET_API_MAC_CARBON
592 if (gCallUniversalProc_Proc == NULL)
593 {
594 CFragConnectionID connectionID;
595 Ptr mainAddress;
596 Str255 errorString;
597 ProcPtr symbolAddress;
598 OSErr err;
599 CFragSymbolClass symbolClass;
600
601 symbolAddress = NULL;
602 err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
603 &connectionID, &mainAddress, errorString);
604
605 if (err != noErr)
606 {
607 gCallUniversalProc_Proc = NULL;
608 goto end;
609 }
610
611 err = FindSymbol(connectionID, "\pCallUniversalProc",
612 (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
613
614 if (err != noErr)
615 {
616 gCallUniversalProc_Proc = NULL;
617 goto end;
618 }
619 }
620 #endif
621
622 {
623 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
624
625 /* make sure the version of the API is compatible */
626 if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
627 kMetroNubUserAPIVersion <= block->apiHiVersion)
628 gMetroNubEntry = block; /* success! */
629 }
630
631 }
632 }
633 }
0adad2d7
SC
634
635end:
636
637#if TARGET_API_MAC_CARBON
04662def 638 return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
0adad2d7 639#else
04662def 640 return (gMetroNubEntry != NULL);
0adad2d7
SC
641#endif
642}
03147cd0 643
0adad2d7 644/* ---------------------------------------------------------------------------
04662def 645 IsMWDebuggerRunning [v1 API]
0adad2d7
SC
646 --------------------------------------------------------------------------- */
647
648Boolean IsMWDebuggerRunning()
649{
04662def
RL
650 if (IsMetroNubInstalled())
651 return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
652 else
653 return false;
0adad2d7
SC
654}
655
656/* ---------------------------------------------------------------------------
04662def 657 AmIBeingMWDebugged [v1 API]
0adad2d7
SC
658 --------------------------------------------------------------------------- */
659
660Boolean AmIBeingMWDebugged()
661{
04662def
RL
662 if (IsMetroNubInstalled())
663 return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
664 else
665 return false;
7d610b90
SC
666}
667
0adad2d7 668/* ---------------------------------------------------------------------------
04662def 669 UserSetWatchPoint [v2 API]
0adad2d7
SC
670 --------------------------------------------------------------------------- */
671
672OSErr UserSetWatchPoint (Ptr address, long length, WatchPointIDT* watchPointID)
7d610b90 673{
04662def
RL
674 if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion))
675 return CallUserSetWatchPointProc(gMetroNubEntry->userSetWatchPoint,
676 address, length, watchPointID);
677 else
678 return errProcessIsNotClient;
7d610b90
SC
679}
680
0adad2d7 681/* ---------------------------------------------------------------------------
04662def 682 ClearWatchPoint [v2 API]
0adad2d7
SC
683 --------------------------------------------------------------------------- */
684
685OSErr ClearWatchPoint (WatchPointIDT watchPointID)
7d610b90 686{
04662def
RL
687 if (IsMetroNubInstalled() && IsCompatibleVersion(kMetroNubUserAPIVersion))
688 return CallClearWatchPointProc(gMetroNubEntry->clearWatchPoint, watchPointID);
689 else
690 return errProcessIsNotClient;
7d610b90 691}
0adad2d7
SC
692
693#ifdef __cplusplus
04662def 694 }
0adad2d7
SC
695#endif
696
5c922642 697#endif // !TARGET_API_MAC_CARBON
925ee99f 698
5c922642 699#endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ > 0x5300)
7d610b90 700
74e3313b 701void wxLogStderr::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
c801d85f 702{
d2e1ef19
VZ
703 wxString str;
704 TimeStamp(&str);
b568d04f 705 str << szString;
1e8a4bc2 706
50920146 707 fputs(str.mb_str(), m_fp);
b568d04f 708 fputc(_T('\n'), m_fp);
0fb67cd1 709 fflush(m_fp);
1e8a4bc2 710
378b05f7 711 // under Windows, programs usually don't have stderr at all, so show the
b568d04f 712 // messages also under debugger - unless it's a console program
8cb172b4 713#if defined(__WXMSW__) && wxUSE_GUI && !defined(__WXMICROWIN__)
f6bcfd97
BP
714 str += wxT("\r\n") ;
715 OutputDebugString(str.c_str());
1e8a4bc2 716#endif // MSW
0cbb9297 717#if defined(__WXMAC__) && !defined(__DARWIN__) && wxUSE_GUI
03147cd0
VZ
718 Str255 pstr ;
719 strcpy( (char*) pstr , str.c_str() ) ;
720 strcat( (char*) pstr , ";g" ) ;
721 c2pstr( (char*) pstr ) ;
0adad2d7 722
03147cd0
VZ
723 Boolean running = false ;
724
5c922642 725#if !TARGET_API_MAC_CARBON && (__MWERKS__ > 0x5300)
925ee99f 726
0adad2d7 727 if ( IsMWDebuggerRunning() && AmIBeingMWDebugged() )
03147cd0 728 {
0adad2d7 729 running = true ;
03147cd0 730 }
0adad2d7 731
925ee99f
GD
732#endif
733
03147cd0
VZ
734 if (running)
735 {
736#ifdef __powerc
737 DebugStr(pstr);
738#else
739 SysBreakStr(pstr);
7d610b90 740#endif
03147cd0 741 }
03e11df5 742#endif // Mac
c801d85f
KB
743}
744
745// ----------------------------------------------------------------------------
746// wxLogStream implementation
747// ----------------------------------------------------------------------------
748
4bf78aae 749#if wxUSE_STD_IOSTREAM
dd107c50 750wxLogStream::wxLogStream(wxSTD ostream *ostr)
c801d85f 751{
0fb67cd1 752 if ( ostr == NULL )
dd107c50 753 m_ostr = &wxSTD cerr;
0fb67cd1
VZ
754 else
755 m_ostr = ostr;
c801d85f
KB
756}
757
74e3313b 758void wxLogStream::DoLogString(const wxChar *szString, time_t WXUNUSED(t))
c801d85f 759{
29fd317b
VZ
760 wxString str;
761 TimeStamp(&str);
dd107c50 762 (*m_ostr) << str << wxConvertWX2MB(szString) << wxSTD endl;
c801d85f 763}
0fb67cd1 764#endif // wxUSE_STD_IOSTREAM
c801d85f 765
03147cd0
VZ
766// ----------------------------------------------------------------------------
767// wxLogChain
768// ----------------------------------------------------------------------------
769
770wxLogChain::wxLogChain(wxLog *logger)
771{
71debe95
VZ
772 m_bPassMessages = TRUE;
773
03147cd0
VZ
774 m_logNew = logger;
775 m_logOld = wxLog::SetActiveTarget(this);
776}
777
199e91fb
VZ
778wxLogChain::~wxLogChain()
779{
e95f8fde
VZ
780 delete m_logOld;
781
782 if ( m_logNew != this )
783 delete m_logNew;
199e91fb
VZ
784}
785
03147cd0
VZ
786void wxLogChain::SetLog(wxLog *logger)
787{
788 if ( m_logNew != this )
789 delete m_logNew;
790
03147cd0
VZ
791 m_logNew = logger;
792}
793
794void wxLogChain::Flush()
795{
796 if ( m_logOld )
797 m_logOld->Flush();
798
799 // be careful to avoid inifinite recursion
800 if ( m_logNew && m_logNew != this )
801 m_logNew->Flush();
802}
803
804void wxLogChain::DoLog(wxLogLevel level, const wxChar *szString, time_t t)
805{
806 // let the previous logger show it
807 if ( m_logOld && IsPassingMessages() )
808 {
809 // bogus cast just to access protected DoLog
810 ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
811 }
812
813 if ( m_logNew && m_logNew != this )
814 {
815 // as above...
816 ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
817 }
818}
819
93d4c1d0
VZ
820// ----------------------------------------------------------------------------
821// wxLogPassThrough
822// ----------------------------------------------------------------------------
823
824#ifdef __VISUALC__
825 // "'this' : used in base member initializer list" - so what?
826 #pragma warning(disable:4355)
827#endif // VC++
828
829wxLogPassThrough::wxLogPassThrough()
830 : wxLogChain(this)
831{
832}
833
834#ifdef __VISUALC__
835 #pragma warning(default:4355)
836#endif // VC++
837
c801d85f
KB
838// ============================================================================
839// Global functions/variables
840// ============================================================================
841
842// ----------------------------------------------------------------------------
843// static variables
844// ----------------------------------------------------------------------------
0fb67cd1
VZ
845
846wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
847bool wxLog::ms_doLog = TRUE;
848bool wxLog::ms_bAutoCreate = TRUE;
fd7718b2 849bool wxLog::ms_bVerbose = FALSE;
d2e1ef19 850
2ed3265e
VZ
851size_t wxLog::ms_suspendCount = 0;
852
9f83044f
VZ
853#if wxUSE_GUI
854 const wxChar *wxLog::ms_timestamp = wxT("%X"); // time only, no date
855#else
856 const wxChar *wxLog::ms_timestamp = NULL; // save space
857#endif
d2e1ef19 858
0fb67cd1
VZ
859wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
860wxArrayString wxLog::ms_aTraceMasks;
c801d85f
KB
861
862// ----------------------------------------------------------------------------
863// stdout error logging helper
864// ----------------------------------------------------------------------------
865
866// helper function: wraps the message and justifies it under given position
867// (looks more pretty on the terminal). Also adds newline at the end.
868//
0fb67cd1
VZ
869// TODO this is now disabled until I find a portable way of determining the
870// terminal window size (ok, I found it but does anybody really cares?)
871#ifdef LOG_PRETTY_WRAP
c801d85f
KB
872static void wxLogWrap(FILE *f, const char *pszPrefix, const char *psz)
873{
0fb67cd1
VZ
874 size_t nMax = 80; // FIXME
875 size_t nStart = strlen(pszPrefix);
876 fputs(pszPrefix, f);
877
878 size_t n;
879 while ( *psz != '\0' ) {
880 for ( n = nStart; (n < nMax) && (*psz != '\0'); n++ )
881 putc(*psz++, f);
882
883 // wrapped?
884 if ( *psz != '\0' ) {
885 /*putc('\n', f);*/
886 for ( n = 0; n < nStart; n++ )
887 putc(' ', f);
888
889 // as we wrapped, squeeze all white space
890 while ( isspace(*psz) )
891 psz++;
892 }
c801d85f 893 }
c801d85f 894
0fb67cd1 895 putc('\n', f);
c801d85f
KB
896}
897#endif //LOG_PRETTY_WRAP
898
899// ----------------------------------------------------------------------------
900// error code/error message retrieval functions
901// ----------------------------------------------------------------------------
902
903// get error code from syste
904unsigned long wxSysErrorCode()
905{
8cb172b4 906#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
0fb67cd1
VZ
907#ifdef __WIN32__
908 return ::GetLastError();
909#else //WIN16
910 // TODO what to do on Windows 3.1?
911 return 0;
912#endif //WIN16/32
913#else //Unix
c801d85f 914 return errno;
0fb67cd1 915#endif //Win/Unix
c801d85f
KB
916}
917
918// get error message from system
50920146 919const wxChar *wxSysErrorMsg(unsigned long nErrCode)
c801d85f 920{
0fb67cd1
VZ
921 if ( nErrCode == 0 )
922 nErrCode = wxSysErrorCode();
923
8cb172b4 924#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
0fb67cd1 925#ifdef __WIN32__
50920146 926 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
0fb67cd1
VZ
927
928 // get error message from system
929 LPVOID lpMsgBuf;
930 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
931 NULL, nErrCode,
932 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
933 (LPTSTR)&lpMsgBuf,
934 0, NULL);
935
936 // copy it to our buffer and free memory
251244a0 937 if( lpMsgBuf != 0 ) {
8c5b1f0f 938 wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
251244a0
VZ
939 s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
940
941 LocalFree(lpMsgBuf);
942
943 // returned string is capitalized and ended with '\r\n' - bad
944 s_szBuf[0] = (wxChar)wxTolower(s_szBuf[0]);
945 size_t len = wxStrlen(s_szBuf);
946 if ( len > 0 ) {
947 // truncate string
948 if ( s_szBuf[len - 2] == wxT('\r') )
949 s_szBuf[len - 2] = wxT('\0');
950 }
951 }
952 else {
8c5b1f0f 953 s_szBuf[0] = wxT('\0');
0fb67cd1
VZ
954 }
955
956 return s_szBuf;
957#else //Win16
958 // TODO
959 return NULL;
960#endif // Win16/32
961#else // Unix
50920146
OK
962#if wxUSE_UNICODE
963 static wxChar s_szBuf[LOG_BUFFER_SIZE / 2];
dcf924a3 964 wxConvCurrent->MB2WC(s_szBuf, strerror(nErrCode), WXSIZEOF(s_szBuf) -1);
50920146
OK
965 return s_szBuf;
966#else
13111b2a 967 return strerror((int)nErrCode);
50920146 968#endif
0fb67cd1 969#endif // Win/Unix
c801d85f
KB
970}
971
f94dfb38 972#endif //wxUSE_LOG
04662def
RL
973
974// vi:sts=4:sw=4:et