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