#include <stdlib.h>
+#ifndef __WXPALMOS5__
#ifndef __WXWINCE__
#include <time.h>
#else
#include "wx/msw/wince/time.h"
#endif
+#endif /* ! __WXPALMOS5__ */
#if defined(__WINDOWS__)
#include "wx/msw/private.h" // includes windows.h
#endif
+#if wxUSE_THREADS
+
+// define static functions providing access to the critical sections we use
+// instead of just using static critical section variables as log functions may
+// be used during static initialization and while this is certainly not
+// advisable it's still better to not crash (as we'd do if we used a yet
+// uninitialized critical section) if it happens
+
+static inline wxCriticalSection& GetTraceMaskCS()
+{
+ static wxCriticalSection s_csTrace;
+
+ return s_csTrace;
+}
+
+static inline wxCriticalSection& GetPreviousLogCS()
+{
+ static wxCriticalSection s_csPrev;
+
+ return s_csPrev;
+}
+
+#endif // wxUSE_THREADS
+
// ----------------------------------------------------------------------------
// non member functions
// ----------------------------------------------------------------------------
void wxSafeShowMessage(const wxString& title, const wxString& text)
{
#ifdef __WINDOWS__
- ::MessageBox(NULL, text.wx_str(), title.wx_str(), MB_OK | MB_ICONSTOP);
+ ::MessageBox(NULL, text.t_str(), title.t_str(), MB_OK | MB_ICONSTOP);
#else
- wxFprintf(stderr, _T("%s: %s\n"), title.c_str(), text.c_str());
+ wxFprintf(stderr, wxS("%s: %s\n"), title.c_str(), text.c_str());
fflush(stderr);
#endif
}
// always terminate the program
void wxVLogFatalError(const wxString& format, va_list argptr)
{
- wxSafeShowMessage(_T("Fatal Error"), wxString::FormatV(format, argptr));
+ wxSafeShowMessage(wxS("Fatal Error"), wxString::FormatV(format, argptr));
#ifdef __WXWINCE__
ExitThread(3);
}
#endif // wxUSE_UNICODE_UTF8
-// debug functions
-#ifdef __WXDEBUG__
+// ----------------------------------------------------------------------------
+// debug and trace functions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_LOG_DEBUG
+ void wxVLogDebug(const wxString& format, va_list argptr)
+ {
+ if ( wxLog::IsEnabled() )
+ {
+ wxLog::OnLog(wxLOG_Debug,
+ wxString::FormatV(format, argptr), time(NULL));
+ }
+ }
#if !wxUSE_UTF8_LOCALE_ONLY
- #define IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \
- void wxDoLog##level##Wchar(const wxChar *format, ...) \
- { \
- va_list argptr; \
- va_start(argptr, format); \
- wxVLog##level(format, argptr); \
- va_end(argptr); \
- }
-#else
- #define IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level)
-#endif
+ void wxDoLogDebugWchar(const wxChar *format, ...)
+ {
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogDebug(format, argptr);
+ va_end(argptr);
+ }
+#endif // !wxUSE_UTF8_LOCALE_ONLY
#if wxUSE_UNICODE_UTF8
- #define IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level) \
- void wxDoLog##level##Utf8(const char *format, ...) \
- { \
- va_list argptr; \
- va_start(argptr, format); \
- wxVLog##level(format, argptr); \
- va_end(argptr); \
- }
-#else
- #define IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level)
-#endif
-
-#define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
- void wxVLog##level(const wxString& format, va_list argptr) \
- { \
- if ( wxLog::IsEnabled() ) { \
- wxLog::OnLog(wxLOG_##level, \
- wxString::FormatV(format, argptr), time(NULL)); \
- } \
- } \
- IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \
- IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level)
-
+ void wxDoLogDebugUtf8(const char *format, ...)
+ {
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogDebug(format, argptr);
+ va_end(argptr);
+ }
+#endif // wxUSE_UNICODE_UTF8
+#endif // wxUSE_LOG_DEBUG
+#if wxUSE_LOG_TRACE
void wxVLogTrace(const wxString& mask, const wxString& format, va_list argptr)
{
if ( wxLog::IsEnabled() && wxLog::IsAllowedTraceMask(mask) ) {
wxString msg;
- msg << _T("(") << mask << _T(") ") << wxString::FormatV(format, argptr);
+ msg << wxS("(") << mask << wxS(") ") << wxString::FormatV(format, argptr);
wxLog::OnLog(wxLOG_Trace, msg, time(NULL));
}
}
#endif // wxUSE_UNICODE_UTF8
+// deprecated (but not declared as such because we don't want to complicate
+// DECLARE_LOG_FUNCTION macros even more) overloads for wxTraceMask
+#if WXWIN_COMPATIBILITY_2_8
void wxVLogTrace(wxTraceMask mask, const wxString& format, va_list argptr)
{
// we check that all of mask bits are set in the current mask, so
}
#endif // wxUSE_UNICODE_UTF8
+#endif // WXWIN_COMPATIBILITY_2_8
+
#ifdef __WATCOMC__
+#if WXWIN_COMPATIBILITY_2_8
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
void wxDoLogTraceWchar(int mask, const wxChar *format, ...)
{
wxVLogTrace(mask, format, argptr);
va_end(argptr);
}
+#endif // WXWIN_COMPATIBILITY_2_8
void wxDoLogTraceWchar(const char *mask, const wxChar *format, ...)
{
va_end(argptr);
}
+#if WXWIN_COMPATIBILITY_2_8
void wxVLogTrace(int mask, const wxString& format, va_list argptr)
{ wxVLogTrace((wxTraceMask)mask, format, argptr); }
+#endif // WXWIN_COMPATIBILITY_2_8
void wxVLogTrace(const char *mask, const wxString& format, va_list argptr)
{ wxVLogTrace(wxString(mask), format, argptr); }
void wxVLogTrace(const wchar_t *mask, const wxString& format, va_list argptr)
{ wxVLogTrace(wxString(mask), format, argptr); }
#endif // __WATCOMC__
+#endif // wxUSE_LOG_TRACE
-#else // release
- #define IMPLEMENT_LOG_DEBUG_FUNCTION(level)
-#endif
-
-IMPLEMENT_LOG_DEBUG_FUNCTION(Debug)
-IMPLEMENT_LOG_DEBUG_FUNCTION(Trace)
// wxLogSysError: one uses the last error code, for other you must give it
// explicitly
return wxString::Format(_(" (error %ld: %s)"), err, wxSysErrorMsg(err));
}
-void WXDLLEXPORT wxVLogSysError(const wxString& format, va_list argptr)
+void WXDLLIMPEXP_BASE wxVLogSysError(const wxString& format, va_list argptr)
{
wxVLogSysError(wxSysErrorCode(), format, argptr);
}
#if !wxUSE_UTF8_LOCALE_ONLY
-void WXDLLEXPORT wxDoLogSysErrorWchar(const wxChar *format, ...)
+void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
#endif // !wxUSE_UTF8_LOCALE_ONLY
#if wxUSE_UNICODE_UTF8
-void WXDLLEXPORT wxDoLogSysErrorUtf8(const char *format, ...)
+void WXDLLIMPEXP_BASE wxDoLogSysErrorUtf8(const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
}
#endif // wxUSE_UNICODE_UTF8
-void WXDLLEXPORT wxVLogSysError(long err, const wxString& format, va_list argptr)
+void WXDLLIMPEXP_BASE wxVLogSysError(long err, const wxString& format, va_list argptr)
{
if ( wxLog::IsEnabled() ) {
wxLog::OnLog(wxLOG_Error,
}
#if !wxUSE_UTF8_LOCALE_ONLY
-void WXDLLEXPORT wxDoLogSysErrorWchar(long lErrCode, const wxChar *format, ...)
+void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(long lErrCode, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
#endif // !wxUSE_UTF8_LOCALE_ONLY
#if wxUSE_UNICODE_UTF8
-void WXDLLEXPORT wxDoLogSysErrorUtf8(long lErrCode, const char *format, ...)
+void WXDLLIMPEXP_BASE wxDoLogSysErrorUtf8(long lErrCode, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
-void WXDLLEXPORT wxDoLogSysErrorWchar(unsigned long lErrCode, const wxChar *format, ...)
+void WXDLLIMPEXP_BASE wxDoLogSysErrorWchar(unsigned long lErrCode, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
}
-void WXDLLEXPORT wxVLogSysError(unsigned long err, const wxString& format, va_list argptr)
+void WXDLLIMPEXP_BASE wxVLogSysError(unsigned long err, const wxString& format, va_list argptr)
{ wxVLogSysError((long)err, format, argptr); }
#endif // __WATCOMC__
// wxLog class implementation
// ----------------------------------------------------------------------------
-unsigned wxLog::LogLastRepetitionCountIfNeeded()
+unsigned wxLog::LogLastRepeatIfNeeded()
{
- wxCRIT_SECT_LOCKER(lock, ms_prevCS);
+ wxCRIT_SECT_LOCKER(lock, GetPreviousLogCS());
+
+ return LogLastRepeatIfNeededUnlocked();
+}
+unsigned wxLog::LogLastRepeatIfNeededUnlocked()
+{
const unsigned count = ms_prevCounter;
if ( ms_prevCounter )
ms_prevCounter),
ms_prevCounter);
#else
- msg.Printf(wxT("The previous message was repeated %lu times."),
+ msg.Printf(wxS("The previous message was repeated %lu times."),
ms_prevCounter);
#endif
ms_prevCounter = 0;
wxLog::~wxLog()
{
- LogLastRepetitionCountIfNeeded();
+ // Flush() must be called before destroying the object as otherwise some
+ // messages could be lost
+ if ( ms_prevCounter )
+ {
+ wxMessageOutputDebug().Printf
+ (
+ wxS("Last repeated message (\"%s\", %lu times) wasn't output"),
+ ms_prevString,
+ ms_prevCounter
+ );
+ }
}
/* static */
{
if ( GetRepetitionCounting() )
{
- wxCRIT_SECT_LOCKER(lock, ms_prevCS);
+ wxCRIT_SECT_LOCKER(lock, GetPreviousLogCS());
if ( szString == ms_prevString )
{
return;
}
- pLogger->LogLastRepetitionCountIfNeeded();
+ pLogger->LogLastRepeatIfNeededUnlocked();
// reset repetition counter for a new message
ms_prevString = szString;
ms_bAutoCreate = true;
}
+void wxLog::AddTraceMask(const wxString& str)
+{
+ wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
+
+ ms_aTraceMasks.push_back(str);
+}
+
void wxLog::RemoveTraceMask(const wxString& str)
{
+ wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
+
int index = ms_aTraceMasks.Index(str);
if ( index != wxNOT_FOUND )
ms_aTraceMasks.RemoveAt((size_t)index);
void wxLog::ClearTraceMasks()
{
+ wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
+
ms_aTraceMasks.Clear();
}
ms_timestamp, wxLocaltime_r(&timeNow, &tm));
str->Empty();
- *str << buf << wxT(": ");
+ *str << buf << wxS(": ");
}
#endif // wxUSE_DATETIME
}
LogString(szString, t);
break;
+#if wxUSE_LOG_DEBUG || wxUSE_LOG_TRACE
+#if wxUSE_LOG_TRACE
case wxLOG_Trace:
+#endif
+#if wxUSE_LOG_DEBUG
case wxLOG_Debug:
-#ifdef __WXDEBUG__
+#endif
{
- wxString msg = level == wxLOG_Trace ? wxT("Trace: ")
- : wxT("Debug: ");
- msg << szString;
- LogString(msg, t);
+ wxString str;
+
+ // don't prepend "debug/trace" prefix under MSW as it goes to
+ // the debug window anyhow and don't add time stamp neither as
+ // debug output viewers under Windows typically add it
+ // themselves anyhow
+ #ifndef __WXMSW__
+ TimeStamp(&str);
+
+ str += level == wxLOG_Trace ? wxT("Trace: ")
+ : wxT("Debug: ");
+ #endif // !__WXMSW__
+
+ str += szString;
+ wxMessageOutputDebug().Output(str);
}
-#endif // Debug
break;
+#endif // wxUSE_LOG_DEBUG || wxUSE_LOG_TRACE
}
}
DoLogString((const char*)szString.mb_str(), t);
DoLogString((const wchar_t*)szString.wc_str(), t);
#else
- wxFAIL_MSG(wxT("DoLogString must be overriden if it's called."));
+ wxFAIL_MSG(wxS("DoLogString must be overriden if it's called."));
wxUnusedVar(szString);
wxUnusedVar(t);
#endif
void wxLog::Flush()
{
- // nothing to do here
+ LogLastRepeatIfNeeded();
}
/*static*/ bool wxLog::IsAllowedTraceMask(const wxString& mask)
{
+ wxCRIT_SECT_LOCKER(lock, GetTraceMaskCS());
+
for ( wxArrayString::iterator it = ms_aTraceMasks.begin(),
en = ms_aTraceMasks.end();
it != en; ++it )
+ {
if ( *it == mask)
return true;
+ }
+
return false;
}
if ( !m_str.empty() )
{
wxMessageOutputBest out;
- out.Printf(_T("%s"), m_str.c_str());
+ out.Printf(wxS("%s"), m_str.c_str());
m_str.clear();
}
}
+#if wxUSE_LOG_DEBUG || wxUSE_LOG_TRACE
+
void wxLogBuffer::DoLog(wxLogLevel level, const wxString& szString, time_t t)
{
- switch ( level )
- {
- case wxLOG_Trace:
- case wxLOG_Debug:
-#ifdef __WXDEBUG__
- // don't put debug messages in the buffer, we don't want to show
- // them to the user in a msg box, log them immediately
- {
- wxString str;
- TimeStamp(&str);
- str += szString;
+ // don't put debug messages in the buffer, we don't want to show
+ // them to the user in a msg box, log them immediately
+ bool showImmediately = false;
+#if wxUSE_LOG_TRACE
+ if ( level == wxLOG_Trace )
+ showImmediately = true;
+#endif
+#if wxUSE_LOG_DEBUG
+ if ( level == wxLOG_Debug )
+ showImmediately = true;
+#endif
- wxMessageOutputDebug dbgout;
- dbgout.Printf(_T("%s\n"), str.c_str());
- }
-#endif // __WXDEBUG__
- break;
+ if ( showImmediately )
+ {
+ wxString str;
+ TimeStamp(&str);
+ str += szString;
- default:
- wxLog::DoLog(level, szString, t);
+ wxMessageOutputDebug dbgout;
+ dbgout.Printf(wxS("%s\n"), str.c_str());
+ }
+ else
+ {
+ wxLog::DoLog(level, szString, t);
}
}
+#endif // wxUSE_LOG_DEBUG || wxUSE_LOG_TRACE
+
void wxLogBuffer::DoLogString(const wxString& szString, time_t WXUNUSED(t))
{
- m_str << szString << _T("\n");
+ m_str << szString << wxS("\n");
}
// ----------------------------------------------------------------------------
str << szString;
wxFputs(str, m_fp);
- wxFputc(_T('\n'), m_fp);
+ wxFputc(wxS('\n'), m_fp);
fflush(m_fp);
// under GUI systems such as Windows or Mac, programs usually don't have
if ( traits && !traits->HasStderr() )
{
wxMessageOutputDebug dbgout;
- dbgout.Printf(_T("%s\n"), str.c_str());
+ dbgout.Printf(wxS("%s\n"), str.c_str());
}
}
}
{
// let the previous logger show it
if ( m_logOld && IsPassingMessages() )
- {
- // bogus cast just to access protected DoLog
- ((wxLogChain *)m_logOld)->DoLog(level, szString, t);
- }
+ m_logOld->Log(level, szString, t);
+ // and also send it to the new one
if ( m_logNew && m_logNew != this )
- {
- // as above...
- ((wxLogChain *)m_logNew)->DoLog(level, szString, t);
- }
+ m_logNew->Log(level, szString, t);
}
#ifdef __VISUALC__
wxLogInterposerTemp::wxLogInterposerTemp()
: wxLogChain(this)
{
- DetachOldLog();
+ DetachOldLog();
}
#ifdef __VISUALC__
// static variables
// ----------------------------------------------------------------------------
-#if wxUSE_THREADS
-wxCriticalSection wxLog::ms_prevCS;
-#endif // wxUSE_THREADS
bool wxLog::ms_bRepetCounting = false;
wxString wxLog::ms_prevString;
unsigned int wxLog::ms_prevCounter = 0;
time_t wxLog::ms_prevTimeStamp= 0;
wxLogLevel wxLog::ms_prevLevel;
-wxLog *wxLog::ms_pLogger = (wxLog *)NULL;
+wxLog *wxLog::ms_pLogger = NULL;
bool wxLog::ms_doLog = true;
bool wxLog::ms_bAutoCreate = true;
bool wxLog::ms_bVerbose = false;
size_t wxLog::ms_suspendCount = 0;
-wxString wxLog::ms_timestamp(wxT("%X")); // time only, no date
+wxString wxLog::ms_timestamp(wxS("%X")); // time only, no date
+#if WXWIN_COMPATIBILITY_2_8
wxTraceMask wxLog::ms_ulTraceMask = (wxTraceMask)0;
+#endif // wxDEBUG_LEVEL
+
wxArrayString wxLog::ms_aTraceMasks;
// ----------------------------------------------------------------------------
{
// if this happens, something is seriously wrong, so don't use _() here
// for safety
- wxSprintf(s_szBuf, _T("unknown error %lx"), nErrCode);
+ wxSprintf(s_szBuf, wxS("unknown error %lx"), nErrCode);
return s_szBuf;
}
#if !defined(__SMARTPHONE__) /* of WinCE */
if( lpMsgBuf != 0 )
{
- wxStrncpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf) - 1);
- s_szBuf[WXSIZEOF(s_szBuf) - 1] = wxT('\0');
+ wxStrlcpy(s_szBuf, (const wxChar *)lpMsgBuf, WXSIZEOF(s_szBuf));
LocalFree(lpMsgBuf);
size_t len = wxStrlen(s_szBuf);
if ( len > 0 ) {
// truncate string
- if ( s_szBuf[len - 2] == wxT('\r') )
- s_szBuf[len - 2] = wxT('\0');
+ if ( s_szBuf[len - 2] == wxS('\r') )
+ s_szBuf[len - 2] = wxS('\0');
}
}
else
#endif // !__SMARTPHONE__
{
- s_szBuf[0] = wxT('\0');
+ s_szBuf[0] = wxS('\0');
}
return s_szBuf;
projects / wxWidgets.git / blobdiff