216 lines
6.7 KiB
C++
216 lines
6.7 KiB
C++
/*
|
|
* synergy -- mouse and keyboard sharing utility
|
|
* Copyright (C) 2002 Chris Schoeneman
|
|
*
|
|
* This package is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* found in the file COPYING that should have accompanied this file.
|
|
*
|
|
* This package is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#ifndef CLOG_H
|
|
#define CLOG_H
|
|
|
|
#include "common.h"
|
|
#include <stdarg.h>
|
|
|
|
//! Logging facility
|
|
/*!
|
|
The logging class; all console output should go through this class.
|
|
It supports multithread safe operation, several message priority levels,
|
|
filtering by priority, and output redirection. The macros log() and
|
|
clog() provide convenient access.
|
|
*/
|
|
class CLog {
|
|
public:
|
|
//! Log levels
|
|
/*!
|
|
The logging priority levels in order of highest to lowest priority.
|
|
*/
|
|
enum ELevel {
|
|
kFATAL, //!< For fatal errors
|
|
kERROR, //!< For serious errors
|
|
kWARNING, //!< For minor errors and warnings
|
|
kNOTE, //!< For messages about notable events
|
|
kINFO, //!< For informational messages
|
|
kDEBUG, //!< For important debugging messages
|
|
kDEBUG1, //!< For more detailed debugging messages
|
|
kDEBUG2 //!< For even more detailed debugging messages
|
|
};
|
|
|
|
//! Outputter function.
|
|
/*!
|
|
Type of outputter function. The outputter should write \c message,
|
|
which has the given \c priority, to a log and return true. Or it can
|
|
return false to let CLog use the default outputter.
|
|
*/
|
|
typedef bool (*Outputter)(int priority, const char* message);
|
|
|
|
//! Locking function
|
|
/*!
|
|
Type of lock/unlock function. If \c lock is true then block other
|
|
threads that try to lock until this thread unlocks. If \c lock is
|
|
false then unlock and allow another (waiting) thread to lock.
|
|
*/
|
|
typedef void (*Lock)(bool lock);
|
|
|
|
//! @name manipulators
|
|
//@{
|
|
|
|
//! Set the function used to write the log
|
|
/*!
|
|
Sets the function used to write to the log. The outputter function
|
|
is called with the formatted string to write and the priority level.
|
|
CLog will have already filtered messages below the current filter
|
|
priority. A NULL outputter means to use the default which is to print
|
|
to stderr. Note that the outputter should not call CLog methods but,
|
|
if it does, the current lock function must permit recursive locks.
|
|
*/
|
|
static void setOutputter(Outputter);
|
|
|
|
//! Set the lock/unlock function
|
|
/*!
|
|
Set the lock/unlock function. Use setLock(NULL) to remove the
|
|
locking function. There is no default lock function; do not call
|
|
CLog from multiple threads unless a working lock function has been
|
|
installed.
|
|
*/
|
|
static void setLock(Lock);
|
|
|
|
//! Set the minimum priority filter.
|
|
/*!
|
|
Set the filter. Messages below this priority are discarded.
|
|
The default priority is 4 (INFO) (unless built without NDEBUG
|
|
in which case it's 5 (DEBUG)). The default can be overridden
|
|
by setting the SYN_LOG_PRI env var to "FATAL", "ERROR", etc.
|
|
setFilter(const char*) returns true if the priority \c name was
|
|
recognized; if \c name is NULL then it simply returns true.
|
|
*/
|
|
static bool setFilter(const char* name);
|
|
static void setFilter(int);
|
|
|
|
//@}
|
|
//! @name accessors
|
|
//@{
|
|
|
|
//! Print a log message
|
|
/*!
|
|
Print a log message using the printf-like \c format and arguments.
|
|
*/
|
|
static void print(const char* format, ...);
|
|
|
|
//! Print a log message
|
|
/*!
|
|
Print a log message using the printf-like \c format and arguments
|
|
preceded by the filename and line number.
|
|
*/
|
|
static void printt(const char* file, int line,
|
|
const char* format, ...);
|
|
|
|
//! Get the function used to write the log
|
|
static Outputter getOutputter();
|
|
|
|
//! Get the lock/unlock function
|
|
/*!
|
|
Get the lock/unlock function. Note that the lock function is
|
|
used when retrieving the lock function.
|
|
*/
|
|
static Lock getLock();
|
|
|
|
//! Get the minimum priority level.
|
|
static int getFilter();
|
|
|
|
//@}
|
|
|
|
private:
|
|
class CHoldLock {
|
|
public:
|
|
CHoldLock(Lock lock) : m_lock(lock) { m_lock(true); }
|
|
~CHoldLock() { m_lock(false); }
|
|
|
|
private:
|
|
Lock m_lock;
|
|
};
|
|
|
|
static void dummyLock(bool);
|
|
static int getMaxPriority();
|
|
static void output(int priority, char* msg);
|
|
#if WINDOWS_LIKE
|
|
static void openConsole();
|
|
#endif
|
|
|
|
private:
|
|
static Outputter s_outputter;
|
|
static Lock s_lock;
|
|
static int s_maxPriority;
|
|
};
|
|
|
|
/*!
|
|
\def log(arg)
|
|
Write to the log. Because macros cannot accept variable arguments, this
|
|
should be invoked like so:
|
|
\code
|
|
log((CLOG_XXX "%d and %d are %s", x, y, x == y ? "equal" : "not equal"));
|
|
\endcode
|
|
In particular, notice the double open and close parentheses. Also note
|
|
that there is no comma after the \c CLOG_XXX. The \c XXX should be
|
|
replaced by one of enumerants in \c CLog::ELevel without the leading
|
|
\c k. For example, \c CLOG_INFO. The special \c CLOG_PRINT level will
|
|
not be filtered and is never prefixed by the filename and line number.
|
|
|
|
If \c NOLOGGING is defined during the build then this macro expands to
|
|
nothing. If \c NDEBUG is defined during the build then it expands to a
|
|
call to CLog::print. Otherwise it expands to a call to CLog::printt,
|
|
which includes the filename and line number.
|
|
*/
|
|
|
|
/*!
|
|
\def logc(expr, arg)
|
|
Write to the log if and only if expr is true. Because macros cannot accept
|
|
variable arguments, this should be invoked like so:
|
|
\code
|
|
clog(x == y, (CLOG_XXX "%d and %d are equal", x, y));
|
|
\endcode
|
|
In particular, notice the parentheses around everything after the boolean
|
|
expression. Also note that there is no comma after the \c CLOG_XXX.
|
|
The \c XXX should be replaced by one of enumerants in \c CLog::ELevel
|
|
without the leading \c k. For example, \c CLOG_INFO. The special
|
|
\c CLOG_PRINT level will not be filtered and is never prefixed by the
|
|
filename and line number.
|
|
|
|
If \c NOLOGGING is defined during the build then this macro expands to
|
|
nothing. If \c NDEBUG is defined during the build then it expands to a
|
|
call to CLog::print. Otherwise it expands to a call to CLog::printt,
|
|
which includes the filename and line number.
|
|
*/
|
|
|
|
#if defined(NOLOGGING)
|
|
#define log(_a1)
|
|
#define logc(_a1, _a2)
|
|
#define CLOG_TRACE
|
|
#elif defined(NDEBUG)
|
|
#define log(_a1) CLog::print _a1
|
|
#define logc(_a1, _a2) if (_a1) CLog::print _a2
|
|
#define CLOG_TRACE
|
|
#else
|
|
#define log(_a1) CLog::printt _a1
|
|
#define logc(_a1, _a2) if (_a1) CLog::printt _a2
|
|
#define CLOG_TRACE __FILE__, __LINE__,
|
|
#endif
|
|
|
|
#define CLOG_PRINT CLOG_TRACE "%z\057"
|
|
#define CLOG_CRIT CLOG_TRACE "%z\060"
|
|
#define CLOG_ERR CLOG_TRACE "%z\061"
|
|
#define CLOG_WARN CLOG_TRACE "%z\062"
|
|
#define CLOG_NOTE CLOG_TRACE "%z\063"
|
|
#define CLOG_INFO CLOG_TRACE "%z\064"
|
|
#define CLOG_DEBUG CLOG_TRACE "%z\065"
|
|
#define CLOG_DEBUG1 CLOG_TRACE "%z\066"
|
|
#define CLOG_DEBUG2 CLOG_TRACE "%z\067"
|
|
|
|
#endif
|