|
|
//====== Assertion/Debug output APIs =================================
#include <platform.h> // for __endexcept
#pragma warning (disable:4096) // '__cdecl' must be used with '...'
#pragma warning (disable:4201) // nonstandard extension used : nameless struct/union
#pragma warning (disable:4115) // named type definition in parentheses
#if defined(DECLARE_DEBUG) && defined(DEBUG)
//
// Declare module-specific debug strings
//
// When including this header in your private header file, do not
// define DECLARE_DEBUG. But do define DECLARE_DEBUG in one of the
// source files in your project, and then include this header file.
//
// You may also define the following:
//
// SZ_DEBUGINI - the .ini file used to set debug flags
// SZ_DEBUGSECTION - the section in the .ini file specific to
// the module component.
// SZ_MODULE - ansi version of the name of your module.
//
//
// (These are deliberately CHAR)
EXTERN_C const CHAR c_szCcshellIniFile[] = SZ_DEBUGINI;EXTERN_C const CHAR c_szCcshellIniSecDebug[] = SZ_DEBUGSECTION;
EXTERN_C const WCHAR c_wszTrace[] = L"t " TEXTW(SZ_MODULE) L" ";EXTERN_C const WCHAR c_wszErrorDbg[] = L"err " TEXTW(SZ_MODULE) L" ";EXTERN_C const WCHAR c_wszWarningDbg[] = L"wn " TEXTW(SZ_MODULE) L" ";EXTERN_C const WCHAR c_wszAssertMsg[] = TEXTW(SZ_MODULE) L" Assert: ";EXTERN_C const WCHAR c_wszAssertFailed[] = TEXTW(SZ_MODULE) L" Assert %ls, line %d: (%ls)\r\n";EXTERN_C const WCHAR c_wszRip[] = TEXTW(SZ_MODULE) L" RIP in %s at %s, line %d: (%s)\r\n";EXTERN_C const WCHAR c_wszRipNoFn[] = TEXTW(SZ_MODULE) L" RIP at %s, line %d: (%s)\r\n";
// (These are deliberately CHAR)
EXTERN_C const CHAR c_szTrace[] = "t " SZ_MODULE " ";EXTERN_C const CHAR c_szErrorDbg[] = "err " SZ_MODULE " ";EXTERN_C const CHAR c_szWarningDbg[] = "wn " SZ_MODULE " ";EXTERN_C const CHAR c_szAssertMsg[] = SZ_MODULE " Assert: ";EXTERN_C const CHAR c_szAssertFailed[] = SZ_MODULE " Assert %s, line %d: (%s)\r\n";EXTERN_C const CHAR c_szRip[] = SZ_MODULE " RIP in %s at %s, line %d: (%s)\r\n";EXTERN_C const CHAR c_szRipNoFn[] = SZ_MODULE " RIP at %s, line %d: (%s)\r\n";EXTERN_C const CHAR c_szRipMsg[] = SZ_MODULE " RIP: ";
#endif // DECLARE_DEBUG && DEBUG
#if defined(DECLARE_DEBUG) && defined(PRODUCT_PROF)
EXTERN_C const CHAR c_szCcshellIniFile[] = SZ_DEBUGINI;EXTERN_C const CHAR c_szCcshellIniSecDebug[] = SZ_DEBUGSECTION;#endif
#ifdef __cplusplus
extern "C" {#endif
#if !defined(DECLARE_DEBUG)
//
// Debug macros and validation code
//
#if !defined(UNIX) || (defined(UNIX) && !defined(NOSHELLDEBUG))
// Undefine the macros that we define in case some other header
// might have tried defining these commonly-named macros.
#undef Assert
#undef AssertE
#undef AssertMsg
#undef AssertStrLen
#undef DebugMsg
#undef FullDebugMsg
#undef ASSERT
#undef EVAL
#undef ASSERTMSG // catch people's typos
#undef DBEXEC
#ifdef _ATL_NO_DEBUG_CRT
#undef _ASSERTE // we substitute this ATL macro
#endif
#endif // !UNIX
// Access these globals to determine which debug flags are set.
// These globals are modified by CcshellGetDebugFlags(), which
// reads an .ini file and sets the appropriate flags.
//
// g_dwDumpFlags - bits are application specific. Typically
// used for dumping structures.
// g_dwBreakFlags - uses BF_* flags. The remaining bits are
// application specific. Used to determine
// when to break into the debugger.
// g_qwTraceFlags - uses TF_* flags. The remaining bits are
// application specific. Used to display
// debug trace messages.
// g_dwFuncTraceFlags - bits are application specific. When
// TF_FUNC is set, CcshellFuncMsg uses this
// value to determine which function traces
// to display.
// g_dwProtoype - bits are application specific. Use it for
// anything.
// g_dwProfileCAP - bits are application specific. Used to
// control ICECAP profiling.
//
extern DWORD g_dwDumpFlags;extern DWORD g_dwBreakFlags;extern ULONGLONG g_qwTraceFlags;#ifdef DEBUG
extern DWORD g_dwPrototype;#else
#define g_dwPrototype 0
#endif
extern DWORD g_dwFuncTraceFlags;
#if defined(DEBUG) || defined(PRODUCT_PROF)
BOOL CcshellGetDebugFlags(void);#else
#define CcshellGetDebugFlags() 0
#endif
// Break flags for g_dwBreakFlags
#define BF_ASSERT 0x00000001 // Break on assertions
#define BF_ONAPIENTER 0x00000002 // Break on entering an API
#define BF_ONERRORMSG 0x00000004 // Break on TF_ERROR
#define BF_ONWARNMSG 0x00000008 // Break on TF_WARNING
#define BF_THR 0x00000100 // Break when THR() receives a failure
#define BF_RIP 0x00000200 // Break on RIPs
#define BF_LEAKS 0x80000000 // Break on detecting a leak
// Trace flags for g_qwTraceFlags
#define TF_ALWAYS 0xFFFFFFFFFFFFFFFF
#define TF_NEVER 0x00000000
#define TF_WARNING 0x00000001
#define TF_ERROR 0x00000002
#define TF_GENERAL 0x00000004 // Standard messages
#define TF_FUNC 0x00000008 // Trace function calls
#define TF_ATL 0x00000008 // Since TF_FUNC is so-little used, I'm overloading this bit
#define TF_MEMUSAGE 0x0000000100000000
#define TF_KEEP_ALLOCATION_STACKS 0x0000000200000000
// (Upper 28 bits reserved for custom use per-module)
#define TF_CUSTOM1 0x40000000 // Custom messages #1
#define TF_CUSTOM2 0x80000000 // Custom messages #2
// Old, archaic debug flags.
// APPCOMPAT (scotth): the following flags will be phased out over time.
#ifdef DM_TRACE
#undef DM_TRACE
#undef DM_WARNING
#undef DM_ERROR
#endif
#define DM_TRACE TF_GENERAL // OBSOLETE Trace messages
#define DM_WARNING TF_WARNING // OBSOLETE Warning
#define DM_ERROR TF_ERROR // OBSOLETE Error
// Use this macro to declare message text that will be placed
// in the CODE segment (useful if DS is getting full)
//
// Ex: DEBUGTEXT(szMsg, "Invalid whatever: %d");
//
#define DEBUGTEXT(sz, msg) /* ;Internal */ \
static const TCHAR sz[] = msg
#ifndef NOSHELLDEBUG // Others have own versions of these.
#ifdef DEBUG
void AttachUserModeDebugger (void);
#ifdef _X86_
// Use int 3 so we stop immediately in the source
#define DEBUG_BREAK \
{ \ static BOOL gAlwaysAssert = FALSE; \ AttachUserModeDebugger(); \ do \ { \ _try \ { \ _asm int 3 \ } \ _except (EXCEPTION_EXECUTE_HANDLER) \ { \ } \ } while (gAlwaysAssert); \ }#else
#define DEBUG_BREAK \
{ \ static BOOL gAlwaysAssert = FALSE; \ AttachUserModeDebugger(); \ do \ { \ _try \ { \ DebugBreak(); \ } \ _except (EXCEPTION_EXECUTE_HANDLER) \ { \ } \ __endexcept \ } while (gAlwaysAssert); \ }#endif
// Prototypes for debug functions
void CcshellStackEnter(void);void CcshellStackLeave(void);
void CDECL CcshellFuncMsgW(ULONGLONG mask, LPCSTR pszMsg, ...);void CDECL CcshellFuncMsgA(ULONGLONG mask, LPCSTR pszMsg, ...);void CDECL _AssertMsgA(BOOL f, LPCSTR pszMsg, ...);void CDECL _AssertMsgW(BOOL f, LPCWSTR pszMsg, ...);
void _AssertStrLenA(LPCSTR pszStr, int iLen);void _AssertStrLenW(LPCWSTR pwzStr, int iLen);
#ifdef UNICODE
#define CcshellFuncMsg CcshellFuncMsgW
#define CcshellAssertMsg CcshellAssertMsgW
#define _AssertMsg _AssertMsgW
#define _AssertStrLen _AssertStrLenW
#else
#define CcshellFuncMsg CcshellFuncMsgA
#define CcshellAssertMsg CcshellAssertMsgA
#define _AssertMsg _AssertMsgA
#define _AssertStrLen _AssertStrLenA
#endif
#endif // DEBUG
// ASSERT(f)
//
// Generates a "Assert file.c, line x (eval)" message if f is NOT true.
//
// Use ASSERT() to check for logic invariance. These are typically considered
// fatal problems, and falls into the 'this should never ever happen'
// category.
//
// Do *not* use ASSERT() to verify successful API calls if the APIs can
// legitimately fail due to low resources. For example, LocalAlloc can
// legally fail, so you shouldn't assert that it will never fail.
//
// The BF_ASSERT bit in g_dwBreakFlags governs whether the function
// performs a DebugBreak().
//
// Default Behavior-
// Retail builds: nothing
// Debug builds: spew and break
// Full debug builds: spew and break
//
#ifdef DEBUG
BOOL CcshellAssertFailedA(LPCSTR szFile, int line, LPCSTR pszEval, BOOL bBreakInside);BOOL CcshellAssertFailedW(LPCWSTR szFile, int line, LPCWSTR pwszEval, BOOL bBreakInside);#ifdef UNICODE
#define CcshellAssertFailed CcshellAssertFailedW
#else
#define CcshellAssertFailed CcshellAssertFailedA
#endif
#define ASSERT(f) \
{ \ DEBUGTEXT(szFile, TEXT(__FILE__)); \ if (!(f) && CcshellAssertFailed(szFile, __LINE__, TEXT(#f), FALSE)) \ DEBUG_BREAK; \ }
// The old Win95 code used to use "Assert()". We discourage the use
// of this macro now because it is not msdev-friendly.
#ifdef DISALLOW_Assert
#define Assert(f) Dont_use_Assert___Use_ASSERT
#else
#define Assert(f) ASSERT(f)
#endif
#else // DEBUG
#define ASSERT(f)
#define Assert(f)
#endif // DEBUG
// ASSERTMSG(f, szFmt, args...)
//
// Behaves like ASSERT, except it prints the wsprintf-formatted message
// instead of the file and line number.
//
// The sz parameter is always ANSI; AssertMsg correctly converts it
// to unicode if necessary. This is so you don't have to wrap your
// debug strings with TEXT().
//
// The BF_ASSERT bit in g_dwBreakFlags governs whether the function
// performs a DebugBreak().
//
// Default Behavior-
// Retail builds: nothing
// Debug builds: spew and break
// Full debug builds: spew and break
//
#ifdef DEBUG
void CDECL CcshellAssertMsgW(BOOL bAssert, LPCSTR pszMsg, ...);void CDECL CcshellAssertMsgA(BOOL bAssert, LPCSTR pszMsg, ...);#ifdef UNICODE
#define CcshellAssertMsg CcshellAssertMsgW
#else
#define CcshellAssertMsg CcshellAssertMsgA
#endif
#define ASSERTMSG CcshellAssertMsg
#else // DEBUG
#define ASSERTMSG 1 ? (void)0 : (void)
#endif // DEBUG
// EVAL(f)
//
// Behaves like ASSERT(). Evaluates the expression (f). The expression
// is always evaluated, even in retail builds. But the macro only asserts
// in the debug build. This macro may be used on logical expressions, eg:
//
// if (EVAL(exp))
// // do something
//
// Do *not* use EVAL() to verify successful API calls if the APIs can
// legitimately fail due to low resources. For example, LocalAlloc can
// legally fail, so you shouldn't assert that it will never fail.
//
// The BF_ASSERT bit in g_dwBreakFlags governs whether the function
// performs a DebugBreak().
//
// Default Behavior-
// Retail builds: nothing
// Debug builds: spew and break
// Full debug builds: spew and break
//
#ifdef DEBUG
#define EVAL(exp) \
((exp) || (CcshellAssertFailed(TEXT(__FILE__), __LINE__, TEXT(#exp), TRUE), 0))
#else // DEBUG
#define EVAL(exp) ((exp) != 0)
#endif // DEBUG
// RIP(f)
//
// Generates a "RIP at file.c, line x (eval)" message if f is NOT true.
//
// Use RIP() to perform parameter validation, especially when you
// know the function or method may be called by a 3rd party app.
// Typically, RIPs are used to indicate the caller passed in an invalid
// parameter, so the problem is really not in the code itself.
//
// Do *not* use RIP() to verify successful API calls if the APIs can
// legitimately fail due to low resources. For example, LocalAlloc can
// legally fail, so you shouldn't assert that it will never fail.
//
// RIP performs a debugbreak only in the following processes:
//
// explore.exe
// iexplore.exe
// rundll32.exe
//
// In any other process, this just spews the debug message, but doesn't stop.
//
// Setting the BF_RIP bit in g_dwBreakFlags will cause the macro to perform
// a DebugBreak() even in non-shell processes.
//
// Default Behavior-
// Retail builds: nothing
// Debug builds: spew (other processes), spew and break (shell processes)
// Full debug builds: spew (other processes), spew and break (shell processes)
//
#ifdef DEBUG
BOOL CcshellRipA(LPCSTR pszFile, int line, LPCSTR pszEval, BOOL bBreakInside);BOOL CcshellRipW(LPCWSTR pszFile, int line, LPCWSTR pwszEval, BOOL bBreakInside);BOOL CDECL CcshellRipMsgA(BOOL bRip, LPCSTR pszMsg, ...);BOOL CDECL CcshellRipMsgW(BOOL bRip, LPCSTR pszMsg, ...);
#ifdef UNICODE
#define CcshellRip CcshellRipW
#define CcshellRipMsg CcshellRipMsgW
#else
#define CcshellRip CcshellRipA
#define CcshellRipMsg CcshellRipMsgA
#endif
#define RIP(f) \
{ \ DEBUGTEXT(szFile, TEXT(__FILE__)); \ if (!(f) && CcshellRip(szFile, __LINE__, TEXT(#f), FALSE)) \ { \ DEBUG_BREAK; \ } \ } \
#define RIPMSG CcshellRipMsg
#else // DEBUG
#define RIP(f)
#define RIPMSG 1 ? (void)0 : (void)
#endif // DEBUG
// TraceMsg(dwMask, sz, args...)
//
// Generate wsprintf-formatted message using the specified trace dwMask.
// dwMask may be one of the predefined bits:
//
// TF_ERROR - display "err <MODULE> <string>"
// TF_WARNING - display "wn <MODULE> <string>"
// TF_GENERAL - display "t <MODULE> <string>"
// TF_ALWAYS - display "t <MODULE> <string>" regardless of g_qwTraceFlags.
//
// or it may be a custom bit (any of the upper 28 bits).
//
// The g_qwTraceFlags global governs whether the message is displayed (based
// upon the dwMask parameter).
//
// The sz parameter is always ANSI; TraceMsg correctly converts it
// to unicode if necessary. This is so you don't have to wrap your
// debug strings with TEXT().
//
// In addition to squirting the trace message, you may optionally cause
// the trace message to stop if you need to trace down the source of
// an error. The BF_ONERRORMSG and BF_ONWARNMSG bits may be set in
// g_dwBreakFlags to make TraceMsg stop when a TF_ERROR or TF_WARNING
// message is displayed. But typically these bits are disabled.
//
// Default Behavior-
// Retail builds: nothing
// Debug builds: only TF_ALWAYS and TF_ERROR messages spew
// Full debug builds: spew
//
#ifdef DEBUG
UINT GetStack(UINT nDepth, CHAR *szBuffer, UINT nBufferLength);void CDECL CcshellDebugMsgW(ULONGLONG mask, LPCSTR pszMsg, ...);void CDECL CcshellDebugMsgA(ULONGLONG mask, LPCSTR pszMsg, ...);void CDECL _DebugMsgA(ULONGLONG flag, LPCSTR psz, ...);void CDECL _DebugMsgW(ULONGLONG flag, LPCWSTR psz, ...);#ifdef UNICODE
#define CcshellDebugMsg CcshellDebugMsgW
#define _DebugMsg _DebugMsgW
#else
#define CcshellDebugMsg CcshellDebugMsgA
#define _DebugMsg _DebugMsgA
#endif
#define TraceMsgW CcshellDebugMsgW
#define TraceMsgA CcshellDebugMsgA
#define TraceMsg CcshellDebugMsg
// Use TraceMsg instead of DebugMsg. DebugMsg is obsolete.
#ifdef DISALLOW_DebugMsg
#define DebugMsg Dont_use_DebugMsg___Use_TraceMsg
#else
#define DebugMsg _DebugMsg
#endif
#else // DEBUG
#define TraceMsgA 1 ? (void)0 : (void)
#define TraceMsgW 1 ? (void)0 : (void)
#define TraceMsg 1 ? (void)0 : (void)
#define DebugMsg 1 ? (void)0 : (void)
#endif // DEBUG
// THR(pfn)
// TBOOL(pfn)
// TINT(pfn)
// TPTR(pfn)
// TW32(pfn)
//
// These macros are useful to trace failed calls to functions that return
// HRESULTs, BOOLs, ints, or pointers. An example use of this is:
//
// {
// ...
// hres = THR(CoCreateInstance(CLSID_Bar, NULL, CLSCTX_INPROC_SERVER,
// IID_IBar, (LPVOID*)&pbar));
// if (SUCCEEDED(hres))
// ...
// }
//
// If CoCreateInstance failed, you would see spew similar to:
//
// err MODULE THR: Failure of "CoCreateInstance(CLSID_Bar, NULL, CLSCTX_INPROC_SERVER, IID_IBar, (LPVOID*)&pbar)" at foo.cpp, line 100 (0x80004005)
//
// THR keys off of the failure code of the hresult.
// TBOOL considers FALSE to be a failure case.
// TINT considers -1 to be a failure case.
// TPTR considers NULL to be a failure case.
// TW32 keys off the failure code of the Win32 error code.
//
// Set the BF_THR bit in g_dwBreakFlags to stop when these macros see a failure.
//
// Default Behavior-
// Retail builds: nothing
// Debug builds: nothing
// Full debug builds: spew on error
//
#ifdef DEBUG
EXTERN_C HRESULT TraceHR(HRESULT hrTest, LPCSTR pszExpr, LPCSTR pszFile, int iLine);EXTERN_C BOOL TraceBool(BOOL bTest, LPCSTR pszExpr, LPCSTR pszFile, int iLine);EXTERN_C int TraceInt(int iTest, LPCSTR pszExpr, LPCSTR pszFile, int iLine);EXTERN_C LPVOID TracePtr(LPVOID pvTest, LPCSTR pszExpr, LPCSTR pszFile, int iLine);EXTERN_C DWORD TraceWin32(DWORD dwTest, LPCSTR pszExpr, LPCSTR pszFile, int iLine);
#define THR(x) (TraceHR((x), #x, __FILE__, __LINE__))
#define TBOOL(x) (TraceBool((x), #x, __FILE__, __LINE__))
#define TINT(x) (TraceInt((x), #x, __FILE__, __LINE__))
#define TPTR(x) (TracePtr((x), #x, __FILE__, __LINE__))
#define TW32(x) (TraceWin32((x), #x, __FILE__, __LINE__))
#else // DEBUG
#define THR(x) (x)
#define TBOOL(x) (x)
#define TINT(x) (x)
#define TPTR(x) (x)
#define TW32(x) (x)
#endif // DEBUG
// DBEXEC(flg, expr)
//
// under DEBUG, does "if (flg) expr;" (w/ the usual safe syntax)
// under !DEBUG, does nothing (and does not evaluate either of its args)
//
#ifdef DEBUG
#define DBEXEC(flg, expr) ((flg) ? (expr) : 0)
#else // DEBUG
#define DBEXEC(flg, expr) /*NOTHING*/
#endif // DEBUG
// string and buffer whacking functions
//
#ifdef DEBUG
EXTERN_C void DEBUGWhackPathBufferA(LPSTR psz, UINT cch);EXTERN_C void DEBUGWhackPathBufferW(LPWSTR psz, UINT cch);EXTERN_C void DEBUGWhackPathStringA(LPSTR psz, UINT cch);EXTERN_C void DEBUGWhackPathStringW(LPWSTR psz, UINT cch);
#else // DEBUG
#define DEBUGWhackPathBufferA(psz, cch)
#define DEBUGWhackPathBufferW(psz, cch)
#define DEBUGWhackPathStringA(psz, cch)
#define DEBUGWhackPathStringW(psz, cch)
#endif // DEBUG
#ifdef UNICODE
#define DEBUGWhackPathBuffer DEBUGWhackPathBufferW
#define DEBUGWhackPathString DEBUGWhackPathStringW
#else
#define DEBUGWhackPathBuffer DEBUGWhackPathBufferA
#define DEBUGWhackPathString DEBUGWhackPathStringA
#endif
// Some trickery to map ATL debug macros to ours, so ATL code that stops
// or spews in our code will look like the rest of our squirties.
#ifdef DEBUG
#ifdef _ATL_NO_DEBUG_CRT
// ATL uses _ASSERTE. Map it to ours.
#define _ASSERTE(f) ASSERT(f)
// We map ATLTRACE macros to our functions
void _cdecl ShellAtlTraceA(LPCSTR lpszFormat, ...);void _cdecl ShellAtlTraceW(LPCWSTR lpszFormat, ...);#ifdef UNICODE
#define ShellAtlTrace ShellAtlTraceW
#else
#define ShellAtlTrace ShellAtlTraceA
#endif
// These are turned off because they normally don't give
// feedback of error cases and so many fire that they
// swamp out other useful debug spew.
//#define ATLTRACE ShellAtlTrace
#endif
#else // DEBUG
#ifdef _ATL_NO_DEBUG_CRT
// ATL uses _ASSERTE. Map it to ours.
#define _ASSERTE(f)
// We map ATLTRACE macros to our functions
#define ATLTRACE 1 ? (void)0 : (void)
#define ATLTRACE2 1 ? (void)0 : (void)
#endif
#endif // DEBUG
// ------ Stay away from these macros below ----------
// APPCOMPAT (scotth): remove these by 8/15/98. They should not be used anymore.
#ifdef DEBUG
#define AssertE(f) ASSERT(f)
#define AssertMsg _AssertMsg
#define AssertStrLen _AssertStrLen
#define AssertStrLenA _AssertStrLenA
#define AssertStrLenW _AssertStrLenW
#ifdef FULL_DEBUG
#define FullDebugMsg _DebugMsg
#else
#define FullDebugMsg 1 ? (void)0 : (void)
#endif
#define ASSERT_MSGW CcshellAssertMsgW
#define ASSERT_MSGA CcshellAssertMsgA
#define ASSERT_MSG CcshellAssertMsg
#else // DEBUG
#define AssertE(f) (f)
#define AssertMsg 1 ? (void)0 : (void)
#define AssertStrLen(lpStr, iLen)
#define FullDebugMsg 1 ? (void)0 : (void)
#define ASSERT_MSGA 1 ? (void)0 : (void)
#define ASSERT_MSGW 1 ? (void)0 : (void)
#define ASSERT_MSG 1 ? (void)0 : (void)
#endif // DEBUG
// ------ Stay away from these macros above ----------
// It's necessary to find when classes that were designed to be single threaded are used
// across threads so they can be fixed to be multithreaded. These asserts will point
// out such cases.
#ifdef DEBUG
#define ASSERT_SINGLE_THREADED AssertMsg(_dwThreadIDForSingleThreadedAssert == GetCurrentThreadId(), TEXT("MULTI-THREADED BUG: This class is being used by more than one thread, but it's not thread safe."))
#define INIT_SINGLE_THREADED_ASSERT _dwThreadIDForSingleThreadedAssert = GetCurrentThreadId();
#define SINGLE_THREADED_MEMBER_VARIABLE DWORD _dwThreadIDForSingleThreadedAssert;
#else // DEBUG
#define ASSERT_SINGLE_THREADED NULL;
#define INIT_SINGLE_THREADED_ASSERT NULL;
#define SINGLE_THREADED_MEMBER_VARIABLE
#endif // DEBUG
#ifdef DEBUG
#define Dbg_SafeStrA(psz) (SAFECAST(psz, LPCSTR), (psz) ? (psz) : "NULL string")
#define Dbg_SafeStrW(psz) (SAFECAST(psz, LPCWSTR), (psz) ? (psz) : L"NULL string")
#ifdef UNICODE
#define Dbg_SafeStr Dbg_SafeStrW
#else
#define Dbg_SafeStr Dbg_SafeStrA
#endif
#define FUNC_MSG CcshellFuncMsg
// Helpful macro for mapping manifest constants to strings. Assumes
// return string is pcsz. You can use this macro in this fashion:
//
// LPCSTR Dbg_GetFoo(FOO foo)
// {
// LPCTSTR pcsz = TEXT("Unknown <foo>");
// switch (foo)
// {
// STRING_CASE(FOOVALUE1);
// STRING_CASE(FOOVALUE2);
// ...
// }
// return pcsz;
// }
//
#define STRING_CASE(val) case val: pcsz = TEXT(#val); break
// Debug function enter
// DBG_ENTER(flag, fn) -- Generates a function entry debug spew for
// a function
//
#define DBG_ENTER(flagFTF, fn) \
(FUNC_MSG(flagFTF, " > " #fn "()"), \ CcshellStackEnter())
// DBG_ENTER_TYPE(flag, fn, dw, pfnStrFromType) -- Generates a function entry debug
// spew for functions that accept <type>.
//
#define DBG_ENTER_TYPE(flagFTF, fn, dw, pfnStrFromType) \
(FUNC_MSG(flagFTF, " < " #fn "(..., %s, ...)", (LPCTSTR)pfnStrFromType(dw)), \ CcshellStackEnter())
// DBG_ENTER_SZ(flag, fn, sz) -- Generates a function entry debug spew for
// a function that accepts a string as one of its
// parameters.
//
#define DBG_ENTER_SZ(flagFTF, fn, sz) \
(FUNC_MSG(flagFTF, " > " #fn "(..., \"%s\",...)", Dbg_SafeStr(sz)), \ CcshellStackEnter())
// Debug function exit
// DBG_EXIT(flag, fn) -- Generates a function exit debug spew
//
#define DBG_EXIT(flagFTF, fn) \
(CcshellStackLeave(), \ FUNC_MSG(flagFTF, " < " #fn "()"))
// DBG_EXIT_TYPE(flag, fn, dw, pfnStrFromType) -- Generates a function exit debug
// spew for functions that return <type>.
//
#define DBG_EXIT_TYPE(flagFTF, fn, dw, pfnStrFromType) \
(CcshellStackLeave(), \ FUNC_MSG(flagFTF, " < " #fn "() with %s", (LPCTSTR)pfnStrFromType(dw)))
// DBG_EXIT_INT(flag, fn, us) -- Generates a function exit debug spew for
// functions that return an INT.
//
#define DBG_EXIT_INT(flagFTF, fn, n) \
(CcshellStackLeave(), \ FUNC_MSG(flagFTF, " < " #fn "() with %d", (int)(n)))
// DBG_EXIT_BOOL(flag, fn, b) -- Generates a function exit debug spew for
// functions that return a boolean.
//
#define DBG_EXIT_BOOL(flagFTF, fn, b) \
(CcshellStackLeave(), \ FUNC_MSG(flagFTF, " < " #fn "() with %s", (b) ? (LPTSTR)TEXT("TRUE") : (LPTSTR)TEXT("FALSE")))
// DBG_EXIT_UL(flag, fn, ul) -- Generates a function exit debug spew for
// functions that return a ULONG.
//
#ifdef _WIN64
#define DBG_EXIT_UL(flagFTF, fn, ul) \
(CcshellStackLeave(), \ FUNC_MSG(flagFTF, " < " #fn "() with %#016I64x", (ULONG_PTR)(ul)))#else
#define DBG_EXIT_UL(flagFTF, fn, ul) \
(CcshellStackLeave(), \ FUNC_MSG(flagFTF, " < " #fn "() with %#08lx", (ULONG)(ul)))#endif // _WIN64
#define DBG_EXIT_DWORD DBG_EXIT_UL
// DBG_EXIT_HRES(flag, fn, hres) -- Generates a function exit debug spew for
// functions that return an HRESULT.
//
#define DBG_EXIT_HRES(flagFTF, fn, hres) DBG_EXIT_TYPE(flagFTF, fn, hres, Dbg_GetHRESULTName)
#else // DEBUG
#define Dbg_SafeStr 1 ? (void)0 : (void)
#define FUNC_MSG 1 ? (void)0 : (void)
#define DBG_ENTER(flagFTF, fn)
#define DBG_ENTER_TYPE(flagFTF, fn, dw, pfn)
#define DBG_ENTER_SZ(flagFTF, fn, sz)
#define DBG_EXIT(flagFTF, fn)
#define DBG_EXIT_INT(flagFTF, fn, n)
#define DBG_EXIT_BOOL(flagFTF, fn, b)
#define DBG_EXIT_UL(flagFTF, fn, ul)
#define DBG_EXIT_DWORD DBG_EXIT_UL
#define DBG_EXIT_TYPE(flagFTF, fn, dw, pfn)
#define DBG_EXIT_HRES(flagFTF, fn, hres)
#endif // DEBUG
// COMPILETIME_ASSERT(f)
//
// Generates a build break at compile time if the constant expression
// is not true. Unlike the "#if" compile-time directive, the expression
// in COMPILETIME_ASSERT() is allowed to use "sizeof".
//
// Compiler magic! If the expression "f" is FALSE, then you get the
// compiler error "Duplicate case expression in switch statement".
//
#define COMPILETIME_ASSERT(f) switch (0) case 0: case f:
#else // NOSHELLDEBUG
#ifdef UNIX
#include <crtdbg.h>
#define ASSERT(f) _ASSERT(f)
#include <mainwin.h>
#define TraceMsg(type, sformat) DebugMessage(0, sformat)
#define TraceMSG(type, sformat, args) DebugMessage(0, sformat, args)
#endif
#endif // NOSHELLDEBUG
//
// Debug dump helper functions
//
#ifdef DEBUG
LPCTSTR Dbg_GetCFName(UINT ucf);LPCTSTR Dbg_GetHRESULTName(HRESULT hr);LPCTSTR Dbg_GetREFIIDName(REFIID riid);LPCTSTR Dbg_GetVTName(VARTYPE vt);
#else
#define Dbg_GetCFName(ucf) (void)0
#define Dbg_GetHRESULTName(hr) (void)0
#define Dbg_GetREFIIDName(riid) (void)0
#define Dbg_GetVTName(vt) (void)0
#endif // DEBUG
// I'm a lazy typist...
#define Dbg_GetHRESULT Dbg_GetHRESULTName
// Parameter validation macros
#include "validate.h"
#endif // DECLARE_DEBUG
#ifdef PRODUCT_PROF
int __stdcall StartCAP(void); // start profiling
int __stdcall StopCAP(void); // stop profiling until StartCAP
int __stdcall SuspendCAP(void); // suspend profiling until ResumeCAP
int __stdcall ResumeCAP(void); // resume profiling
int __stdcall StartCAPAll(void); // process-wide start profiling
int __stdcall StopCAPAll(void); // process-wide stop profiling
int __stdcall SuspendCAPAll(void); // process-wide suspend profiling
int __stdcall ResumeCAPAll(void); // process-wide resume profiling
void __stdcall MarkCAP(long lMark); // write mark to MEA
extern DWORD g_dwProfileCAP;#else
#define StartCAP() 0
#define StopCAP() 0
#define SuspendCAP() 0
#define ResumeCAP() 0
#define StartCAPAll() 0
#define StopCAPAll() 0
#define SuspendCAPAll() 0
#define ResumeCAPAll() 0
#define MarkCAP(n) 0
#define g_dwProfileCAP 0
#endif
#ifdef __cplusplus
};#endif
|
