edkdebug.h

希望我上传的这些东西可以对搞编程的程序员有点小小的帮助！谢谢！

#define TEST_STRINGA_PTR(x)       \
    (((x) != NULL) && (!IsBadStringPtrA(x, (INFINITE))))
#define TEST_STRINGW_PTR(x)       \
    (((x) != NULL) && (!IsBadStringPtrW(x, (INFINITE))))
#define TEST_READ_PTR(x, y)    \
    (((x) != NULL) && (!IsBadReadPtr((x),(y))))
#define TEST_WRITE_PTR(x, y)   \
    (((x) != NULL) && (!IsBadWritePtr((x),(y))))
#define TEST_FUNCTION_PTR(x)   \
    (((x) != NULL) && (!IsBadCodePtr((x))))

#define TEST_STRING_PTR_OR_NULL(x)        \
    (((x) == NULL) || (!IsBadStringPtr((x), (INFINITE))))
#define TEST_STRINGA_PTR_OR_NULL(x)        \
    (((x) == NULL) || (!IsBadStringPtrA((x), (INFINITE))))
#define TEST_STRINGW_PTR_OR_NULL(x)        \
    (((x) == NULL) || (!IsBadStringPtrW((x), (INFINITE))))
#define TEST_READ_PTR_OR_NULL(x, y)    \
    (((x) == NULL) || (!IsBadReadPtr((x),(y))))
#define TEST_WRITE_PTR_OR_NULL(x, y)   \
    (((x) == NULL) || (!IsBadWritePtr((x),(y))))
#define TEST_FUNCTION_PTR_OR_NULL(x)   \
    (((x) == NULL) || (!IsBadCodePtr((x))))
#define TEST_IUNKNOWN_PTR(x) \
    (((x) != NULL) && !FBadUnknown((x)))

#ifdef DEBUG

#define HR_LOG(_hr) EDKDBG_HrLog(__FILE__, __LINE__, (_hr), GetLastError())

#ifdef FAILED
#undef FAILED
#endif
#define FAILED(_hr) EDKDBG_HrFailed(__FILE__, __LINE__, (_hr), GetLastError())

#ifdef SUCCEEDED
#undef SUCCEEDED
#endif
#define SUCCEEDED(_hr) (!EDKDBG_HrFailed(__FILE__, __LINE__, (_hr), GetLastError()))

#ifdef HR_FAILED
#undef HR_FAILED
#endif
#define HR_FAILED(_hr) FAILED(_hr)

#ifdef HR_SUCCEEDED
#undef HR_SUCCEEDED
#endif
#define HR_SUCCEEDED(_hr) SUCCEEDED(_hr)

#define RETURN(_hr) return(EDKDBG_HrLog(__FILE__, __LINE__, (_hr), GetLastError()))

#define DEBUGPUBLIC(x) \
    { _Assert("DEBUG", __FILE__, __LINE__, D_PUBLIC, TRUE, "%s\n", (x)); }

#define DEBUGPRIVATE(x) \
    { _Assert("DEBUG", __FILE__, __LINE__, D_PRIVATE, TRUE, "%s\n", (x)); }

#define DEBUGACTION(x) \
    { _Assert("DEBUG", __FILE__, __LINE__, D_ACTION, TRUE, "%s\n", (x)); }


#define MODULE_ERROR(x) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, FALSE, "%s\n", (x)); }

#define MODULE_WARNING(x) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, FALSE, "%s\n", (x)); }

#define MODULE_STATUS(x) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_STATUS, FALSE, "%s\n", (x)); }

#define MODULE_ERROR1(x, y) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, FALSE, (x"\n"), (y)); }

#define MODULE_ERROR2(x, y, z) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, FALSE, (x"\n"), (y), (z)); }

#define MODULE_WARNING1(x, y) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, FALSE, (x"\n"), (y)); }

#define MODULE_WARNING2(x, y, z) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, FALSE, (x"\n"), (y), (z)); }

#define MODULE_STATUS1(x, y) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_STATUS, FALSE, (x"\n"), (y)); }

#define MODULE_STATUS2(x, y, z) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_STATUS, FALSE, (x"\n"), (y), (z)); }


#define ASSERTERROR(x, y) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, (x), (y"\n")); }

#define ASSERTWARNING(x, y) \
    { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, (x), (y"\n")); }

#define ASSERT_STRING_PTR(x, y)     ASSERTERROR(TEST_STRING_PTR(x), y)
#define ASSERT_STRINGA_PTR(x, y)    ASSERTERROR(TEST_STRINGA_PTR(x), y)
#define ASSERT_STRINGW_PTR(x, y)    ASSERTERROR(TEST_STRINGW_PTR(x), y)
#define ASSERT_READ_PTR(x, y, z)    ASSERTERROR(TEST_READ_PTR(x, y), z)
#define ASSERT_WRITE_PTR(x, y, z)   ASSERTERROR(TEST_WRITE_PTR(x, y), z)
#define ASSERT_FUNCTION_PTR(x, y)   ASSERTERROR(TEST_FUNCTION_PTR(x), y)

#define ASSERT_IUNKNOWN_PTR(x, y)   ASSERTERROR(TEST_IUNKNOWN_PTR(x), y)

#define ASSERT_STRING_PTR_OR_NULL(x, y)   \
    ASSERTERROR(TEST_STRING_PTR_OR_NULL(x), y)
#define ASSERT_STRINGA_PTR_OR_NULL(x, y)  \
    ASSERTERROR(TEST_STRINGA_PTR_OR_NULL(x), y)
#define ASSERT_STRINGW_PTR_OR_NULL(x, y)  \
    ASSERTERROR(TEST_STRINGW_PTR_OR_NULL(x), y)
#define ASSERT_READ_PTR_OR_NULL(x, y, z)  \
    ASSERTERROR(TEST_READ_PTR_OR_NULL(x, y), z)
#define ASSERT_WRITE_PTR_OR_NULL(x, y, z) \
    ASSERTERROR(TEST_WRITE_PTR_OR_NULL(x, y), z)
#define ASSERT_FUNCTION_PTR_OR_NULL(x, y) \
    ASSERTERROR(TEST_FUNCTION_PTR_OR_NULL(x), y)

#define OUTPUTDEBUGSTRING(_sz) \
    OutputDebugString("error: " __FILE__ ", " QUOTE(__LINE__) ", " _sz "\n");

#else

#define HR_LOG(_hr)                         (_hr)

#define RETURN(_hr)                         return((_hr))

#define DEBUGPUBLIC(x)                      ((void)0)

#define DEBUGPRIVATE(x)                     ((void)0)

#define DEBUGACTION(x)                      ((void)0)


#define MODULE_ERROR(x)                     ((void)0)

#define MODULE_WARNING(x)                   ((void)0)

#define MODULE_STATUS(x)                    ((void)0)

#define MODULE_ERROR1(x, y)                 ((void)0)

#define MODULE_ERROR2(x, y, z)              ((void)0)

#define MODULE_WARNING1(x, y)               ((void)0)

#define MODULE_WARNING2(x, y, z)            ((void)0)

#define MODULE_STATUS1(x, y)                ((void)0)

#define MODULE_STATUS2(x, y, z)             ((void)0)


#define ASSERTERROR(x, y)                   ((void)0)

#define ASSERTWARNING(x, y)                 ((void)0)

#define ASSERT_STRING_PTR(x, y)             ((void)0)

#define ASSERT_STRINGA_PTR(x, y)            ((void)0)

#define ASSERT_STRINGW_PTR(x, y)            ((void)0)

#define ASSERT_READ_PTR(x, y, z)            ((void)0)

#define ASSERT_WRITE_PTR(x, y, z)           ((void)0)

#define ASSERT_FUNCTION_PTR(x, y)           ((void)0)

#define ASSERT_IUNKNOWN_PTR(x, y)           ((void)0)

#define ASSERT_STRING_PTR_OR_NULL(x, y)     ((void)0)

#define ASSERT_STRINGA_PTR_OR_NULL(x, y)    ((void)0)
                                            
#define ASSERT_STRINGW_PTR_OR_NULL(x, y)    ((void)0)

#define ASSERT_READ_PTR_OR_NULL(x, y, z)    ((void)0)

#define ASSERT_WRITE_PTR_OR_NULL(x, y, z)   ((void)0)

#define ASSERT_FUNCTION_PTR_OR_NULL(x, y)   ((void)0)

#define OUTPUTDEBUGSTRING(x)                ((void)0)

#endif

//
// Memory allocation function wrappers
//

#ifndef _PRIVATE_MEMORY_H

#ifdef DEBUG

#define DEBUG_HEAP_CHECK    _DebugHeapCheck(__LINE__,__FILE__)

#define DEBUG_DUMP_HEAP     _DebugDumpHeap(__LINE__,__FILE__)

#define MAPIAllocateBuffer(x, y)    \
    EDKDBG_MAPIAllocateBuffer(__LINE__,__FILE__,(x),(y))

#define MAPIAllocateMore(x, y, z)   \
    EDKDBG_MAPIAllocateMore(__LINE__,__FILE__,(x),(y),(z))

#define MAPIFreeBuffer(x)           \
    EDKDBG_MAPIFreeBuffer(__LINE__,__FILE__,(x))

#define malloc(x)                   \
    EDKDBG_malloc(__LINE__,__FILE__,(x))

#define calloc(x, y)                \
    EDKDBG_calloc(__LINE__,__FILE__,(x),(y))

#define realloc(x, y)                \
    EDKDBG_realloc(__LINE__,__FILE__,(x),(y))

#define GlobalAlloc(x, y)            \
    EDKDBG_GlobalAlloc(__LINE__,__FILE__,(x),(y))

#define GlobalReAlloc(x, y, z)       \
    EDKDBG_GlobalReAlloc(__LINE__,__FILE__,(x),(y),(z))

#ifdef GlobalDiscard
#undef GlobalDiscard
#endif
#define GlobalDiscard(x)             \
    EDKDBG_GlobalReAlloc(__LINE__,__FILE__,(x),0,GMEM_MOVEABLE)

#define GlobalFree(x)                \
    EDKDBG_GlobalFree(__LINE__,__FILE__,(x))

#define LocalAlloc(x, y)            \
    EDKDBG_LocalAlloc(__LINE__,__FILE__,(x),(y))

#define LocalReAlloc(x, y, z)       \
    EDKDBG_LocalReAlloc(__LINE__,__FILE__,(x),(y),(z))

#ifdef LocalDiscard
#undef LocalDiscard
#endif
#define LocalDiscard(x)             \
    EDKDBG_LocalReAlloc(__LINE__,__FILE__,(x),0,GMEM_MOVEABLE)

#define LocalFree(x)                \
    EDKDBG_LocalFree(__LINE__,__FILE__,(x))

#ifdef strdup
#undef strdup
#endif
#define strdup(x)                    \
    EDKDBG_strdup(__LINE__,__FILE__,(x))

#define _strdup(x)                   \
    EDKDBG_strdup(__LINE__,__FILE__,(x))

#define _wcsdup(x)                   \
    EDKDBG_wcsdup(__LINE__,__FILE__,(x))

#define free(x)                     \
    EDKDBG_free(__LINE__,__FILE__,(x))

#else

#define DEBUG_HEAP_CHECK              ((void)0)

#define DEBUG_DUMP_HEAP               ((void)0)

#endif

#endif // _PRIVATE_MEMORY_H


//------------------------------------------------------------------------------
//
// Inline parameter checking functions
//
//------------------------------------------------------------------------------

//$--CHK_main-------------------------------------------------------------------
//  Check the parameters for main() functions.
// -----------------------------------------------------------------------------
__inline static HRESULT CHK_main(		// RETURNS: HRESULT
	IN int argc,						// number of arguments on command line
	IN char *argv[])					// array of command line arguments
{
	HRESULT		hr		= NOERROR;
	int			i		= 0;

	if (argc < 0)
	{
		hr = HR_LOG(E_INVALIDARG);
		goto cleanup;
	}

	for (i = 0; i < argc; i++)
	{
		if (!TEST_STRINGA_PTR(argv[i]))
		{
			hr = HR_LOG(E_INVALIDARG);
			goto cleanup;
		}
	}

cleanup:
	return(hr);
}


#endif // _PRIVATE_EDKDEBUG_H

#ifdef __cplusplus
}
#endif

#pragma option pop /*P_O_Pop*/
#endif