354 lines
9.5 KiB
C++
354 lines
9.5 KiB
C++
/* UCMS_VERSION_ID("@(#)pcpdbg.h 61EX:6 readonly 17/05/95 12:59(#)@") */
|
|
#ifndef PCPDBG_H
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* $Workfile:: PCPDBG.H $
|
|
*
|
|
* $Logfile:: $
|
|
*
|
|
* Library:: CLASSLIB.LIB
|
|
*
|
|
* Makefile:: MAKEFILE
|
|
*
|
|
* $Date:: $
|
|
*
|
|
* $Revision:: 0.00 $
|
|
*
|
|
* $Author:: Klaas van Ditzhuyzen $
|
|
*
|
|
* Functions::
|
|
*
|
|
* $Log:: $
|
|
*
|
|
* NOTES: DEBUG_PRINTF should be defined as a standard printf routine
|
|
* to a debug port or file.
|
|
* DEBUG_ON() is a macro which returns the debug level. When
|
|
* zero, all runtime debugging is turned off.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
/*****************************************************************************
|
|
* Definitions
|
|
*****************************************************************************/
|
|
#ifndef EXTERN_C
|
|
/* Allow usage of C++ compiler */
|
|
#ifdef __cplusplus /* Move this to "software.h" */
|
|
#define EXTERN_C extern "C"
|
|
#define EXTERN_C_BEGIN EXTERN_C {
|
|
#define EXTERN_C_END }
|
|
#else
|
|
#define EXTERN_C
|
|
#define EXTERN_C_BEGIN
|
|
#define EXTERN_C_END
|
|
#endif /* C++ */
|
|
#endif /* EXTERN_C */
|
|
|
|
#ifndef NULL
|
|
#define NULL ((void*) 0)
|
|
#endif
|
|
|
|
#if DEBUG
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma message("DEBUG SHIT ENABLED")
|
|
#endif
|
|
|
|
#ifndef DEBUG_PRINTF_FUNCDEF
|
|
|
|
#define DEBUG_PRINTF_FUNCDEF(file) \
|
|
EXTERN_C int DEBUG_PRINTF(const char *s, ...) \
|
|
{ \
|
|
va_list array; \
|
|
char *p = file; \
|
|
int i; \
|
|
static FILE * fp; \
|
|
va_start(array,s); \
|
|
if (!fp) \
|
|
{ \
|
|
if (!file) \
|
|
{ \
|
|
char fbuf[100]; \
|
|
strcpy(fbuf, __FILE__); \
|
|
p = strchr(fbuf, '.'); \
|
|
strcpy(p, ".log"); \
|
|
p = fbuf; \
|
|
} \
|
|
fp = fopen(p, "w"); \
|
|
} \
|
|
i = vfprintf(fp, s, array); \
|
|
fflush(fp); \
|
|
return i; \
|
|
}
|
|
|
|
#endif
|
|
|
|
EXTERN_C void DEBUG_DUMPDATA(const char *name, const void *ptr, int nbytes, int flags);
|
|
|
|
/*
|
|
* Log current value of STACK in hex (consumes two words of stack space !).
|
|
*/
|
|
#ifndef DEBUG_LOGSTACK
|
|
#define DEBUG_LOGSTACK() { int _stack, *STACK=&_stack; dsx(STACK); }
|
|
#endif
|
|
|
|
/*
|
|
* Makes always an acceptable string
|
|
*/
|
|
#ifndef DEBUG_STR
|
|
#define DEBUG_STR(x) (char*)(x) ? (*((char*)x) ? (char*)(x) : "\\0") : _nullname
|
|
#endif
|
|
|
|
/*
|
|
* Opens the debug environment. Can be redefined.
|
|
*/
|
|
|
|
#ifndef DEBUG_OPEN
|
|
#define DEBUG_OPEN(file) fopen(file, "w",stdout)
|
|
#endif
|
|
|
|
/*
|
|
* Does a printf() to a debug file or port.
|
|
*/
|
|
|
|
#ifndef DEBUG_PRINTF
|
|
#define DEBUG_PRINTF printf
|
|
#endif
|
|
|
|
#ifndef zprintf
|
|
#define zprintf DEBUG_PRINTF
|
|
#endif
|
|
|
|
/*
|
|
* Logs return value and return it.
|
|
*/
|
|
|
|
#ifndef DEBUG_RETURN
|
|
#define DEBUG_RETURN(x) { ds(("Returning %s\n",#x)) return x; }
|
|
#endif
|
|
|
|
/*
|
|
* Can be replaced by a variable which holds the debug level.
|
|
*/
|
|
|
|
#ifndef DEBUG_ON
|
|
#if DEBUG==2
|
|
int _debug_on=1;
|
|
#elif DEBUG==3
|
|
extern int _debug_on;
|
|
#elif DEBUG==1
|
|
static int _debug_on=1;
|
|
#endif
|
|
#define DEBUG_ON() (_debug_on)
|
|
#endif
|
|
|
|
/*
|
|
* Can be replaced by a variable which holds the debug level.
|
|
* Used for tracing function entries.
|
|
*/
|
|
|
|
#ifndef DEBUG_ENTRYON
|
|
#define DEBUG_ENTRYON() DEBUG_ON()
|
|
#endif
|
|
|
|
/*
|
|
* Cleans up the debug environment.
|
|
*/
|
|
|
|
#ifndef DEBUG_CLOSE
|
|
#define DEBUG_CLOSE() fclose(stdout)
|
|
#endif
|
|
|
|
/*
|
|
* Log file name and line number
|
|
*/
|
|
|
|
#ifndef DEBUG_LOGFILELINE
|
|
static char __fileline__[]="%-10s %4d :";
|
|
/* #define DEBUG_LOGFILELINE(file, line) DEBUG_PRINTF("%-10s %4d :",file,line) */
|
|
#define DEBUG_LOGFILELINE(file, line) DEBUG_PRINTF(__fileline__,file,line)
|
|
#endif
|
|
|
|
|
|
#ifndef DL
|
|
#define DL() DEBUG_LOGFILELINE(__FILE__,__LINE__);
|
|
#endif
|
|
|
|
#ifndef DEBUG_ENTRY
|
|
/*
|
|
* Function entry and exit
|
|
*/
|
|
#define _DEBUG_STACKTAG 0xFEDCBA98 /* magic number */
|
|
|
|
#ifdef __cplusplus
|
|
|
|
class debug_logentry
|
|
{
|
|
private:
|
|
long stacktag;
|
|
char *funcname;
|
|
public:
|
|
char *getfuncname() { return funcname; } // function name
|
|
void * getstack() { int hello; return (void*) &hello; } // return current stack
|
|
void * unwindstack(); // unwind stack
|
|
debug_logentry(char *name)
|
|
{
|
|
funcname = name;
|
|
stacktag = _DEBUG_STACKTAG; // magic number
|
|
if (DEBUG_ENTRYON()) DEBUG_PRINTF("Entering [%s]\n", funcname);
|
|
}
|
|
~debug_logentry()
|
|
{
|
|
if (DEBUG_ENTRYON()) DEBUG_PRINTF("Leaving [%s]\n", funcname);
|
|
}
|
|
} ;
|
|
|
|
#define __FUNCENTRY__(a,b) debug_logentry __FUNC__(a);
|
|
|
|
#else
|
|
/*
|
|
* Sets the name of a function in a local variable called __FUNC__.
|
|
* Can be replaced by logging the name.
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
long stacktag;
|
|
char *funcname;
|
|
} debug_logentry;
|
|
|
|
#define __FUNCENTRY__(a,b) debug_logentry __FUNC__ = {_DEBUG_STACKTAG, a} ;
|
|
|
|
#endif /* C++ */
|
|
#define DEBUG_ENTRY(a,b) __FUNCENTRY__(#a,b)
|
|
#endif /* DEBUG_ENTRY */
|
|
|
|
|
|
#define D(x) x
|
|
#define d(x) {if (DEBUG_ON()) {x} }
|
|
#define dd(x) {if (DEBUG_ON()) {DL() x} }
|
|
#define ds(x) dd(DEBUG_PRINTF x; )
|
|
#define dsx(x) ds(( #x "=0x%08lX\n", (long)(x)))
|
|
#define dsd(x) ds(( #x "=%ld\n", (long)(x)))
|
|
#define dsxd(x) ds(( #x "=0x%08lX %ld\n", (long)(x), (long)(x)))
|
|
#define dsf(x) ds(( #x "=%16g\n", (double)(x)))
|
|
#define dsm(s,n) DL() DEBUG_DUMPDATA(#s, s, n, 0)
|
|
static const char _nullname[] = "<NULL>";
|
|
#define dss(x) ds(( #x "=[%s]\n", (const char*)((char*)(x) ? (char*)(x) : _nullname)))
|
|
#define dsxs(x) ds(( #x "=0x%08lX [%s]\n", (long)(x), (const char*)((char*)(x) ? (char*)(x) : _nullname)))
|
|
|
|
#if __cplusplus
|
|
|
|
#define dcp(x) { dd((x)->debug(#x);) } // class debug function
|
|
|
|
/*
|
|
* For debugging of existing structures: make a derived class of it.
|
|
* NOTE: private members are not accessible by this class !
|
|
*/
|
|
|
|
#define DEBUG_DCLASS(type, statements) \
|
|
class _DEBUG_##type : public type \
|
|
{ \
|
|
public: \
|
|
inline operator type & () { return (type &) *this; } \
|
|
inline _DEBUG_##type & operator = (type & par) { *this = (_DEBUG_##type &) par; return *this; } \
|
|
DEBUG_LOGSTRUCT(statements) \
|
|
} ; \
|
|
DEBUG_LOGSTRUCTFUNC(type,var)
|
|
|
|
#define ddcp(var) { dd(_debug_logstruct(var, #var); ) }
|
|
|
|
/*
|
|
* For debugging of nonstruct scalar types: make a class containing one data element
|
|
* of the specified type named <var>.
|
|
*/
|
|
|
|
#define DEBUG_VCLASS(type,statements) \
|
|
class _DEBUG_##type \
|
|
{ \
|
|
protected: \
|
|
type var; \
|
|
public: \
|
|
_DEBUG_##type(const type init) { var = init; } \
|
|
inline operator type & () const { return (type&) var ; } \
|
|
DEBUG_LOGSTRUCT(statements) \
|
|
} ; \
|
|
DEBUG_LOGSTRUCTFUNC(type,var)
|
|
|
|
#else /* Standard Regular C */
|
|
|
|
#define DEBUG_VCLASS(y,x)
|
|
#define DEBUG_DCLASS(y,x)
|
|
#define ddcp(x) /* not defined */
|
|
#define dcp(x) /* not defined */
|
|
#endif /* if C++ */
|
|
|
|
#else /* DEBUG off */
|
|
/* stub out DEBUG_PRINTF */
|
|
#define DEBUG_PRINTF_FUNCDEF(file) \
|
|
EXTERN_C int DEBUG_PRINTF(const char *s, ...) { return 0; }
|
|
|
|
#define DEBUG_STR(s) s
|
|
#define DEBUG_LOGSTACK()
|
|
#define DEBUG_VCLASS(y,x)
|
|
#define DEBUG_DCLASS(y,x)
|
|
#define DEBUG_OPEN(file)
|
|
#define DEBUG_CLOSE()
|
|
#define DEBUG_ENTRY(a,b)
|
|
#define DEBUG_LOGFILELINE(x,y)
|
|
#define DEBUG_RETURN(x) return x
|
|
#define __FUNCENTRY__(a,b)
|
|
#define D(x)
|
|
#define DL()
|
|
#define d(x)
|
|
#define dd(x)
|
|
#define ds(x)
|
|
#define dsx(x)
|
|
#define dsd(x)
|
|
#define dsxd(x)
|
|
#define dsf(x)
|
|
#define dsm(s,n)
|
|
#define dss(x)
|
|
#define dcp(x)
|
|
#define ddcp(x)
|
|
#define dsxs(x)
|
|
#endif /* if DEBUG */
|
|
|
|
#ifndef assert
|
|
#include <assert.h>
|
|
#endif
|
|
|
|
#if !DEBUG
|
|
#define _assert(exp, file, line) _assert(NULL, file, line)
|
|
#endif
|
|
|
|
/*
|
|
* DEBUG member function in a struct or class (C++ only)
|
|
* To be put as last item in a struct or class definition.
|
|
*/
|
|
#if DEBUG && __cplusplus
|
|
|
|
/*
|
|
* This nonclass function allows type specific versions to allow
|
|
* automatic invocation of the type specific debug function without
|
|
* specifying the type in the macro.
|
|
*/
|
|
#define DEBUG_LOGSTRUCTFUNC(type, var) \
|
|
inline void _debug_logstruct(const type * var, char * str) \
|
|
{ \
|
|
((_DEBUG_##type*)var)->debug(str, #type); \
|
|
}
|
|
#ifndef DEBUG_LOGSTRUCT
|
|
#define DEBUG_LOGSTRUCT(x) \
|
|
public: void debug(const char *s, const char *typestr=NULL) { \
|
|
DEBUG_PRINTF("%s [%s]: ptr=%08lXh\n", typestr ? typestr : "?", s, this); \
|
|
if (this) { x ; } }
|
|
#endif
|
|
#else
|
|
#define DEBUG_LOGSTRUCTFUNC(type, var)
|
|
#define DEBUG_LOGSTRUCT(x)
|
|
#endif /* if C++ */
|
|
|
|
#define PCPDBG_H
|
|
#endif
|