///////////////////////////////////////////////////////////////////////////// // Name: wx/log.h // Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs) // Author: Vadim Zeitlin // Modified by: // Created: 29/01/98 // Copyright: (c) 1998 Vadim Zeitlin // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// #ifndef _WX_LOG_H_ #define _WX_LOG_H_ #include "wx/defs.h" #include "wx/cpp.h" // ---------------------------------------------------------------------------- // types // ---------------------------------------------------------------------------- // NB: this is needed even if wxUSE_LOG == 0 typedef unsigned long wxLogLevel; // the trace masks have been superseded by symbolic trace constants, they're // for compatibility only and will be removed soon - do NOT use them #if WXWIN_COMPATIBILITY_2_8 #define wxTraceMemAlloc 0x0001 // trace memory allocation (new/delete) #define wxTraceMessages 0x0002 // trace window messages/X callbacks #define wxTraceResAlloc 0x0004 // trace GDI resource allocation #define wxTraceRefCount 0x0008 // trace various ref counting operations #ifdef __WINDOWS__ #define wxTraceOleCalls 0x0100 // OLE interface calls #endif typedef unsigned long wxTraceMask; #endif // WXWIN_COMPATIBILITY_2_8 // ---------------------------------------------------------------------------- // headers // ---------------------------------------------------------------------------- #include "wx/string.h" #include "wx/strvararg.h" // ---------------------------------------------------------------------------- // forward declarations // ---------------------------------------------------------------------------- class WXDLLIMPEXP_FWD_BASE wxObject; #if wxUSE_GUI class WXDLLIMPEXP_FWD_CORE wxFrame; #endif // wxUSE_GUI #if wxUSE_LOG #include "wx/arrstr.h" #include // for time_t #include "wx/dynarray.h" #include "wx/hashmap.h" #include "wx/msgout.h" #if wxUSE_THREADS #include "wx/thread.h" #endif // wxUSE_THREADS // wxUSE_LOG_DEBUG enables the debug log messages #ifndef wxUSE_LOG_DEBUG #if wxDEBUG_LEVEL #define wxUSE_LOG_DEBUG 1 #else // !wxDEBUG_LEVEL #define wxUSE_LOG_DEBUG 0 #endif #endif // wxUSE_LOG_TRACE enables the trace messages, they are disabled by default #ifndef wxUSE_LOG_TRACE #if wxDEBUG_LEVEL #define wxUSE_LOG_TRACE 1 #else // !wxDEBUG_LEVEL #define wxUSE_LOG_TRACE 0 #endif #endif // wxUSE_LOG_TRACE // wxLOG_COMPONENT identifies the component which generated the log record and // can be #define'd to a user-defined value when compiling the user code to use // component-based filtering (see wxLog::SetComponentLevel()) #ifndef wxLOG_COMPONENT // this is a variable and not a macro in order to allow the user code to // just #define wxLOG_COMPONENT without #undef'ining it first extern WXDLLIMPEXP_DATA_BASE(const char *) wxLOG_COMPONENT; #ifdef WXBUILDING #define wxLOG_COMPONENT "wx" #endif #endif // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- // different standard log levels (you may also define your own) enum wxLogLevelValues { wxLOG_FatalError, // program can't continue, abort immediately wxLOG_Error, // a serious error, user must be informed about it wxLOG_Warning, // user is normally informed about it but may be ignored wxLOG_Message, // normal message (i.e. normal output of a non GUI app) wxLOG_Status, // informational: might go to the status line of GUI app wxLOG_Info, // informational message (a.k.a. 'Verbose') wxLOG_Debug, // never shown to the user, disabled in release mode wxLOG_Trace, // trace messages are also only enabled in debug mode wxLOG_Progress, // used for progress indicator (not yet) wxLOG_User = 100, // user defined levels start here wxLOG_Max = 10000 }; // symbolic trace masks - wxLogTrace("foo", "some trace message...") will be // discarded unless the string "foo" has been added to the list of allowed // ones with AddTraceMask() #define wxTRACE_MemAlloc wxT("memalloc") // trace memory allocation (new/delete) #define wxTRACE_Messages wxT("messages") // trace window messages/X callbacks #define wxTRACE_ResAlloc wxT("resalloc") // trace GDI resource allocation #define wxTRACE_RefCount wxT("refcount") // trace various ref counting operations #ifdef __WINDOWS__ #define wxTRACE_OleCalls wxT("ole") // OLE interface calls #endif #include "wx/iosfwrap.h" // ---------------------------------------------------------------------------- // information about a log record, i.e. unit of log output // ---------------------------------------------------------------------------- class wxLogRecordInfo { public: // default ctor creates an uninitialized object wxLogRecordInfo() { memset(this, 0, sizeof(*this)); } // normal ctor, used by wxLogger specifies the location of the log // statement; its time stamp and thread id are set up here wxLogRecordInfo(const char *filename_, int line_, const char *func_, const char *component_) { filename = filename_; func = func_; line = line_; component = component_; // don't initialize the timestamp yet, we might not need it at all if // the message doesn't end up being logged and otherwise we'll fill it // just before logging it, which won't change it by much and definitely // less than a second resolution of the timestamp timestamp = 0; #if wxUSE_THREADS threadId = wxThread::GetCurrentId(); #endif // wxUSE_THREADS m_data = NULL; } // we need to define copy ctor and assignment operator because of m_data wxLogRecordInfo(const wxLogRecordInfo& other) { Copy(other); } wxLogRecordInfo& operator=(const wxLogRecordInfo& other) { if ( &other != this ) { delete m_data; Copy(other); } return *this; } // dtor is non-virtual, this class is not meant to be derived from ~wxLogRecordInfo() { delete m_data; } // the file name and line number of the file where the log record was // generated, if available or NULL and 0 otherwise const char *filename; int line; // the name of the function where the log record was generated (may be NULL // if the compiler doesn't support __FUNCTION__) const char *func; // the name of the component which generated this message, may be NULL if // not set (i.e. wxLOG_COMPONENT not defined) const char *component; // time of record generation time_t timestamp; #if wxUSE_THREADS // id of the thread which logged this record wxThreadIdType threadId; #endif // wxUSE_THREADS // store an arbitrary value in this record context // // wxWidgets always uses keys starting with "wx.", e.g. "wx.sys_error" void StoreValue(const wxString& key, wxUIntPtr val) { if ( !m_data ) m_data = new ExtraData; m_data->numValues[key] = val; } void StoreValue(const wxString& key, const wxString& val) { if ( !m_data ) m_data = new ExtraData; m_data->strValues[key] = val; } // these functions retrieve the value of either numeric or string key, // return false if not found bool GetNumValue(const wxString& key, wxUIntPtr *val) const { if ( !m_data ) return false; const wxStringToNumHashMap::const_iterator it = m_data->numValues.find(key); if ( it == m_data->numValues.end() ) return false; *val = it->second; return true; } bool GetStrValue(const wxString& key, wxString *val) const { if ( !m_data ) return false; const wxStringToStringHashMap::const_iterator it = m_data->strValues.find(key); if ( it == m_data->strValues.end() ) return false; *val = it->second; return true; } private: void Copy(const wxLogRecordInfo& other) { memcpy(this, &other, sizeof(*this)); if ( other.m_data ) m_data = new ExtraData(*other.m_data); } // extra data associated with the log record: this is completely optional // and can be used to pass information from the log function to the log // sink (e.g. wxLogSysError() uses this to pass the error code) struct ExtraData { wxStringToNumHashMap numValues; wxStringToStringHashMap strValues; }; // NULL if not used ExtraData *m_data; }; #define wxLOG_KEY_TRACE_MASK "wx.trace_mask" // ---------------------------------------------------------------------------- // log record: a unit of log output // ---------------------------------------------------------------------------- struct wxLogRecord { wxLogRecord(wxLogLevel level_, const wxString& msg_, const wxLogRecordInfo& info_) : level(level_), msg(msg_), info(info_) { } wxLogLevel level; wxString msg; wxLogRecordInfo info; }; // ---------------------------------------------------------------------------- // Derive from this class to customize format of log messages. // ---------------------------------------------------------------------------- class WXDLLIMPEXP_BASE wxLogFormatter { public: // Default constructor. wxLogFormatter() { } // Trivial but virtual destructor for the base class. virtual ~wxLogFormatter() { } // Override this method to implement custom formatting of the given log // record. The default implementation simply prepends a level-dependent // prefix to the message and optionally adds a time stamp. virtual wxString Format(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info) const; protected: // Override this method to change just the time stamp formatting. It is // called by default Format() implementation. virtual wxString FormatTime(time_t t) const; }; // ---------------------------------------------------------------------------- // derive from this class to redirect (or suppress, or ...) log messages // normally, only a single instance of this class exists but it's not enforced // ---------------------------------------------------------------------------- class WXDLLIMPEXP_BASE wxLog { public: // ctor wxLog() : m_formatter(new wxLogFormatter) { } // make dtor virtual for all derived classes virtual ~wxLog(); // log messages selection // ---------------------- // these functions allow to completely disable all log messages or disable // log messages at level less important than specified for the current // thread // is logging enabled at all now? static bool IsEnabled() { #if wxUSE_THREADS if ( !wxThread::IsMain() ) return IsThreadLoggingEnabled(); #endif // wxUSE_THREADS return ms_doLog; } // change the flag state, return the previous one static bool EnableLogging(bool enable = true) { #if wxUSE_THREADS if ( !wxThread::IsMain() ) return EnableThreadLogging(enable); #endif // wxUSE_THREADS const bool doLogOld = ms_doLog; ms_doLog = enable; return doLogOld; } // return the current global log level static wxLogLevel GetLogLevel() { return ms_logLevel; } // set global log level: messages with level > logLevel will not be logged static void SetLogLevel(wxLogLevel logLevel) { ms_logLevel = logLevel; } // set the log level for the given component static void SetComponentLevel(const wxString& component, wxLogLevel level); // return the effective log level for this component, falling back to // parent component and to the default global log level if necessary static wxLogLevel GetComponentLevel(const wxString& component); // is logging of messages from this component enabled at this level? // // usually always called with wxLOG_COMPONENT as second argument static bool IsLevelEnabled(wxLogLevel level, const wxString& component) { return IsEnabled() && level <= GetComponentLevel(component); } // enable/disable messages at wxLOG_Verbose level (only relevant if the // current log level is greater or equal to it) // // notice that verbose mode can be activated by the standard command-line // '--verbose' option static void SetVerbose(bool bVerbose = true) { ms_bVerbose = bVerbose; } // check if verbose messages are enabled static bool GetVerbose() { return ms_bVerbose; } // message buffering // ----------------- // flush shows all messages if they're not logged immediately (FILE // and iostream logs don't need it, but wxLogGui does to avoid showing // 17 modal dialogs one after another) virtual void Flush(); // flush the active target if any and also output any pending messages from // background threads static void FlushActive(); // only one sink is active at each moment get current log target, will call // wxAppTraits::CreateLogTarget() to create one if none exists static wxLog *GetActiveTarget(); // change log target, logger may be NULL static wxLog *SetActiveTarget(wxLog *logger); #if wxUSE_THREADS // change log target for the current thread only, shouldn't be called from // the main thread as it doesn't use thread-specific log target static wxLog *SetThreadActiveTarget(wxLog *logger); #endif // wxUSE_THREADS // suspend the message flushing of the main target until the next call // to Resume() - this is mainly for internal use (to prevent wxYield() // from flashing the messages) static void Suspend() { ms_suspendCount++; } // must be called for each Suspend()! static void Resume() { ms_suspendCount--; } // should GetActiveTarget() try to create a new log object if the // current is NULL? static void DontCreateOnDemand(); // Make GetActiveTarget() create a new log object again. static void DoCreateOnDemand(); // log the count of repeating messages instead of logging the messages // multiple times static void SetRepetitionCounting(bool bRepetCounting = true) { ms_bRepetCounting = bRepetCounting; } // gets duplicate counting status static bool GetRepetitionCounting() { return ms_bRepetCounting; } // add string trace mask static void AddTraceMask(const wxString& str); // add string trace mask static void RemoveTraceMask(const wxString& str); // remove all string trace masks static void ClearTraceMasks(); // get string trace masks: note that this is MT-unsafe if other threads can // call AddTraceMask() concurrently static const wxArrayString& GetTraceMasks(); // is this trace mask in the list? static bool IsAllowedTraceMask(const wxString& mask); // log formatting // ----------------- // Change wxLogFormatter object used by wxLog to format the log messages. // // wxLog takes ownership of the pointer passed in but the caller is // responsible for deleting the returned pointer. wxLogFormatter* SetFormatter(wxLogFormatter* formatter); // All the time stamp related functions below only work when the default // wxLogFormatter is being used. Defining a custom formatter overrides them // as it could use its own time stamp format or format messages without // using time stamp at all. // sets the time stamp string format: this is used as strftime() format // string for the log targets which add time stamps to the messages; set // it to empty string to disable time stamping completely. static void SetTimestamp(const wxString& ts) { ms_timestamp = ts; } // disable time stamping of log messages static void DisableTimestamp() { SetTimestamp(wxEmptyString); } // get the current timestamp format string (maybe empty) static const wxString& GetTimestamp() { return ms_timestamp; } // helpers: all functions in this section are mostly for internal use only, // don't call them from your code even if they are not formally deprecated // put the time stamp into the string if ms_timestamp is not empty (don't // change it otherwise); the first overload uses the current time. static void TimeStamp(wxString *str); static void TimeStamp(wxString *str, time_t t); // these methods should only be called from derived classes DoLogRecord(), // DoLogTextAtLevel() and DoLogText() implementations respectively and // shouldn't be called directly, use logging functions instead void LogRecord(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info) { DoLogRecord(level, msg, info); } void LogTextAtLevel(wxLogLevel level, const wxString& msg) { DoLogTextAtLevel(level, msg); } void LogText(const wxString& msg) { DoLogText(msg); } // this is a helper used by wxLogXXX() functions, don't call it directly // and see DoLog() for function to overload in the derived classes static void OnLog(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info); // version called when no information about the location of the log record // generation is available (but the time stamp is), it mainly exists for // backwards compatibility, don't use it in new code static void OnLog(wxLogLevel level, const wxString& msg, time_t t); // a helper calling the above overload with current time static void OnLog(wxLogLevel level, const wxString& msg) { OnLog(level, msg, time(NULL)); } // this method exists for backwards compatibility only, don't use bool HasPendingMessages() const { return true; } // don't use integer masks any more, use string trace masks instead #if WXWIN_COMPATIBILITY_2_8 static wxDEPRECATED_INLINE( void SetTraceMask(wxTraceMask ulMask), ms_ulTraceMask = ulMask; ) // this one can't be marked deprecated as it's used in our own wxLogger // below but it still is deprecated and shouldn't be used static wxTraceMask GetTraceMask() { return ms_ulTraceMask; } #endif // WXWIN_COMPATIBILITY_2_8 protected: // the logging functions that can be overridden: DoLogRecord() is called // for every "record", i.e. a unit of log output, to be logged and by // default formats the message and passes it to DoLogTextAtLevel() which in // turn passes it to DoLogText() by default // override this method if you want to change message formatting or do // dynamic filtering virtual void DoLogRecord(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info); // override this method to redirect output to different channels depending // on its level only; if even the level doesn't matter, override // DoLogText() instead virtual void DoLogTextAtLevel(wxLogLevel level, const wxString& msg); // this function is not pure virtual as it might not be needed if you do // the logging in overridden DoLogRecord() or DoLogTextAtLevel() directly // but if you do not override them in your derived class you must override // this one as the default implementation of it simply asserts virtual void DoLogText(const wxString& msg); // the rest of the functions are for backwards compatibility only, don't // use them in new code; if you're updating your existing code you need to // switch to overriding DoLogRecord/Text() above (although as long as these // functions exist, log classes using them will continue to work) #if WXWIN_COMPATIBILITY_2_8 wxDEPRECATED_BUT_USED_INTERNALLY( virtual void DoLog(wxLogLevel level, const char *szString, time_t t) ); wxDEPRECATED_BUT_USED_INTERNALLY( virtual void DoLog(wxLogLevel level, const wchar_t *wzString, time_t t) ); // these shouldn't be used by new code wxDEPRECATED_BUT_USED_INTERNALLY_INLINE( virtual void DoLogString(const char *WXUNUSED(szString), time_t WXUNUSED(t)), wxEMPTY_PARAMETER_VALUE ) wxDEPRECATED_BUT_USED_INTERNALLY_INLINE( virtual void DoLogString(const wchar_t *WXUNUSED(wzString), time_t WXUNUSED(t)), wxEMPTY_PARAMETER_VALUE ) #endif // WXWIN_COMPATIBILITY_2_8 // log a message indicating the number of times the previous message was // repeated if previous repetition counter is strictly positive, does // nothing otherwise; return the old value of repetition counter unsigned LogLastRepeatIfNeeded(); private: #if wxUSE_THREADS // called from FlushActive() to really log any buffered messages logged // from the other threads void FlushThreadMessages(); // these functions are called for non-main thread only by IsEnabled() and // EnableLogging() respectively static bool IsThreadLoggingEnabled(); static bool EnableThreadLogging(bool enable = true); #endif // wxUSE_THREADS // get the active log target for the main thread, auto-creating it if // necessary // // this is called from GetActiveTarget() and OnLog() when they're called // from the main thread static wxLog *GetMainThreadActiveTarget(); // called from OnLog() if it's called from the main thread or if we have a // (presumably MT-safe) thread-specific logger and by FlushThreadMessages() // when it plays back the buffered messages logged from the other threads void CallDoLogNow(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info); // variables // ---------------- wxLogFormatter *m_formatter; // We own this pointer. // static variables // ---------------- // if true, don't log the same message multiple times, only log it once // with the number of times it was repeated static bool ms_bRepetCounting; static wxLog *ms_pLogger; // currently active log sink static bool ms_doLog; // false => all logging disabled static bool ms_bAutoCreate; // create new log targets on demand? static bool ms_bVerbose; // false => ignore LogInfo messages static wxLogLevel ms_logLevel; // limit logging to levels <= ms_logLevel static size_t ms_suspendCount; // if positive, logs are not flushed // format string for strftime(), if empty, time stamping log messages is // disabled static wxString ms_timestamp; #if WXWIN_COMPATIBILITY_2_8 static wxTraceMask ms_ulTraceMask; // controls wxLogTrace behaviour #endif // WXWIN_COMPATIBILITY_2_8 wxDECLARE_NO_COPY_CLASS(wxLog); }; // ---------------------------------------------------------------------------- // "trivial" derivations of wxLog // ---------------------------------------------------------------------------- // log everything except for the debug/trace messages (which are passed to // wxMessageOutputDebug) to a buffer class WXDLLIMPEXP_BASE wxLogBuffer : public wxLog { public: wxLogBuffer() { } // get the string contents with all messages logged const wxString& GetBuffer() const { return m_str; } // show the buffer contents to the user in the best possible way (this uses // wxMessageOutputMessageBox) and clear it virtual void Flush() wxOVERRIDE; protected: virtual void DoLogTextAtLevel(wxLogLevel level, const wxString& msg) wxOVERRIDE; private: wxString m_str; wxDECLARE_NO_COPY_CLASS(wxLogBuffer); }; // log everything to a "FILE *", stderr by default class WXDLLIMPEXP_BASE wxLogStderr : public wxLog, protected wxMessageOutputStderr { public: // redirect log output to a FILE wxLogStderr(FILE *fp = NULL, const wxMBConv &conv = wxConvWhateverWorks); protected: // implement sink function virtual void DoLogText(const wxString& msg) wxOVERRIDE; wxDECLARE_NO_COPY_CLASS(wxLogStderr); }; #if wxUSE_STD_IOSTREAM // log everything to an "ostream", cerr by default class WXDLLIMPEXP_BASE wxLogStream : public wxLog, private wxMessageOutputWithConv { public: // redirect log output to an ostream wxLogStream(wxSTD ostream *ostr = (wxSTD ostream *) NULL, const wxMBConv& conv = wxConvWhateverWorks); protected: // implement sink function virtual void DoLogText(const wxString& msg) wxOVERRIDE; // using ptr here to avoid including from this file wxSTD ostream *m_ostr; wxDECLARE_NO_COPY_CLASS(wxLogStream); }; #endif // wxUSE_STD_IOSTREAM // ---------------------------------------------------------------------------- // /dev/null log target: suppress logging until this object goes out of scope // ---------------------------------------------------------------------------- // example of usage: /* void Foo() { wxFile file; // wxFile.Open() normally complains if file can't be opened, we don't // want it wxLogNull logNo; if ( !file.Open("bar") ) ... process error ourselves ... // ~wxLogNull called, old log sink restored } */ class WXDLLIMPEXP_BASE wxLogNull { public: wxLogNull() : m_flagOld(wxLog::EnableLogging(false)) { } ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld); } private: bool m_flagOld; // the previous value of the wxLog::ms_doLog }; // ---------------------------------------------------------------------------- // chaining log target: installs itself as a log target and passes all // messages to the real log target given to it in the ctor but also forwards // them to the previously active one // // note that you don't have to call SetActiveTarget() with this class, it // does it itself in its ctor // ---------------------------------------------------------------------------- class WXDLLIMPEXP_BASE wxLogChain : public wxLog { public: wxLogChain(wxLog *logger); virtual ~wxLogChain(); // change the new log target void SetLog(wxLog *logger); // this can be used to temporarily disable (and then reenable) passing // messages to the old logger (by default we do pass them) void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; } // are we passing the messages to the previous log target? bool IsPassingMessages() const { return m_bPassMessages; } // return the previous log target (may be NULL) wxLog *GetOldLog() const { return m_logOld; } // override base class version to flush the old logger as well virtual void Flush() wxOVERRIDE; // call to avoid destroying the old log target void DetachOldLog() { m_logOld = NULL; } protected: // pass the record to the old logger if needed virtual void DoLogRecord(wxLogLevel level, const wxString& msg, const wxLogRecordInfo& info) wxOVERRIDE; private: // the current log target wxLog *m_logNew; // the previous log target wxLog *m_logOld; // do we pass the messages to the old logger? bool m_bPassMessages; wxDECLARE_NO_COPY_CLASS(wxLogChain); }; // a chain log target which uses itself as the new logger #define wxLogPassThrough wxLogInterposer class WXDLLIMPEXP_BASE wxLogInterposer : public wxLogChain { public: wxLogInterposer(); private: wxDECLARE_NO_COPY_CLASS(wxLogInterposer); }; // a temporary interposer which doesn't destroy the old log target // (calls DetachOldLog) class WXDLLIMPEXP_BASE wxLogInterposerTemp : public wxLogChain { public: wxLogInterposerTemp(); private: wxDECLARE_NO_COPY_CLASS(wxLogInterposerTemp); }; #if wxUSE_GUI // include GUI log targets: #include "wx/generic/logg.h" #endif // wxUSE_GUI // ---------------------------------------------------------------------------- // wxLogger // ---------------------------------------------------------------------------- // wxLogger is a helper class used by wxLogXXX() functions implementation, // don't use it directly as it's experimental and subject to change (OTOH it // might become public in the future if it's deemed to be useful enough) // contains information about the context from which a log message originates // and provides Log() vararg method which forwards to wxLog::OnLog() and passes // this context to it class wxLogger { public: // ctor takes the basic information about the log record wxLogger(wxLogLevel level, const char *filename, int line, const char *func, const char *component) : m_level(level), m_info(filename, line, func, component) { } // store extra data in our log record and return this object itself (so // that further calls to its functions could be chained) template wxLogger& Store(const wxString& key, T val) { m_info.StoreValue(key, val); return *this; } // hack for "overloaded" wxLogXXX() functions: calling this method // indicates that we may have an extra first argument preceding the format // string and that if we do have it, we should store it in m_info using the // given key (while by default 0 value will be used) wxLogger& MaybeStore(const wxString& key, wxUIntPtr value = 0) { wxASSERT_MSG( m_optKey.empty(), "can only have one optional value" ); m_optKey = key; m_info.StoreValue(key, value); return *this; } // non-vararg function used by wxVLogXXX(): // log the message at the level specified in the ctor if this log message // is enabled void LogV(const wxString& format, va_list argptr) { // remember that fatal errors can't be disabled if ( m_level == wxLOG_FatalError || wxLog::IsLevelEnabled(m_level, m_info.component) ) DoCallOnLog(format, argptr); } // overloads used by functions with optional leading arguments (whose // values are stored in the key passed to MaybeStore()) void LogV(long num, const wxString& format, va_list argptr) { Store(m_optKey, num); LogV(format, argptr); } void LogV(void *ptr, const wxString& format, va_list argptr) { Store(m_optKey, wxPtrToUInt(ptr)); LogV(format, argptr); } void LogVTrace(const wxString& mask, const wxString& format, va_list argptr) { if ( !wxLog::IsAllowedTraceMask(mask) ) return; Store(wxLOG_KEY_TRACE_MASK, mask); LogV(format, argptr); } // vararg functions used by wxLogXXX(): // will log the message at the level specified in the ctor // // notice that this function supposes that the caller already checked that // the level was enabled and does no checks itself WX_DEFINE_VARARG_FUNC_VOID ( Log, 1, (const wxFormatString&), DoLog, DoLogUtf8 ) // same as Log() but with an extra numeric or pointer parameters: this is // used to pass an optional value by storing it in m_info under the name // passed to MaybeStore() and is required to support "overloaded" versions // of wxLogStatus() and wxLogSysError() WX_DEFINE_VARARG_FUNC_VOID ( Log, 2, (long, const wxFormatString&), DoLogWithNum, DoLogWithNumUtf8 ) // unfortunately we can't use "void *" here as we get overload ambiguities // with Log(wxFormatString, ...) when the first argument is a "char *" or // "wchar_t *" then -- so we only allow passing wxObject here, which is // ugly but fine in practice as this overload is only used by wxLogStatus() // whose first argument is a wxFrame WX_DEFINE_VARARG_FUNC_VOID ( Log, 2, (wxObject *, const wxFormatString&), DoLogWithPtr, DoLogWithPtrUtf8 ) // log the message at the level specified as its first argument // // as the macros don't have access to the level argument in this case, this // function does check that the level is enabled itself WX_DEFINE_VARARG_FUNC_VOID ( LogAtLevel, 2, (wxLogLevel, const wxFormatString&), DoLogAtLevel, DoLogAtLevelUtf8 ) // special versions for wxLogTrace() which is passed either string or // integer mask as first argument determining whether the message should be // logged or not WX_DEFINE_VARARG_FUNC_VOID ( LogTrace, 2, (const wxString&, const wxFormatString&), DoLogTrace, DoLogTraceUtf8 ) #if WXWIN_COMPATIBILITY_2_8 WX_DEFINE_VARARG_FUNC_VOID ( LogTrace, 2, (wxTraceMask, const wxFormatString&), DoLogTraceMask, DoLogTraceMaskUtf8 ) #endif // WXWIN_COMPATIBILITY_2_8 private: #if !wxUSE_UTF8_LOCALE_ONLY void DoLog(const wxChar *format, ...) { va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } void DoLogWithNum(long num, const wxChar *format, ...) { Store(m_optKey, num); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } void DoLogWithPtr(void *ptr, const wxChar *format, ...) { Store(m_optKey, wxPtrToUInt(ptr)); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } void DoLogAtLevel(wxLogLevel level, const wxChar *format, ...) { if ( !wxLog::IsLevelEnabled(level, m_info.component) ) return; va_list argptr; va_start(argptr, format); DoCallOnLog(level, format, argptr); va_end(argptr); } void DoLogTrace(const wxString& mask, const wxChar *format, ...) { if ( !wxLog::IsAllowedTraceMask(mask) ) return; Store(wxLOG_KEY_TRACE_MASK, mask); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } #if WXWIN_COMPATIBILITY_2_8 void DoLogTraceMask(wxTraceMask mask, const wxChar *format, ...) { if ( (wxLog::GetTraceMask() & mask) != mask ) return; Store(wxLOG_KEY_TRACE_MASK, mask); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } #endif // WXWIN_COMPATIBILITY_2_8 #endif // !wxUSE_UTF8_LOCALE_ONLY #if wxUSE_UNICODE_UTF8 void DoLogUtf8(const char *format, ...) { va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } void DoLogWithNumUtf8(long num, const char *format, ...) { Store(m_optKey, num); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } void DoLogWithPtrUtf8(void *ptr, const char *format, ...) { Store(m_optKey, wxPtrToUInt(ptr)); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } void DoLogAtLevelUtf8(wxLogLevel level, const char *format, ...) { if ( !wxLog::IsLevelEnabled(level, m_info.component) ) return; va_list argptr; va_start(argptr, format); DoCallOnLog(level, format, argptr); va_end(argptr); } void DoLogTraceUtf8(const wxString& mask, const char *format, ...) { if ( !wxLog::IsAllowedTraceMask(mask) ) return; Store(wxLOG_KEY_TRACE_MASK, mask); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } #if WXWIN_COMPATIBILITY_2_8 void DoLogTraceMaskUtf8(wxTraceMask mask, const char *format, ...) { if ( (wxLog::GetTraceMask() & mask) != mask ) return; Store(wxLOG_KEY_TRACE_MASK, mask); va_list argptr; va_start(argptr, format); DoCallOnLog(format, argptr); va_end(argptr); } #endif // WXWIN_COMPATIBILITY_2_8 #endif // wxUSE_UNICODE_UTF8 void DoCallOnLog(wxLogLevel level, const wxString& format, va_list argptr) { // As explained in wxLogRecordInfo ctor, we don't initialize its // timestamp to avoid calling time() unnecessary, but now that we are // about to log the message, we do need to do it. m_info.timestamp = time(NULL); wxLog::OnLog(level, wxString::FormatV(format, argptr), m_info); } void DoCallOnLog(const wxString& format, va_list argptr) { DoCallOnLog(m_level, format, argptr); } const wxLogLevel m_level; wxLogRecordInfo m_info; wxString m_optKey; wxDECLARE_NO_COPY_CLASS(wxLogger); }; // ============================================================================ // global functions // ============================================================================ // ---------------------------------------------------------------------------- // get error code/error message from system in a portable way // ---------------------------------------------------------------------------- // return the last system error code WXDLLIMPEXP_BASE unsigned long wxSysErrorCode(); // return the error message for given (or last if 0) error code WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0); // return the error message for given (or last if 0) error code WXDLLIMPEXP_BASE wxString wxSysErrorMsgStr(unsigned long nErrCode = 0); // ---------------------------------------------------------------------------- // define wxLog() functions which can be used by application instead of // stdio, iostream &c for log messages for easy redirection // ---------------------------------------------------------------------------- /* The code below is unreadable because it (unfortunately unavoidably) contains a lot of macro magic but all it does is to define wxLogXXX() such that you can call them as vararg functions to log a message at the corresponding level. More precisely, it defines: - wxLog{FatalError,Error,Warning,Message,Verbose,Debug}() functions taking the format string and additional vararg arguments if needed. - wxLogGeneric(wxLogLevel level, const wxString& format, ...) which takes the log level explicitly. - wxLogSysError(const wxString& format, ...) and wxLogSysError(long err, const wxString& format, ...) which log a wxLOG_Error severity message with the error message corresponding to the system error code err or the last error. - wxLogStatus(const wxString& format, ...) which logs the message into the status bar of the main application window and its overload wxLogStatus(wxFrame *frame, const wxString& format, ...) which logs it into the status bar of the specified frame. - wxLogTrace(Mask mask, const wxString& format, ...) which only logs the message is the specified mask is enabled. This comes in two kinds: Mask can be a wxString or a long. Both are deprecated. In addition, wxVLogXXX() versions of all the functions above are also defined. They take a va_list argument instead of "...". */ // creates wxLogger object for the current location #define wxMAKE_LOGGER(level) \ wxLogger(wxLOG_##level, __FILE__, __LINE__, __WXFUNCTION__, wxLOG_COMPONENT) // this macro generates the expression which logs whatever follows it in // parentheses at the level specified as argument #define wxDO_LOG(level) wxDO_LOG_WITH_FUNC(level, Log) // generalization of the macro above that uses the given function of wxLogger // object rather than the default "Log" #define wxDO_LOG_WITH_FUNC(level, func) wxMAKE_LOGGER(level).func // this is the non-vararg equivalent #define wxDO_LOGV(level, format, argptr) \ wxMAKE_LOGGER(level).LogV(format, argptr) // Macro evaluating to true if logging at the given level is enabled. #define wxLOG_IS_ENABLED(level) \ wxLog::IsLevelEnabled(wxLOG_##level, wxLOG_COMPONENT) // Macro used to define most of the actual wxLogXXX() macros: just calls // wxLogger::Log(), if logging at the specified level is enabled. #define wxDO_LOG_IF_ENABLED(level) \ wxDO_IF(wxLOG_IS_ENABLED(level)) \ wxDO_LOG(level) // Similar to above, but calls the given function instead of Log(). #define wxDO_LOG_IF_ENABLED_WITH_FUNC(level, func) \ wxDO_IF(wxLOG_IS_ENABLED(level)) \ wxDO_LOG_WITH_FUNC(level, func) // wxLogFatalError() is special as it can't be disabled #define wxLogFatalError wxDO_LOG(FatalError) #define wxVLogFatalError(format, argptr) wxDO_LOGV(FatalError, format, argptr) #define wxLogError wxDO_LOG_IF_ENABLED(Error) #define wxVLogError(format, argptr) wxDO_LOGV(Error, format, argptr) #define wxLogWarning wxDO_LOG_IF_ENABLED(Warning) #define wxVLogWarning(format, argptr) wxDO_LOGV(Warning, format, argptr) #define wxLogMessage wxDO_LOG_IF_ENABLED(Message) #define wxVLogMessage(format, argptr) wxDO_LOGV(Message, format, argptr) #define wxLogInfo wxDO_LOG_IF_ENABLED(Info) #define wxVLogInfo(format, argptr) wxDO_LOGV(Info, format, argptr) // this one is special as it only logs if we're in verbose mode #define wxLogVerbose \ wxDO_IF(wxLOG_IS_ENABLED(Info) && wxLog::GetVerbose()) \ wxDO_LOG(Info) #define wxVLogVerbose(format, argptr) \ wxDO_IF(wxLOG_IS_ENABLED(Info) && wxLog::GetVerbose()) \ wxDO_LOGV(Info, format, argptr) // another special case: the level is passed as first argument of the function // and so is not available to the macro // // notice that because of this, arguments of wxLogGeneric() are currently // always evaluated, unlike for the other log functions #define wxLogGeneric wxMAKE_LOGGER(Max).LogAtLevel #define wxVLogGeneric(level, format, argptr) \ wxDO_IF(wxLOG_IS_ENABLED(level)) \ wxDO_LOGV(level, format, argptr) // wxLogSysError() needs to stash the error code value in the log record info // so it needs special handling too; additional complications arise because the // error code may or not be present as the first argument // // notice that we unfortunately can't avoid the call to wxSysErrorCode() even // though it may be unneeded if an explicit error code is passed to us because // the message might not be logged immediately (e.g. it could be queued for // logging from the main thread later) and so we can't to wait until it is // logged to determine whether we have last error or not as it will be too late // and it will have changed already by then (in fact it even changes when // wxString::Format() is called because of vsnprintf() inside it so it can // change even much sooner) #define wxLOG_KEY_SYS_ERROR_CODE "wx.sys_error" #define wxLogSysError \ wxDO_LOG_IF_ENABLED_WITH_FUNC(Error, MaybeStore(wxLOG_KEY_SYS_ERROR_CODE, \ wxSysErrorCode()).Log) // unfortunately we can't have overloaded macros so we can't define versions // both with and without error code argument and have to rely on LogV() // overloads in wxLogger to select between them #define wxVLogSysError \ wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE, \ wxSysErrorCode()).LogV #if wxUSE_GUI // wxLogStatus() is similar to wxLogSysError() as it allows to optionally // specify the frame to which the message should go #define wxLOG_KEY_FRAME "wx.frame" #define wxLogStatus \ wxDO_LOG_IF_ENABLED_WITH_FUNC(Status, MaybeStore(wxLOG_KEY_FRAME).Log) #define wxVLogStatus \ wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).LogV #endif // wxUSE_GUI #else // !wxUSE_LOG #undef wxUSE_LOG_DEBUG #define wxUSE_LOG_DEBUG 0 #undef wxUSE_LOG_TRACE #define wxUSE_LOG_TRACE 0 // define macros for defining log functions which do nothing at all #define wxDEFINE_EMPTY_LOG_FUNCTION(level) \ WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxFormatString&)) \ inline void wxVLog##level(const wxFormatString& WXUNUSED(format), \ va_list WXUNUSED(argptr)) { } \ #define wxDEFINE_EMPTY_LOG_FUNCTION2(level, argclass) \ WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxFormatString&)) \ inline void wxVLog##level(argclass WXUNUSED(arg), \ const wxFormatString& WXUNUSED(format), \ va_list WXUNUSED(argptr)) {} wxDEFINE_EMPTY_LOG_FUNCTION(FatalError); wxDEFINE_EMPTY_LOG_FUNCTION(Error); wxDEFINE_EMPTY_LOG_FUNCTION(SysError); wxDEFINE_EMPTY_LOG_FUNCTION2(SysError, long); wxDEFINE_EMPTY_LOG_FUNCTION(Warning); wxDEFINE_EMPTY_LOG_FUNCTION(Message); wxDEFINE_EMPTY_LOG_FUNCTION(Info); wxDEFINE_EMPTY_LOG_FUNCTION(Verbose); wxDEFINE_EMPTY_LOG_FUNCTION2(Generic, wxLogLevel); #if wxUSE_GUI wxDEFINE_EMPTY_LOG_FUNCTION(Status); wxDEFINE_EMPTY_LOG_FUNCTION2(Status, wxFrame *); #endif // wxUSE_GUI // Empty Class to fake wxLogNull class WXDLLIMPEXP_BASE wxLogNull { public: wxLogNull() { } }; // Dummy macros to replace some functions. #define wxSysErrorCode() (unsigned long)0 #define wxSysErrorMsg( X ) (const wxChar*)NULL #define wxSysErrorMsgStr( X ) wxEmptyString // Fake symbolic trace masks... for those that are used frequently #define wxTRACE_OleCalls wxEmptyString // OLE interface calls #endif // wxUSE_LOG/!wxUSE_LOG // debug functions can be completely disabled in optimized builds // if these log functions are disabled, we prefer to define them as (empty) // variadic macros as this completely removes them and their argument // evaluation from the object code but if this is not supported by compiler we // use empty inline functions instead (defining them as nothing would result in // compiler warnings) // // note that making wxVLogDebug/Trace() themselves (empty inline) functions is // a bad idea as some compilers are stupid enough to not inline even empty // functions if their parameters are complicated enough, but by defining them // as an empty inline function we ensure that even dumbest compilers optimise // them away #ifdef __BORLANDC__ // but Borland gives "W8019: Code has no effect" for wxLogNop() so we need // to define it differently for it to avoid these warnings (same problem as // with wxUnusedVar()) #define wxLogNop() { } #else inline void wxLogNop() { } #endif #if wxUSE_LOG_DEBUG #define wxLogDebug wxDO_LOG_IF_ENABLED(Debug) #define wxVLogDebug(format, argptr) wxDO_LOGV(Debug, format, argptr) #else // !wxUSE_LOG_DEBUG #define wxVLogDebug(fmt, valist) wxLogNop() #ifdef HAVE_VARIADIC_MACROS #define wxLogDebug(fmt, ...) wxLogNop() #else // !HAVE_VARIADIC_MACROS WX_DEFINE_VARARG_FUNC_NOP(wxLogDebug, 1, (const wxFormatString&)) #endif #endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG #if wxUSE_LOG_TRACE #define wxLogTrace wxDO_LOG_IF_ENABLED_WITH_FUNC(Trace, LogTrace) #define wxVLogTrace wxDO_LOG_IF_ENABLED_WITH_FUNC(Trace, LogVTrace) #else // !wxUSE_LOG_TRACE #define wxVLogTrace(mask, fmt, valist) wxLogNop() #ifdef HAVE_VARIADIC_MACROS #define wxLogTrace(mask, fmt, ...) wxLogNop() #else // !HAVE_VARIADIC_MACROS #if WXWIN_COMPATIBILITY_2_8 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (wxTraceMask, const wxFormatString&)) #endif WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wxString&, const wxFormatString&)) #endif // HAVE_VARIADIC_MACROS/!HAVE_VARIADIC_MACROS #endif // wxUSE_LOG_TRACE/!wxUSE_LOG_TRACE // wxLogFatalError helper: show the (fatal) error to the user in a safe way, // i.e. without using wxMessageBox() for example because it could crash void WXDLLIMPEXP_BASE wxSafeShowMessage(const wxString& title, const wxString& text); // ---------------------------------------------------------------------------- // debug only logging functions: use them with API name and error code // ---------------------------------------------------------------------------- #if wxUSE_LOG_DEBUG // make life easier for people using VC++ IDE: clicking on the message // will take us immediately to the place of the failed API #ifdef __VISUALC__ #define wxLogApiError(api, rc) \ wxLogDebug(wxT("%s(%d): '%s' failed with error 0x%08lx (%s)."), \ __FILE__, __LINE__, api, \ (long)rc, wxSysErrorMsgStr(rc)) #else // !VC++ #define wxLogApiError(api, rc) \ wxLogDebug(wxT("In file %s at line %d: '%s' failed with ") \ wxT("error 0x%08lx (%s)."), \ __FILE__, __LINE__, api, \ (long)rc, wxSysErrorMsgStr(rc)) #endif // VC++/!VC++ #define wxLogLastError(api) wxLogApiError(api, wxSysErrorCode()) #else // !wxUSE_LOG_DEBUG #define wxLogApiError(api, err) wxLogNop() #define wxLogLastError(api) wxLogNop() #endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG // macro which disables debug logging in release builds: this is done by // default by wxIMPLEMENT_APP() so usually it doesn't need to be used explicitly #if defined(NDEBUG) && wxUSE_LOG_DEBUG #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() \ wxLog::SetLogLevel(wxLOG_Info) #else // !NDEBUG #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() #endif // NDEBUG/!NDEBUG #endif // _WX_LOG_H_