269 lines
7.1 KiB
C++
269 lines
7.1 KiB
C++
//
|
|
// The developer of the original code and/or files is Tripwire, Inc.
|
|
// Portions created by Tripwire, Inc. are copyright (C) 2000-2018 Tripwire,
|
|
// Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights
|
|
// reserved.
|
|
//
|
|
// This program is free software. The contents of this file are subject
|
|
// to the terms of the GNU General Public License as published by the
|
|
// Free Software Foundation; either version 2 of the License, or (at your
|
|
// option) any later version. You may redistribute it and/or modify it
|
|
// only in compliance with the GNU General Public License.
|
|
//
|
|
// This program is distributed in the hope that it will be useful.
|
|
// However, this program is distributed AS-IS WITHOUT ANY
|
|
// WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS
|
|
// FOR A PARTICULAR PURPOSE. Please see the GNU General Public License
|
|
// for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
// USA.
|
|
//
|
|
// Nothing in the GNU General Public License or any other license to use
|
|
// the code or files shall permit you to use Tripwire's trademarks,
|
|
// service marks, or other intellectual property without Tripwire's
|
|
// prior written consent.
|
|
//
|
|
// If you have any questions, please contact Tripwire, Inc. at either
|
|
// info@tripwire.org or www.tripwire.org.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// debug.h
|
|
//
|
|
// definitions of debug macros that will vary across platforms
|
|
|
|
#ifndef __DEBUG_H
|
|
#define __DEBUG_H
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
#include <iostream>
|
|
/* Do it in this order, because autoconf checks for <stdarg.h>
|
|
* first i.e. if HAVE_VARARGS_H is defined, it is only because
|
|
* <stdarg.h> couldn't be found.
|
|
*/
|
|
#ifdef HAVE_VARARGS_H
|
|
#include <varargs.h>
|
|
#else
|
|
# ifdef HAVE_STDARG_H
|
|
# include <stdarg.h>
|
|
# endif
|
|
#endif
|
|
#include "types.h"
|
|
|
|
//
|
|
// NOTE:
|
|
// When compiling with MFC, these are already defined and we get error msgs
|
|
// every time this file is included. Since these behave the same as the MFC
|
|
// version, it is OK to always undef them here....
|
|
// -- 20 Aug 99 mdb
|
|
//
|
|
#undef ASSERT
|
|
#undef TRACE
|
|
|
|
//
|
|
// IMPORTANT:
|
|
//
|
|
// strings outputted as trace statements are printed as narrow characters.
|
|
// passing trace messages with wide characters will have odd results, since
|
|
// they will be used as arugments to sprintf(), etc...
|
|
//
|
|
|
|
// debug utility class
|
|
class cDebug
|
|
{
|
|
public:
|
|
enum OutTarget
|
|
{
|
|
OUT_STDOUT = 1,
|
|
OUT_TRACE = 2,
|
|
OUT_FILE = 4
|
|
};
|
|
|
|
enum DebugLevel
|
|
{
|
|
D_ALWAYS = 0,
|
|
D_ERROR = 1,
|
|
D_WARNING = 4,
|
|
D_DEBUG = 8,
|
|
D_DETAIL = 16,
|
|
D_NEVER = 1000
|
|
};
|
|
|
|
cDebug(const char* pLabel);
|
|
~cDebug();
|
|
cDebug(const cDebug& rhs);
|
|
|
|
// These are the preferred tracing interfaces, because you don't need to know
|
|
// the DebugLevel enums.
|
|
// Wide/Narrow Chars Issues: If you include a %s in your format string and you
|
|
// wish to print out a TCHAR (which might be a natural thing to do) you should
|
|
// encompas the format string with a _T("") macro, i.e. make it a TSTRING.
|
|
// The wide character overloads of these functions will expect wide strings
|
|
// for %s options.
|
|
//
|
|
void TraceAlways(const char* format, ...);
|
|
void TraceError(const char* format, ...);
|
|
void TraceWarning(const char* format, ...);
|
|
void TraceDebug(const char* format, ...);
|
|
void TraceDetail(const char* format, ...);
|
|
void TraceNever(const char* format, ...);
|
|
|
|
|
|
// these are of use if you are inside a function with a "..." as an argument
|
|
// and you want to trace those args
|
|
void TraceVaArgs(int iDebugLevel, const char* format, va_list& args);
|
|
|
|
// ...but you can still choose to use this interface...
|
|
|
|
void Trace(int levelNum, const char* format, ...);
|
|
// Outputs based on levelnum. If levelnum <= global debug, print.
|
|
|
|
public:
|
|
static bool AddOutTarget(OutTarget target);
|
|
static bool RemoveOutTarget(OutTarget target);
|
|
// used to specify the out target....
|
|
static bool HasOutTarget(OutTarget target);
|
|
|
|
static bool SetOutputFile(const char* filename);
|
|
// specifies the output file name used when OUT_FILE is set
|
|
static void SetDebugLevel(int level);
|
|
static int GetDebugLevel(void);
|
|
// gets and sets the global debug level. Trace output at or below this
|
|
// level will be output.
|
|
|
|
static void DebugOut(const char* lpOutputString, ...);
|
|
// Works just like TRACE
|
|
// note: there is an internal buffer size of 1024; traces larger
|
|
// than that will have unpredictable and probably bad results
|
|
private:
|
|
#ifdef DEBUG
|
|
enum
|
|
{
|
|
MAX_LABEL = 128
|
|
};
|
|
|
|
static int mDebugLevel;
|
|
static uint32 mOutMask;
|
|
static std::ofstream logfile;
|
|
char mLabel[MAX_LABEL];
|
|
|
|
// helper functions
|
|
void DoTrace(const char* format, va_list& args);
|
|
#endif
|
|
};
|
|
|
|
#ifdef DEBUG
|
|
# define TRACE cDebug::DebugOut
|
|
#else
|
|
# define TRACE 1 ? (void)0 : cDebug::DebugOut
|
|
#endif // DEBUG
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
// inline implementation
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
// Hopefully this class should do nothing in release mode
|
|
|
|
#ifdef DEBUG
|
|
|
|
inline void cDebug::SetDebugLevel(int level)
|
|
{
|
|
mDebugLevel = level;
|
|
}
|
|
|
|
inline int cDebug::GetDebugLevel()
|
|
{
|
|
return mDebugLevel;
|
|
}
|
|
|
|
# else // DEBUG
|
|
|
|
inline cDebug::cDebug(const char*)
|
|
{
|
|
}
|
|
inline cDebug::~cDebug()
|
|
{
|
|
}
|
|
inline cDebug::cDebug(const cDebug&)
|
|
{
|
|
}
|
|
inline void cDebug::TraceAlways(const char*, ...)
|
|
{
|
|
}
|
|
inline void cDebug::TraceError(const char*, ...)
|
|
{
|
|
}
|
|
inline void cDebug::TraceWarning(const char*, ...)
|
|
{
|
|
}
|
|
inline void cDebug::TraceDebug(const char*, ...)
|
|
{
|
|
}
|
|
inline void cDebug::TraceDetail(const char*, ...)
|
|
{
|
|
}
|
|
inline void cDebug::TraceNever(const char*, ...)
|
|
{
|
|
}
|
|
inline void cDebug::TraceVaArgs(int, const char*, va_list&)
|
|
{
|
|
}
|
|
inline void cDebug::Trace(int, const char*, ...)
|
|
{
|
|
}
|
|
inline bool cDebug::AddOutTarget(OutTarget)
|
|
{
|
|
return false;
|
|
}
|
|
inline bool cDebug::RemoveOutTarget(OutTarget)
|
|
{
|
|
return false;
|
|
}
|
|
inline bool cDebug::HasOutTarget(OutTarget)
|
|
{
|
|
return false;
|
|
}
|
|
inline bool cDebug::SetOutputFile(const char*)
|
|
{
|
|
return false;
|
|
}
|
|
inline void cDebug::SetDebugLevel(int)
|
|
{
|
|
}
|
|
inline int cDebug::GetDebugLevel(void)
|
|
{
|
|
return 0;
|
|
}
|
|
inline void cDebug::DebugOut(const char*, ...)
|
|
{
|
|
}
|
|
|
|
# endif // DEBUG
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
// ASSERT macro
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
# define ASSERTMSG(exp, s) assert((exp) != 0)
|
|
# define ASSERT(exp) assert((exp) != 0)
|
|
// if we are not windows we will just use the standard assert()
|
|
# define TSS_DebugBreak() ASSERT(false);
|
|
|
|
# ifndef ASSERT
|
|
# error ASSERT did not get defined!!!
|
|
# endif
|
|
|
|
# ifndef ASSERTMSG
|
|
# error ASSERTMSG did not get defined!!!
|
|
# endif
|
|
|
|
# ifndef TSS_DebugBreak
|
|
# error TSS_DebugBreak did not get defined!!!
|
|
# endif
|
|
|
|
#endif //__DEBUG_H
|