WindowsXP-SP1/admin/admt/profext/mcsdebug.h

410 lines
11 KiB
C
Raw Permalink Normal View History

2001-01-01 00:00:00 +01:00
//---------------------------------------------------------------------------
// MCSDebug.h
//
// The debug macros and support classes are declared in
// this file, they are:
//
// MCSASSERT & MCSASSERTSZ:
// These macros are only valid for a debug build. The
// usage of these macros is outlined in the MCS Coding
// Standards document. To support automated testing these
// macros look to the environment variable MCS_TEST, if
// this variable is defined a McsDebugException is generated.
//
// MCSEXCEPTION & MCSEXCEPTIONSZ
// These macros are valid for debug and release builds.
// In the debug mode these macros are the same as
// MCSASSERT(SZ). In the release mode they throw an
// exception McsException The usage of these macros is
// outlined in the MCS Coding Standards document.
//
// MCSVERIFY & MCSVERIFYSZ
// These macros are valid for debug and release builds.
// In the debug mode these macros are the same as
// MCSASSERT(SZ). In the release mode they log the
// message using McsVerifyLog class. The usage of these
// macros is outlined in the MCS Coding Standards document.
//
// MCSASSERTVALID
// This macro is based on MCSASSERT(SZ) macros, and is
// available only in debug mode. The usage of this macro
// is outlined in the MCS Coding Standards document.
// IMPORTANT: The macro expects the string allocation done
// in the Validate function uses new operator.
//
// MCSEXCEPTIONVALID
// This macro is based on MCSEXCEPTION(SZ) macros, and is
// available in debug and release modes. The usage of this
// macro is outlined in the MCS Coding Standards document.
// IMPORTANT: The macro expects the string allocation done
// in the Validate function uses new operator.
//
// MCSVERIFYVALID
// This macro is based on MCSVERIFY(SZ) macros, and is
// available debug and release modes. The usage of this
// macro is outlined in the MCS Coding Standards document.
// IMPORTANT: The macro expects the string allocation done
// in the Validate function uses new operator.
//
// McsVerifyLog:
// The McsVerifyLog class is used by MCSVERIFY(SZ) macros
// to log verify messages. This class uses the McsDebugLog
// class to log messages. The user can change the ostream
// object to log messages else where.
// The output log file is created in the directory
// defined by MCS_LOG environment variable, or in the
// TEMP directory, or in the current directory. The name
// of the output log file is <module name>.err.
//
// McsTestLog:
// The McsTestLog class is used by MCSASSERT(SZ) macros
// to log messages in test mode. This class currently
// generates an exception. This may have to be modified
// to support any new functionality required for unit
// testing.
//
// (c) Copyright 1995-1998, Mission Critical Software, Inc., All Rights Reserved
//
// Proprietary and confidential to Mission Critical Software, Inc.
//---------------------------------------------------------------------------
#ifndef MCSINC_McsDebug_h
#define MCSINC_McsDebug_h
#ifdef __cplusplus /* C++ */
#ifdef WIN16_VERSION /* WIN16_VERSION */
#include <assert.h>
// -------------------------------
// MCSASSERT & MCSASSERTSZ macros.
// -------------------------------
#define MCSASSERT(expr) assert(expr)
#define MCSASSERTSZ(expr,msg) assert(expr)
// -----------------------------
// MCSEXCEPTION & MCSEXCEPTIONSZ
// -----------------------------
#define MCSEXCEPTION(expr) MCSASSERT(expr)
#define MCSEXCEPTIONSZ(expr,msg) MCSASSERTSZ(expr,msg)
// -----------------------
// MCSVERIFY & MCSVERIFYSZ
// -----------------------
#define MCSVERIFY(expr) MCSASSERT(expr)
#define MCSVERIFYSZ(expr,msg) MCSASSERTSZ(expr,msg)
// --------------
// MCSASSERTVALID
// --------------
#define MCSASSERTVALID() \
do { \
char *msg = 0; \
int flag = Validate(&msg); \
MCSASSERTSZ(flag, msg); \
delete [] msg; \
} while (0)
// -----------------
// MCSEXCEPTIONVALID
// -----------------
#define MCSEXCEPTIONVALID() \
do { \
char *msg = 0; \
int flag = Validate(&msg); \
MCSEXCEPTIONSZ(flag, msg); \
delete [] msg; \
} while (0)
// --------------
// MCSVERIFYVALID
// --------------
#define MCSVERIFYVALID() \
do { \
char *msg = 0; \
int flag = Validate(&msg); \
MCSVERIFYSZ(flag, msg); \
delete [] msg; \
} while (0)
#else /* WIN16_VERSION */
#include <crtdbg.h>
#include "McsDbgU.h"
// ------------
// McsException
// ------------
class McsDebugException {
public:
McsDebugException ();
McsDebugException (const McsDebugException &sourceIn);
McsDebugException (const char *messageIn,
const char *fileNameIn,
int lineNumIn);
~McsDebugException();
McsDebugException& operator= (const McsDebugException &rhsIn);
const char *getMessage (void) const;
const char *getFileName (void) const;
getLineNum (void) const;
private:
char *m_message;
char *m_fileName;
int m_lineNum;
};
// ------------
// McsVerifyLog
// ------------
class McsVerifyLog {
public:
// No public ctors only way to access
// an object of this class by using the
// getLog function. This required for
// the correct static initializations.
static McsVerifyLog* getLog (void);
~McsVerifyLog (void);
void changeLog (ostream *outStreamIn);
void log (const char *messageIn,
const char *fileNameIn,
int lineNumIn);
private:
McsVerifyLog (void);
const char* getLogFileName (void);
void formatMsg (const char *messageIn,
const char *fileNameIn,
int lineNumIn);
// Do not allow dflt ctor, copy ctor & operator=.
McsVerifyLog (const McsVerifyLog&);
McsVerifyLog& operator= (const McsVerifyLog&);
private:
enum { MSG_BUF_LEN = 2048 };
char m_msgBuf[MSG_BUF_LEN];
McsDebugUtil::McsDebugCritSec m_logSec;
McsDebugUtil::McsDebugLog m_log;
fstream *m_outLog;
};
// ----------
// McsTestLog
// ----------
class McsTestLog {
public:
// No public ctors only way to access
// an object of this class by using the
// getLog function. This required for
// the correct static initializations.
static McsTestLog* getLog (void);
~McsTestLog (void);
bool isTestMode (void);
void log (const char *messageIn,
const char *fileNameIn,
int lineNumIn);
private:
McsTestLog (void);
// Do not allow copy ctor & operator=.
McsTestLog (const McsTestLog&);
McsTestLog& operator= (const McsTestLog&);
private:
bool m_isTested;
bool m_isTestMode_;
McsDebugUtil::McsDebugCritSec m_testSec;
};
// -------------------------------
// MCSASSERT & MCSASSERTSZ macros.
// -------------------------------
#ifdef _DEBUG
#define MCSASSERT(expr) \
do { \
if (!(expr)) { \
if (McsTestLog::getLog()->isTestMode()) { \
McsTestLog::getLog()->log (#expr, __FILE__, __LINE__); \
} else { \
if (1 == _CrtDbgReport(_CRT_ASSERT, __FILE__, __LINE__, NULL, #expr)) { \
_CrtDbgBreak(); \
} \
} \
} \
} while (0)
#else // _DEBUG
#define MCSASSERT(expr) ((void)0)
#endif // _DEBUG
#ifdef _DEBUG
#define MCSASSERTSZ(expr,msg) \
do { \
if (!(expr)) { \
if (McsTestLog::getLog()->isTestMode()) { \
McsTestLog::getLog()->log (msg, __FILE__, __LINE__); \
} else { \
if (1 == _CrtDbgReport(_CRT_ASSERT, __FILE__, \
__LINE__, NULL, msg)) { \
_CrtDbgBreak(); \
} \
} \
} \
} while (0)
#else // _DEBUG
#define MCSASSERTSZ(expr,msg) ((void)0)
#endif // _DEBUG
// -----------------------------
// MCSEXCEPTION & MCSEXCEPTIONSZ
// -----------------------------
#ifdef _DEBUG
#define MCSEXCEPTION(expr) MCSASSERT(expr)
#else
#define MCSEXCEPTION(expr) \
do { \
if (!(expr)) { \
throw new McsDebugException (#expr, __FILE__, \
__LINE__); \
} \
} while (0)
#endif
#ifdef _DEBUG
#define MCSEXCEPTIONSZ(expr,msg) MCSASSERTSZ(expr,msg)
#else
#define MCSEXCEPTIONSZ(expr,msg) \
do { \
if (!(expr)) { \
throw new McsDebugException ((msg), __FILE__, \
__LINE__); \
} \
} while (0)
#endif
// -----------------------
// MCSVERIFY & MCSVERIFYSZ
// -----------------------
#ifdef _DEBUG
#define MCSVERIFY(expr) MCSASSERT(expr)
#else
#define MCSVERIFY(expr) \
do { \
if (!(expr)) { \
McsVerifyLog::getLog()->log (#expr, __FILE__, __LINE__); \
} \
} while (0)
#endif
#ifdef _DEBUG
#define MCSVERIFYSZ(expr,msg) MCSASSERTSZ(expr,msg)
#else
#define MCSVERIFYSZ(expr,msg) \
do { \
if (!(expr)) { \
McsVerifyLog::getLog()->log ((msg), __FILE__, \
__LINE__); \
} \
} while (0)
#endif
// --------------
// MCSASSERTVALID
// --------------
#define MCSASSERTVALID() \
do { \
char *msg = NULL; \
int flag = Validate(&msg); \
MCSASSERTSZ(flag, msg); \
delete [] msg; \
} while (0)
// -----------------
// MCSEXCEPTIONVALID
// -----------------
#define MCSEXCEPTIONVALID() \
do { \
char *msg = NULL; \
int flag = Validate(&msg); \
MCSEXCEPTIONSZ(flag, msg); \
delete [] msg; \
} while (0)
// --------------
// MCSVERIFYVALID
// --------------
#define MCSVERIFYVALID() \
do { \
char *msg = NULL; \
int flag = Validate(&msg); \
MCSVERIFYSZ(flag, msg); \
delete [] msg; \
} while (0)
// ---------------
// --- INLINES ---
// ---------------
// -----------------
// McsDebugException
// -----------------
inline McsDebugException::McsDebugException ()
: m_message (0), m_fileName (0), m_lineNum (0)
{ /* EMPTY */ }
inline McsDebugException::~McsDebugException() {
delete [] m_message;
delete [] m_fileName;
}
inline const char *McsDebugException::getMessage
(void) const {
return m_message;
}
inline const char *McsDebugException::getFileName
(void) const {
return m_fileName;
}
inline int McsDebugException::getLineNum
(void) const {
return m_lineNum;
}
// ------------
// McsVerifyLog
// ------------
inline McsVerifyLog::McsVerifyLog (void)
{ /* EMPTY */ }
inline McsVerifyLog::~McsVerifyLog (void) {
delete m_outLog;
}
// ----------
// McsTestLog
// ----------
inline McsTestLog::McsTestLog (void)
: m_isTested (FALSE), m_isTestMode_ (FALSE)
{ /* EMPTY */ }
inline McsTestLog::~McsTestLog (void) { /* EMPTY */ }
inline void McsTestLog::log (const char *messageIn,
const char *fileNameIn,
int lineNumIn) {
throw new McsDebugException (messageIn, fileNameIn,
lineNumIn);
}
#endif /* WIN16_VERSION */
#endif /* C++ */
#endif /* MCSINC_McsDebug_h */