|
|
//
// Common defines used in the mars project.
//
#ifndef __MARSDEV_H
#define __MARSDEV_H
// Number of elements in array
#define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0]))
// Size of struct up to but not including specified member
#define STRUCT_SIZE_TO_MEMBER(s,m) ((DWORD_PTR)(&(((s *)0)->m)))
// Size of a single member of a structure
#define SIZEOF_MEMBER(s,m) sizeof(((s *)0)->m)
// Size of struct up to and including specified member
#define STRUCT_SIZE_INCLUDING_MEMBER(s,m) (STRUCT_SIZE_TO_MEMBER(s,m) + SIZEOF_MEMBER(s,m))
#define SAFERELEASE(p) if ((p) != NULL) { (p)->Release(); (p) = NULL; } else;
// For destructor use -- doesn't NULL pointer
#define SAFERELEASE2(p) if ((p) != NULL) { (p)->Release();} else;
// Do strong typechecking
#ifdef SAFECAST
#undef SAFECAST
#endif
#define SAFECAST(_src, _type) (static_cast<_type>(_src))
//
// Validation functions.
//
#define IsValidReadPtr(ptr) \
((ptr) && !IsBadReadPtr((ptr), sizeof(*(ptr))))
#define IsValidWritePtr(ptr) \
((ptr) && !IsBadWritePtr((ptr), sizeof(*(ptr))))
#define IsValidStringW(pstr) \
((pstr) && !IsBadStringPtrW((pstr), (UINT)-1))
#define IsValidReadBuffer(ptr, n) \
((ptr) && !IsBadReadPtr((ptr), sizeof(*(ptr)) * (n)))
#define IsValidWriteBuffer(ptr, n) \
((ptr) && !IsBadWritePtr((ptr), sizeof(*(ptr)) * (n)))
#define IsValidInterfacePtr(punk) \
((punk) && IsValidReadPtr(punk) && \ !IsBadCodePtr(*((FARPROC*)punk)))
#define IsValidFunctionPtr(pfunc) \
((NULL != pfunc) && \ !IsBadCodePtr((FARPROC)pfunc))
#define IsValidBstr(bstr) \
((bstr) && IsValidWriteBuffer((BYTE*)(bstr), SysStringByteLen(bstr)))
#define IsValidOptionalBstr(bstr) \
((!bstr) || IsValidBstr(bstr))
#define IsValidVariantBoolVal(vb) \
(VARIANT_FALSE == vb || VARIANT_TRUE == vb)
#define IsValidVariantI4(var) \
(VT_I4 == (var).vt)
#define IsValidVariantBstr(var) \
(VT_BSTR == (var).vt && IsValidBstr((var).bstrVal))
#define IsValidVariantMissingOptional(var) \
(VT_ERROR == (var).vt && DISP_E_PARAMNOTFOUND == (var).scode)
#define IsValidFlag(f, fAll) \
(!((f) & ~(fAll)))
BOOL IsValidVariant(VARIANT var);BOOL IsValidStringPtrBufferW(LPOLESTR* ppstr, UINT n);
#define IsValidString IsValidStringW
#define IsValidStringPtrBuffer IsValidStringPtrBufferW
//
// API parameter validation helpers. Use these on public APIs. If a parameter
// is bad on debug build a RIP message will be generated.
//
#ifdef DEBUG
BOOL API_IsValidReadPtr(void* ptr, UINT cbSize);BOOL API_IsValidWritePtr(void* ptr, UINT cbSize);BOOL API_IsValidStringW(LPCWSTR psz);BOOL API_IsValidReadBuffer(void* ptr, UINT cbSize, UINT n);BOOL API_IsValidWriteBuffer(void* ptr, UINT cbSize, UINT n);BOOL API_IsValidInterfacePtr(IUnknown* punk);BOOL API_IsValidFunctionPtr(void *pfunc);BOOL API_IsValidVariant(VARIANT var);BOOL API_IsValidVariantI4(VARIANT var);BOOL API_IsValidVariantBstr(VARIANT var);BOOL API_IsValidBstr(BSTR bstr);BOOL API_IsValidOptionalBstr(BSTR bstr);BOOL API_IsValidFlag(DWORD dwFlag, DWORD dwAllFlags);BOOL API_IsValidStringPtrBufferW(LPOLESTR* ppStr, UINT n);
#define API_IsValidString API_IsValidStringW
#define API_IsValidStringPtrBuffer API_IsValidStringPtrBufferW
#endif //Debug
#ifdef DEBUG
#define API_IsValidReadPtr(ptr) \
API_IsValidReadPtr((ptr), sizeof(*(ptr)))
#define API_IsValidWritePtr(ptr) \
API_IsValidWritePtr((ptr), sizeof(*(ptr)))
#define API_IsValidReadBuffer(ptr, n) \
API_IsValidReadBuffer((ptr), sizeof(*(ptr)), (n))
#define API_IsValidWriteBuffer(ptr, n) \
API_IsValidWriteBuffer((ptr), sizeof(*(ptr)), (n))
#else // DEBUG
#define API_IsValidReadPtr IsValidReadPtr
#define API_IsValidWritePtr IsValidWritePtr
#define API_IsValidString IsValidString
#define API_IsValidStringW IsValidStringW
#define API_IsValidReadBuffer IsValidReadBuffer
#define API_IsValidWriteBuffer IsValidWriteBuffer
#define API_IsValidInterfacePtr IsValidInterfacePtr
#define API_IsValidFunctionPtr IsValidFunctionPtr
#define API_IsValidVariant IsValidVariant
#define API_IsValidVariantI4 IsValidVariantI4
#define API_IsValidVariantBstr IsValidVariantBstr
#define API_IsValidBstr IsValidBstr
#define API_IsValidOptionalBstr IsValidOptionalBstr
#define API_IsValidFlag IsValidFlag
#define API_IsValidStringPtrBuffer IsValidStringPtrBufferW
#endif // DEBUG
//
// Function prototypes.
//
BOOL StrEqlW(LPCWSTR psz1, LPCWSTR psz2);BOOL StrEqlA(LPCSTR psz1, LPCSTR psz2);#define StrEql StrEqlW
UINT64 HexStringToUINT64W(LPCWSTR lpwstr);
//
// Macro magic to help define away functions.
//
// TO USE:
//
// If you don't want a function to be used in the code do the following:
// #undef funcA
// #define funcA DON_USE(funcA, funcB)
//
// This will result in funcA being redefined to Don_not_use_funcA_use_funcB.
// A compilation error complaining that Don_not_use_funcA_use_funcB is undefined
// will be generated whenever anyone tries to use funcA.
//
#define MACRO_CAT(a,b) \
a##b
#define DONT_USE(a,b) \
MACRO_CAT(Do_not_use_##a,_use_##b)
// return SCRIPT_ERROR upon serious error that shouldn't occur; will break in debug builds
#ifdef DEBUG
#define SCRIPT_ERROR E_FAIL
#else
#define SCRIPT_ERROR S_FALSE
#endif
#define RECTWIDTH(rc) ((rc).right-(rc).left)
#define RECTHEIGHT(rc) ((rc).bottom-(rc).top)
HRESULT SanitizeResult(HRESULT hr);
// BITBOOL macros just make using single-bit bools a little safer. You can't nonchalantly assign
// any "int" value to a bit bool and expect it to always work. "BOOLIFY" it first.
//
#define BOOLIFY(expr) (!!(expr))
// BUGBUG (scotth): we should probably make this a 'bool', but be careful
// because the Alpha compiler might not recognize it yet. Talk to AndyP.
// This isn't a BOOL because BOOL is signed and the compiler produces
// sloppy code when testing for a single bit.
typedef DWORD BITBOOL;//
#define VARIANT_BOOLIFY(expr) ((expr) ? VARIANT_TRUE : VARIANT_FALSE)
/*
TraceResult Macros
The idea behind these macros is to have one entry and exit point per function to reduce errors (primarily bad state / leaks). They generally require an HRESULT hr, and an 'exit' label that returns hr and performs any cleanup that might be needed.
In addition to encouraging a unified exit point, these macros also debug spew if something fails (try to only use these macros on things that should never fail). This can be extremely useful when something is failing many layers deep in the code. To see the spew, you need to set TF_TRACERESULT. To break on such failures, set BF_TRACERESULT.
Common mistake: you must set hr when you use IF_FAILEXIT as it is not automatically set to _hresult (for flexibility).*/
#define IF_FAILEXIT(_hresult) \
if (FAILED(_hresult)) { \ TraceResult(hr); \ goto exit; \ } else
#define IF_NULLEXIT(_palloc) \
if (NULL == (_palloc)) { \ hr = TraceResult(E_OUTOFMEMORY); \ goto exit; \ } else
#define IF_TRUEEXIT(_expression, _hresult) \
if (_expression) { \ hr = TraceResult(_hresult); \ goto exit; \ } else
#define IF_FALSEEXIT(_expression, _hresult) \
if (FALSE == _expression) { \ hr = TraceResult(_hresult); \ goto exit; \ } else
#define TraceResult(_hresult) _hresult
#endif // __MARSDEV_H
|
