home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / edkdebug.h < prev    next >
C/C++ Source or Header  |  1998-04-25  |  25KB  |  635 lines
  1. // --edkdebug.h-----------------------------------------------------------------
  2. //
  3. //  Functions to log debugging information in DEBUG builds.
  4. // 
  5. // Copyright 1986 - 1998 Microsoft Corporation.  All Rights Reserved.
  6. // -----------------------------------------------------------------------------
  7. #if !defined(_EDKDEBUG_H)
  8. #define _EDKDEBUG_H
  9.  
  10. #include <stdio.h>
  11. #include <stdarg.h>
  12.  
  13. // Default prefix for EDK debug log files.  By default, these files
  14. // will be written to the temporary directory.  The name and path of the
  15. // log files, can, however, be overriden by setting the EDK_DEBUG_FILE
  16. // environment variable.
  17. #define EDK_LOG_FILE_PREFIX        "edk"
  18. #define EDK_LOG_FILE_SUFFIX        "log"
  19.  
  20. //$--DebugLevel-----------------------------------------------------------------
  21. //  Available levels of debug.
  22. // -----------------------------------------------------------------------------
  23. typedef enum __DEBUGLEVEL
  24. {
  25.     D_PUBLIC = 0,   // log interface functions
  26.     D_PRIVATE,      // log implementation functions
  27.     D_ERROR,        // log errors
  28.     D_WARNING,      // log warnings
  29.     D_STATUS,       // log status
  30.     D_ACTION,       // log starting/completed action
  31.     D_OTHER,        // log other information
  32.     D_LAST          // all debug levels are less than this 
  33. } DEBUGLEVEL;
  34.  
  35. #ifdef __cplusplus
  36. extern "C" {
  37. #endif // __cplusplus
  38.  
  39. //------------------------------------------------------------------------------
  40. //
  41. // EDKLOG.C Functions
  42. //
  43. //------------------------------------------------------------------------------
  44.  
  45. //$--_WriteDebugString----------------------------------------------------------
  46. //
  47. //  Write a string to the debugger output window.
  48. //  
  49. // -----------------------------------------------------------------------------
  50. void _WriteDebugString(                 // RETURNS: nothing
  51.     IN LPSTR lpszFormat,                // format string
  52.     ...);                               // arguments
  53.  
  54. //$--_StatusShowAssert----------------------------------------------------------
  55. //
  56. //  Status of the assert prompt.
  57. //  
  58. // -----------------------------------------------------------------------------
  59. BOOL _StatusShowAssert(             // RETURNS: TRUE if assert prompt
  60.     void);                          // no arguments
  61.  
  62. //$--_StatusDebugFile-----------------------------------------------------------
  63. //
  64. //  Status of the debug log file.
  65. //  
  66. // -----------------------------------------------------------------------------
  67. BOOL _StatusDebugFile(              // RETURNS: nothing
  68.     void);                          // no arguments
  69.  
  70. //$--_StatusDebugLevel----------------------------------------------------------
  71. //
  72. //  Status of the debug level.
  73. //  
  74. // -----------------------------------------------------------------------------
  75. BOOL _StatusDebugLevel(             // RETURNS: nothing
  76.     IN DEBUGLEVEL level);           // debug level
  77.  
  78. //$--_LockDebugFile-------------------------------------------------------------
  79. //
  80. //  Lock the debug log file.
  81. //  
  82. // -----------------------------------------------------------------------------
  83. void _LockDebugFile(                // RETURNS: nothing
  84.     void);                          // no arguments
  85.  
  86. //$--_UnlockDebugFile-----------------------------------------------------------
  87. //
  88. //  Unlock the debug log file.
  89. //  
  90. // -----------------------------------------------------------------------------
  91. void _UnlockDebugFile(              // RETURNS: nothing
  92.     void);                          // no arguments
  93.  
  94. //$--_WriteDebugFile------------------------------------------------------------
  95. //
  96. //  Write to the debug log file.
  97. //  
  98. // -----------------------------------------------------------------------------
  99. void _WriteDebugFile(               // RETURNS: nothing
  100.     IN LPSTR lpszFormat,            // format string
  101.     ...);                           // arguments
  102.  
  103. //$--_InitDebugFile-------------------------------------------------------------
  104. //
  105. //  Initialize the debug log file.
  106. //  
  107. // -----------------------------------------------------------------------------
  108. void _InitDebugFile(                // RETURNS: nothing
  109.     void);                          // no arguments
  110.  
  111.  
  112. //------------------------------------------------------------------------------
  113. //
  114. // EDKDEBUG.C Functions
  115. //
  116. //------------------------------------------------------------------------------
  117.  
  118. //$--_Assert--------------------------------------------------------------------
  119. //  
  120. //  Write to the debug log file and/or evaluate assertion.
  121. //  
  122. // -----------------------------------------------------------------------------
  123. void _Assert(                   // RETURNS: nothing
  124.     IN LPSTR lpszTag,           // tag name
  125.     IN LPSTR lpszFile,          // source file name
  126.     IN ULONG ulLine,            // source line number
  127.     IN DEBUGLEVEL Level,        // assertion level
  128.     IN BOOL fValue,             // assertion value
  129.     IN LPSTR lpszFormat,        // format string
  130.     ...);                       // arguments
  131.  
  132. //------------------------------------------------------------------------------
  133. //
  134. // MEMORY.C Functions
  135. //
  136. //------------------------------------------------------------------------------
  137.  
  138. #ifndef _PRIVATE_EDKDEBUG_H
  139.  
  140. //$--_DebugHeapCheck------------------------------------------------------------
  141. //  Writes an entry in the debug log. This function is only called in
  142. //  DEBUG builds through the DebugHeapCheck() macro.
  143. // -----------------------------------------------------------------------------
  144. void _DebugHeapCheck(                   // RETURNS: return code
  145.     IN ULONG ulLine,                    // line number
  146.     IN LPSTR lpszFile);                 // file name
  147.  
  148. //$--_DebugDumpHeap-------------------------------------------------------------
  149. //  Writes an entry in the debug log. This function is only called in
  150. //  DEBUG builds through the DebugDumpHeap() macro.
  151. // -----------------------------------------------------------------------------
  152. void _DebugDumpHeap(                    // RETURNS: nothing
  153.     IN ULONG ulLine,                    // line number
  154.     IN LPSTR lpszFile);                 // file name
  155.  
  156. //$--EDKDBG_MAPIAllocateBuffer--------------------------------------------------
  157. //  Wrapper for MAPIAllocateBuffer().
  158. // -----------------------------------------------------------------------------
  159. SCODE EDKDBG_MAPIAllocateBuffer(        // RETURNS: status code
  160.     IN  ULONG ulLine,                   // line number
  161.     IN  LPSTR lpszFile,                 // file name
  162.     IN  ULONG ulSize,                   // size of memory block
  163.     OUT LPVOID *lppv);                  // pointer to memory block address
  164.                                         // variable
  165.  
  166. //$--EDKDBG_MAPIAllocateMore----------------------------------------------------
  167. //  Wrapper for MAPIAllocateMore().
  168. // -----------------------------------------------------------------------------
  169. SCODE EDKDBG_MAPIAllocateMore(          // RETURNS: status code
  170.     IN  ULONG ulLine,                   // line number
  171.     IN  LPSTR lpszFile,                 // file name
  172.     IN  ULONG ulSize,                   // size of memory block
  173.     IN  LPVOID lpvOriginal,             // pointer to original memory block
  174.     OUT LPVOID *lppvData);              // pointer to memory block address
  175.                                         // variable
  176.  
  177. //$--EDKDBG_MAPIFreeBuffer------------------------------------------------------
  178. //  Wrapper for MAPIFreeBuffer().
  179. // -----------------------------------------------------------------------------
  180. SCODE EDKDBG_MAPIFreeBuffer(            // RETURNS: status code
  181.     IN ULONG ulLine,                    // line number
  182.     IN LPSTR lpszFile,                  // file name
  183.     IN LPVOID lpv);                     // pointer to memory block
  184.  
  185. //$--EDKDBG_malloc--------------------------------------------------------------
  186. //  Wrapper for malloc().
  187. // -----------------------------------------------------------------------------
  188. LPVOID EDKDBG_malloc(                   // RETURNS: pointer to memory block
  189.     IN ULONG ulLine,                    // line number
  190.     IN LPSTR lpszFile,                  // file name
  191.     IN ULONG ulSize);                   // size of memory block
  192.  
  193. //$--EDKDBG_calloc--------------------------------------------------------------
  194. //  Wrapper for calloc().
  195. // -----------------------------------------------------------------------------
  196. LPVOID EDKDBG_calloc(                   // RETURNS: pointer to memory block
  197.     IN ULONG ulLine,                    // line number
  198.     IN LPSTR lpszFile,                  // file name
  199.     IN ULONG ulNum,                     // number of elements
  200.     IN ULONG ulSize);                   // size of element
  201.  
  202. //$--EDKDBG_realloc-------------------------------------------------------------
  203. //  Wrapper for realloc().
  204. // -----------------------------------------------------------------------------
  205. LPVOID EDKDBG_realloc(                  // RETURNS: pointer to memory block
  206.     IN ULONG ulLine,                    // line number
  207.     IN LPSTR lpszFile,                  // file name
  208.     IN LPVOID lpvBlock,                 // pointer to memory block
  209.     IN ULONG ulSize);                   // new size of memory block
  210.  
  211. //$--EDKDBG_strdup--------------------------------------------------------------
  212. //  Wrapper for strdup().
  213. // -----------------------------------------------------------------------------
  214. char* EDKDBG_strdup(                    // RETURNS: pointer to allocated string
  215.     IN ULONG ulLine,                    // line number
  216.     IN LPSTR lpszFile,                  // file name
  217.     IN const char *lpsz);               // pointer to string
  218.  
  219. //$--EDKDBG_wcsdup--------------------------------------------------------------
  220. //  Wrapper for wcsdup().
  221. // -----------------------------------------------------------------------------
  222. wchar_t* EDKDBG_wcsdup(                 // RETURNS: pointer to allocated string
  223.     IN ULONG ulLine,                    // line number
  224.     IN LPSTR lpszFile,                  // file name
  225.     IN const wchar_t *lpsz);            // pointer to string
  226.  
  227. //$--EDKDBG_free----------------------------------------------------------------
  228. //  Wrapper for free().
  229. // -----------------------------------------------------------------------------
  230. void EDKDBG_free(                       // RETURNS: nothing
  231.     IN ULONG ulLine,                    // line number
  232.     IN LPSTR lpszFile,                  // file name
  233.     IN LPVOID lpv);                     // pointer to memory block
  234.  
  235. //$--EDKDBG_GlobalAlloc---------------------------------------------------------
  236. //  Wrapper for GlobalAlloc().
  237. // -----------------------------------------------------------------------------
  238. HGLOBAL EDKDBG_GlobalAlloc(             // RETURNS: pointer to memory block
  239.     IN ULONG ulLine,                    // line number
  240.     IN LPSTR lpszFile,                  // file name
  241.     IN UINT  fuFlags,                   // allocation flags
  242.     IN DWORD dwSize);                   // size of memory block
  243.  
  244. //$--EDKDBG_GlobalReAlloc-------------------------------------------------------
  245. //  Wrapper for GlobalReAlloc().
  246. // -----------------------------------------------------------------------------
  247. HGLOBAL EDKDBG_GlobalReAlloc(           // RETURNS: pointer to memory block
  248.     IN ULONG ulLine,                    // line number
  249.     IN LPSTR lpszFile,                  // file name
  250.     IN HGLOBAL hglb,                    // pointer to memory block
  251.     IN DWORD cbBytes,                   // new size of memory block
  252.     IN UINT  fuFlags);                  // allocation flags
  253.  
  254. //$--EDKDBG_GlobalFree----------------------------------------------------------
  255. //  Wrapper for GlobalFree().
  256. // -----------------------------------------------------------------------------
  257. HGLOBAL EDKDBG_GlobalFree(              // RETURNS: nothing
  258.     IN ULONG ulLine,                    // line number
  259.     IN LPSTR lpszFile,                  // file name
  260.     IN HGLOBAL hglb);                   // pointer to memory block
  261.  
  262. //$--EDKDBG_LocalAlloc---------------------------------------------------------
  263. //  Wrapper for LocalAlloc().
  264. // -----------------------------------------------------------------------------
  265. HGLOBAL EDKDBG_LocalAlloc(              // RETURNS: pointer to memory block
  266.     IN ULONG ulLine,                    // line number
  267.     IN LPSTR lpszFile,                  // file name
  268.     IN UINT  fuFlags,                   // allocation flags
  269.     IN DWORD dwSize);                   // size of memory block
  270.  
  271. //$--EDKDBG_LocalReAlloc-------------------------------------------------------
  272. //  Wrapper for LocalReAlloc().
  273. // -----------------------------------------------------------------------------
  274. HGLOBAL EDKDBG_LocalReAlloc(            // RETURNS: pointer to memory block
  275.     IN ULONG ulLine,                    // line number
  276.     IN LPSTR lpszFile,                  // file name
  277.     IN HLOCAL hgbl,                     // pointer to memory block
  278.     IN DWORD cbBytes,                   // new size of memory block
  279.     IN UINT  fuFlags);                  // allocation flags
  280.  
  281. //$--EDKDBG_LocalFree----------------------------------------------------------
  282. //  Wrapper for LocalFree().
  283. // -----------------------------------------------------------------------------
  284. HGLOBAL EDKDBG_LocalFree(               // RETURNS: nothing
  285.     IN ULONG ulLine,                    // line number
  286.     IN LPSTR lpszFile,                  // file name
  287.     IN HGLOBAL hgbl);                   // pointer to memory block
  288.  
  289. //$--EDKDBG_HrLog---------------------------------------------------------------
  290. //  Log an HRESULT (and the last Win32 error) to the debug log.
  291. // -----------------------------------------------------------------------------
  292. HRESULT EDKDBG_HrLog(                   // RETURNS: HRESULT
  293.     IN LPSTR lpszFile,                  // file name
  294.     IN ULONG ulLine,                    // line number
  295.     IN HRESULT hr,                      // function return code
  296.     IN DWORD dwLastError);              // last Win32 error
  297.  
  298. //$--EDKDBG_HrFailed------------------------------------------------------------
  299. //  Log an HRESULT (and the last Win32 error) to the debug log.
  300. // -----------------------------------------------------------------------------
  301. BOOL EDKDBG_HrFailed(                   // RETURNS: HRESULT
  302.     IN LPSTR lpszFile,                  // file name
  303.     IN ULONG ulLine,                    // line number
  304.     IN HRESULT hr,                      // function return code
  305.     IN DWORD dwLastError);              // last Win32 error
  306.  
  307. #define _QUOTE(x) # x
  308. #define QUOTE(x) _QUOTE(x)
  309.  
  310. // Use __FILE__LINE__ as a string containing "File.x(line#)" for example:
  311. //     #pragma message( __FILE__LINE__ "Remove this line after testing.")
  312. // The above example will display the file name and line number in the build window
  313. // in such a way as to allow you to double click on it to go to the line.
  314. #define __FILE__LINE__ __FILE__ "(" QUOTE(__LINE__) ") : "
  315.  
  316.  
  317. #define TEST_STRING_PTR(x)        \
  318.     (((x) != NULL) && (!IsBadStringPtr((x), (INFINITE))))
  319. #define TEST_STRINGA_PTR(x)       \
  320.     (((x) != NULL) && (!IsBadStringPtrA(x, (INFINITE))))
  321. #define TEST_STRINGW_PTR(x)       \
  322.     (((x) != NULL) && (!IsBadStringPtrW(x, (INFINITE))))
  323. #define TEST_READ_PTR(x, y)    \
  324.     (((x) != NULL) && (!IsBadReadPtr((x),(y))))
  325. #define TEST_WRITE_PTR(x, y)   \
  326.     (((x) != NULL) && (!IsBadWritePtr((x),(y))))
  327. #define TEST_FUNCTION_PTR(x)   \
  328.     (((x) != NULL) && (!IsBadCodePtr((x))))
  329.  
  330. #define TEST_STRING_PTR_OR_NULL(x)        \
  331.     (((x) == NULL) || (!IsBadStringPtr((x), (INFINITE))))
  332. #define TEST_STRINGA_PTR_OR_NULL(x)        \
  333.     (((x) == NULL) || (!IsBadStringPtrA((x), (INFINITE))))
  334. #define TEST_STRINGW_PTR_OR_NULL(x)        \
  335.     (((x) == NULL) || (!IsBadStringPtrW((x), (INFINITE))))
  336. #define TEST_READ_PTR_OR_NULL(x, y)    \
  337.     (((x) == NULL) || (!IsBadReadPtr((x),(y))))
  338. #define TEST_WRITE_PTR_OR_NULL(x, y)   \
  339.     (((x) == NULL) || (!IsBadWritePtr((x),(y))))
  340. #define TEST_FUNCTION_PTR_OR_NULL(x)   \
  341.     (((x) == NULL) || (!IsBadCodePtr((x))))
  342. #define TEST_IUNKNOWN_PTR(x) \
  343.     (((x) != NULL) && !FBadUnknown((x)))
  344.  
  345. #ifdef DEBUG
  346.  
  347. #define HR_LOG(_hr) EDKDBG_HrLog(__FILE__, __LINE__, (_hr), GetLastError())
  348.  
  349. #ifdef FAILED
  350. #undef FAILED
  351. #endif
  352. #define FAILED(_hr) EDKDBG_HrFailed(__FILE__, __LINE__, (_hr), GetLastError())
  353.  
  354. #ifdef SUCCEEDED
  355. #undef SUCCEEDED
  356. #endif
  357. #define SUCCEEDED(_hr) (!EDKDBG_HrFailed(__FILE__, __LINE__, (_hr), GetLastError()))
  358.  
  359. #ifdef HR_FAILED
  360. #undef HR_FAILED
  361. #endif
  362. #define HR_FAILED(_hr) FAILED(_hr)
  363.  
  364. #ifdef HR_SUCCEEDED
  365. #undef HR_SUCCEEDED
  366. #endif
  367. #define HR_SUCCEEDED(_hr) SUCCEEDED(_hr)
  368.  
  369. #define RETURN(_hr) return(EDKDBG_HrLog(__FILE__, __LINE__, (_hr), GetLastError()))
  370.  
  371. #define DEBUGPUBLIC(x) \
  372.     { _Assert("DEBUG", __FILE__, __LINE__, D_PUBLIC, TRUE, "%s\n", (x)); }
  373.  
  374. #define DEBUGPRIVATE(x) \
  375.     { _Assert("DEBUG", __FILE__, __LINE__, D_PRIVATE, TRUE, "%s\n", (x)); }
  376.  
  377. #define DEBUGACTION(x) \
  378.     { _Assert("DEBUG", __FILE__, __LINE__, D_ACTION, TRUE, "%s\n", (x)); }
  379.  
  380.  
  381. #define MODULE_ERROR(x) \
  382.     { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, FALSE, "%s\n", (x)); }
  383.  
  384. #define MODULE_WARNING(x) \
  385.     { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, FALSE, "%s\n", (x)); }
  386.  
  387. #define MODULE_STATUS(x) \
  388.     { _Assert("ASSERT", __FILE__, __LINE__, D_STATUS, FALSE, "%s\n", (x)); }
  389.  
  390. #define MODULE_ERROR1(x, y) \
  391.     { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, FALSE, (x"\n"), (y)); }
  392.  
  393. #define MODULE_ERROR2(x, y, z) \
  394.     { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, FALSE, (x"\n"), (y), (z)); }
  395.  
  396. #define MODULE_WARNING1(x, y) \
  397.     { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, FALSE, (x"\n"), (y)); }
  398.  
  399. #define MODULE_WARNING2(x, y, z) \
  400.     { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, FALSE, (x"\n"), (y), (z)); }
  401.  
  402. #define MODULE_STATUS1(x, y) \
  403.     { _Assert("ASSERT", __FILE__, __LINE__, D_STATUS, FALSE, (x"\n"), (y)); }
  404.  
  405. #define MODULE_STATUS2(x, y, z) \
  406.     { _Assert("ASSERT", __FILE__, __LINE__, D_STATUS, FALSE, (x"\n"), (y), (z)); }
  407.  
  408.  
  409. #define ASSERTERROR(x, y) \
  410.     { _Assert("ASSERT", __FILE__, __LINE__, D_ERROR, (x), (y"\n")); }
  411.  
  412. #define ASSERTWARNING(x, y) \
  413.     { _Assert("ASSERT", __FILE__, __LINE__, D_WARNING, (x), (y"\n")); }
  414.  
  415. #define ASSERT_STRING_PTR(x, y)     ASSERTERROR(TEST_STRING_PTR(x), y)
  416. #define ASSERT_STRINGA_PTR(x, y)    ASSERTERROR(TEST_STRINGA_PTR(x), y)
  417. #define ASSERT_STRINGW_PTR(x, y)    ASSERTERROR(TEST_STRINGW_PTR(x), y)
  418. #define ASSERT_READ_PTR(x, y, z)    ASSERTERROR(TEST_READ_PTR(x, y), z)
  419. #define ASSERT_WRITE_PTR(x, y, z)   ASSERTERROR(TEST_WRITE_PTR(x, y), z)
  420. #define ASSERT_FUNCTION_PTR(x, y)   ASSERTERROR(TEST_FUNCTION_PTR(x), y)
  421.  
  422. #define ASSERT_IUNKNOWN_PTR(x, y)   ASSERTERROR(TEST_IUNKNOWN_PTR(x), y)
  423.  
  424. #define ASSERT_STRING_PTR_OR_NULL(x, y)   \
  425.     ASSERTERROR(TEST_STRING_PTR_OR_NULL(x), y)
  426. #define ASSERT_STRINGA_PTR_OR_NULL(x, y)  \
  427.     ASSERTERROR(TEST_STRINGA_PTR_OR_NULL(x), y)
  428. #define ASSERT_STRINGW_PTR_OR_NULL(x, y)  \
  429.     ASSERTERROR(TEST_STRINGW_PTR_OR_NULL(x), y)
  430. #define ASSERT_READ_PTR_OR_NULL(x, y, z)  \
  431.     ASSERTERROR(TEST_READ_PTR_OR_NULL(x, y), z)
  432. #define ASSERT_WRITE_PTR_OR_NULL(x, y, z) \
  433.     ASSERTERROR(TEST_WRITE_PTR_OR_NULL(x, y), z)
  434. #define ASSERT_FUNCTION_PTR_OR_NULL(x, y) \
  435.     ASSERTERROR(TEST_FUNCTION_PTR_OR_NULL(x), y)
  436.  
  437. #define OUTPUTDEBUGSTRING(_sz) \
  438.     OutputDebugString("error: " __FILE__ ", " QUOTE(__LINE__) ", " _sz "\n");
  439.  
  440. #else
  441.  
  442. #define HR_LOG(_hr)                         (_hr)
  443.  
  444. #define RETURN(_hr)                         return((_hr))
  445.  
  446. #define DEBUGPUBLIC(x)                      ((void)0)
  447.  
  448. #define DEBUGPRIVATE(x)                     ((void)0)
  449.  
  450. #define DEBUGACTION(x)                      ((void)0)
  451.  
  452.  
  453. #define MODULE_ERROR(x)                     ((void)0)
  454.  
  455. #define MODULE_WARNING(x)                   ((void)0)
  456.  
  457. #define MODULE_STATUS(x)                    ((void)0)
  458.  
  459. #define MODULE_ERROR1(x, y)                 ((void)0)
  460.  
  461. #define MODULE_ERROR2(x, y, z)              ((void)0)
  462.  
  463. #define MODULE_WARNING1(x, y)               ((void)0)
  464.  
  465. #define MODULE_WARNING2(x, y, z)            ((void)0)
  466.  
  467. #define MODULE_STATUS1(x, y)                ((void)0)
  468.  
  469. #define MODULE_STATUS2(x, y, z)             ((void)0)
  470.  
  471.  
  472. #define ASSERTERROR(x, y)                   ((void)0)
  473.  
  474. #define ASSERTWARNING(x, y)                 ((void)0)
  475.  
  476. #define ASSERT_STRING_PTR(x, y)             ((void)0)
  477.  
  478. #define ASSERT_STRINGA_PTR(x, y)            ((void)0)
  479.  
  480. #define ASSERT_STRINGW_PTR(x, y)            ((void)0)
  481.  
  482. #define ASSERT_READ_PTR(x, y, z)            ((void)0)
  483.  
  484. #define ASSERT_WRITE_PTR(x, y, z)           ((void)0)
  485.  
  486. #define ASSERT_FUNCTION_PTR(x, y)           ((void)0)
  487.  
  488. #define ASSERT_IUNKNOWN_PTR(x, y)           ((void)0)
  489.  
  490. #define ASSERT_STRING_PTR_OR_NULL(x, y)     ((void)0)
  491.  
  492. #define ASSERT_STRINGA_PTR_OR_NULL(x, y)    ((void)0)
  493.                                             
  494. #define ASSERT_STRINGW_PTR_OR_NULL(x, y)    ((void)0)
  495.  
  496. #define ASSERT_READ_PTR_OR_NULL(x, y, z)    ((void)0)
  497.  
  498. #define ASSERT_WRITE_PTR_OR_NULL(x, y, z)   ((void)0)
  499.  
  500. #define ASSERT_FUNCTION_PTR_OR_NULL(x, y)   ((void)0)
  501.  
  502. #define OUTPUTDEBUGSTRING(x)                ((void)0)
  503.  
  504. #endif
  505.  
  506. //
  507. // Memory allocation function wrappers
  508. //
  509.  
  510. #ifndef _PRIVATE_MEMORY_H
  511.  
  512. #ifdef DEBUG
  513.  
  514. #define DEBUG_HEAP_CHECK    _DebugHeapCheck(__LINE__,__FILE__)
  515.  
  516. #define DEBUG_DUMP_HEAP     _DebugDumpHeap(__LINE__,__FILE__)
  517.  
  518. #define MAPIAllocateBuffer(x, y)    \
  519.     EDKDBG_MAPIAllocateBuffer(__LINE__,__FILE__,(x),(y))
  520.  
  521. #define MAPIAllocateMore(x, y, z)   \
  522.     EDKDBG_MAPIAllocateMore(__LINE__,__FILE__,(x),(y),(z))
  523.  
  524. #define MAPIFreeBuffer(x)           \
  525.     EDKDBG_MAPIFreeBuffer(__LINE__,__FILE__,(x))
  526.  
  527. #define malloc(x)                   \
  528.     EDKDBG_malloc(__LINE__,__FILE__,(x))
  529.  
  530. #define calloc(x, y)                \
  531.     EDKDBG_calloc(__LINE__,__FILE__,(x),(y))
  532.  
  533. #define realloc(x, y)                \
  534.     EDKDBG_realloc(__LINE__,__FILE__,(x),(y))
  535.  
  536. #define GlobalAlloc(x, y)            \
  537.     EDKDBG_GlobalAlloc(__LINE__,__FILE__,(x),(y))
  538.  
  539. #define GlobalReAlloc(x, y, z)       \
  540.     EDKDBG_GlobalReAlloc(__LINE__,__FILE__,(x),(y),(z))
  541.  
  542. #ifdef GlobalDiscard
  543. #undef GlobalDiscard
  544. #endif
  545. #define GlobalDiscard(x)             \
  546.     EDKDBG_GlobalReAlloc(__LINE__,__FILE__,(x),0,GMEM_MOVEABLE)
  547.  
  548. #define GlobalFree(x)                \
  549.     EDKDBG_GlobalFree(__LINE__,__FILE__,(x))
  550.  
  551. #define LocalAlloc(x, y)            \
  552.     EDKDBG_LocalAlloc(__LINE__,__FILE__,(x),(y))
  553.  
  554. #define LocalReAlloc(x, y, z)       \
  555.     EDKDBG_LocalReAlloc(__LINE__,__FILE__,(x),(y),(z))
  556.  
  557. #ifdef LocalDiscard
  558. #undef LocalDiscard
  559. #endif
  560. #define LocalDiscard(x)             \
  561.     EDKDBG_LocalReAlloc(__LINE__,__FILE__,(x),0,GMEM_MOVEABLE)
  562.  
  563. #define LocalFree(x)                \
  564.     EDKDBG_LocalFree(__LINE__,__FILE__,(x))
  565.  
  566. #ifdef strdup
  567. #undef strdup
  568. #endif
  569. #define strdup(x)                    \
  570.     EDKDBG_strdup(__LINE__,__FILE__,(x))
  571.  
  572. #define _strdup(x)                   \
  573.     EDKDBG_strdup(__LINE__,__FILE__,(x))
  574.  
  575. #define _wcsdup(x)                   \
  576.     EDKDBG_wcsdup(__LINE__,__FILE__,(x))
  577.  
  578. #define free(x)                     \
  579.     EDKDBG_free(__LINE__,__FILE__,(x))
  580.  
  581. #else
  582.  
  583. #define DEBUG_HEAP_CHECK              ((void)0)
  584.  
  585. #define DEBUG_DUMP_HEAP               ((void)0)
  586.  
  587. #endif
  588.  
  589. #endif // _PRIVATE_MEMORY_H
  590.  
  591.  
  592. //------------------------------------------------------------------------------
  593. //
  594. // Inline parameter checking functions
  595. //
  596. //------------------------------------------------------------------------------
  597.  
  598. //$--CHK_main-------------------------------------------------------------------
  599. //  Check the parameters for main() functions.
  600. // -----------------------------------------------------------------------------
  601. __inline static HRESULT CHK_main(        // RETURNS: HRESULT
  602.     IN int argc,                        // number of arguments on command line
  603.     IN char *argv[])                    // array of command line arguments
  604. {
  605.     HRESULT        hr        = NOERROR;
  606.     int            i        = 0;
  607.  
  608.     if (argc < 0)
  609.     {
  610.         hr = HR_LOG(E_INVALIDARG);
  611.         goto cleanup;
  612.     }
  613.  
  614.     for (i = 0; i < argc; i++)
  615.     {
  616.         if (!TEST_STRINGA_PTR(argv[i]))
  617.         {
  618.             hr = HR_LOG(E_INVALIDARG);
  619.             goto cleanup;
  620.         }
  621.     }
  622.  
  623. cleanup:
  624.     return(hr);
  625. }
  626.  
  627.  
  628. #endif // _PRIVATE_EDKDEBUG_H
  629.  
  630. #ifdef __cplusplus
  631. }
  632. #endif
  633.  
  634. #endif
  635.