windows-xp/Source/XPSP1/NT/admin/activec/designer/vb98ctls/framewrk/macros.cpp

//=--------------------------------------------------------------------------=
// Macros.Cpp
//=--------------------------------------------------------------------------=
// Copyright  1997  Microsoft Corporation.  All Rights Reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
// PARTICULAR PURPOSE.
//=--------------------------------------------------------------------------=
// Handy macros like the ones we use in the VB code base.
//=--------------------------------------------------------------------------=
#include "pch.h"

#ifdef DEBUG
#include <winuser.h>

// for ASSERT and FAIL
//
SZTHISFILE


//=--------------------------------------------------------------------------=
//  Debug control switches
//=--------------------------------------------------------------------------=
DEFINE_SWITCH(fTraceCtlAllocs);	//  Trace all Heap allocations and frees
				//  fOutputFile should also be on with this switch
DEFINE_SWITCH(fOutputFile);	//  Logs all debug info in file: 
				//    %CurrentDir%\ctldebug.log
DEFINE_SWITCH(fNoLeakAsserts);	//  No Heap memory leak asserts are displayed 
				//    when turned on.



//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//                            !DEBUGGING HEAP MEMORY LEAKS!
// To debug a leak you need to figure out where and when the allocation was made.
// The top of the assert dialog will give you the OCX/DLL causing the leak.
// Goto Project/Build...Settings.
// On the Debug tab, select "additional DLLs"
// Locate and select the OCX/DLL causing the leak.
// Put a breakpoint on the noted line below. 
// Goto Edit...Breakpoints.
// Select the new breakpoint.
// Press 'Condition'
// In the 'Enter number of times to skip before breaking' put the value of nAlloc-1.
// (if the leak was nAlloc=267 then you want to skip the breapoint 266 times, enter 266)
//
// WARNING: Each control (OCX/DLL) will have its own instance of the framewrk, and thus
//	    its own instance of the memory leak implementaion.  Adding a breakpoint 
//	    anywhere in the framewrk will actually add multiple breakpoints - one for 
//	    each control.
//          Go back to Edit...Breakpoints.
//	    Deselect or remove the breakpoints for the OCX's/DLL's not causing leaks
//
// Run your scenario.
// When you hit this breakpoint verify that pvAddress and nByteCount are correct and then
// look down the callstack to see where the allocation was made.
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
void PutBreakPointHere(void * pvAddress, ULONG nByteCount, ULONG  nAlloc, char * szFile, ULONG uLine)
{
  pvAddress=pvAddress;  nAlloc=nAlloc;  nByteCount=nByteCount;
  szFile=szFile;
  uLine=uLine;
  HINSTANCE hInstance = g_hInstance;  //  hInstance of the OCX/DLL calling this breakpoint
  int PutBreakPointOnThisLine = 1;                              // <--- breakpoint here.
} //  PutBreakPointHere



//=--------------------------------------------------------------------------=
//
//  Debug Heap Memory Leak implementations
//

class CAddressNode
{
public:
  void * m_pv;		    //	Address of memory block allocated
  ULONG  m_cb;		    //	Size of allocation in BYTES
  ULONG  m_cAlloc;	    //	Allocation pass count.  
  LPSZ   m_szFile;	    //	Source file where the allocation was made
  ULONG  m_uLine;	    //	Source line number where the allocation was made
  CAddressNode * m_pnNext;  //	Nodes are stored in a linked list

  void * operator new(size_t cb);
  void operator delete(void * pv);

  //  We maintain a freelist to speed up allocation of AddressNodes.
  static CAddressNode * m_pnFreeList;
};


CAddressNode *	m_rInstTable[NUM_INST_TABLE_ENTRIES];  // Hashing table of all instances of 
						       // mem alloc

CAddressNode *	m_pnEnumNode;	      //  Next node for enumerator to return
UINT		m_uEnumIndex;	      //  Current index into m_rInstTable for enumerator
static ULONG	m_cGlobalPassCount;   //  Pass count of allocation.  Common to all heaps    

ULONG m_cCurNumAllocs;		  // Current number of allocations
ULONG m_cNumAllocs;		  // Total number of allocations ever done.
ULONG m_cCurNumBytesAllocated;	  // Current number of bytes allocated.
ULONG m_cNumBytesAllocated;	  // Total bytes allocated.
ULONG m_HWAllocs;		  // High water allocations.
ULONG m_HWBytes;		  // High water bytes.
static ULONG m_OverallCurAlloc;   // These are overall statistics to since we
static ULONG m_OverallCurBytes;   // wouldn't mind the overall high water.
static ULONG m_OverallHWAlloc;
static ULONG m_OverallHWBytes;


//  Forward declarations
VOID AddInst(VOID * pv, DWORD dwBytes, LPSZ szFile, UINT uLine);
VOID DebugInst(ULONG cb);
VOID AnalyzeInst(LPVOID pv);
VOID DumpInst(CAddressNode * pn, LPTSTR lpTypeofAlloc);
LPSTR DumpInstTable(LPSTR lpLeak);
VOID DeleteInst(LPVOID pv);
VOID VerifyHeaderTrailer(CAddressNode * pn);
VOID CheckForLeaks(VOID);
VOID HeapCheck(VOID);
VOID OutputToFile(LPSTR szOutput);
CAddressNode * FindInst(LPVOID pv);
CAddressNode * EnumReset();
CAddressNode * EnumNext();


//  Initialize a header and trailer for all memory to be allocated.
//  Use 8 bytes so it is also compatible with RISC machines.
char * g_szHeader  = "HEADHEAD";
char * g_szTrailer = "END!END!";

#define HEADERSIZE 8	    // # of bytes of block header
			    // 0 ==> no block header signature
#define TRAILERSIZE 8	    // # of bytes of block trailer
			    // 0 ==> no block trailer signature



//=--------------------------------------------------------------------------=
//  CtlHeapAllocImpl:
//	Debug wrapper for HeapAlloc to track memory leaks:
//=--------------------------------------------------------------------------=
LPVOID CtlHeapAllocImpl(
			HANDLE g_hHeap, 
			DWORD dwFlags, 
			DWORD dwBytesRequested, 
			LPSTR lpszFile, 
			UINT line
		       )
{
  LPVOID lpvRet;
  DWORD dwBytes;
  LPTSTR lpTypeofAlloc = "HeapAlloc   ";
  

  //  If someone tries to allocate memory before PROCCESS_ATTATCH (such as in a 
  //  global constructor), do not track it because neither our heap nor our 
  //  hInstance have been initialized yet.
  //
  if (!g_fInitCrit)
    {
    g_flagConstructorAlloc = TRUE;
    return HeapAlloc(g_hHeap, dwFlags, dwBytesRequested);
    }


  //  Increase size to make space for header and trailer signatures
  dwBytes = dwBytesRequested + HEADERSIZE + TRAILERSIZE;

  //  Allocate memory
  lpvRet = HeapAlloc(g_hHeap, dwFlags, dwBytes);
  if (lpvRet)
    {
    //	Initialize memory (non-zero)
    if (!(dwFlags & HEAP_ZERO_MEMORY))
      memset(lpvRet, 0xAF, dwBytes);

    //	Add instance to hash table
    AddInst(lpvRet, dwBytesRequested, lpszFile, line);

    //	Trace allocations if switch is on
    if (FSWITCH(fTraceCtlAllocs))
      {
      CAddressNode *pn = FindInst(lpvRet);
      DumpInst(pn, lpTypeofAlloc);
      }

    //	Advance pointer past header signature.
    lpvRet = (LPVOID) ((char *)lpvRet + HEADERSIZE);
    }
  return lpvRet;
} //  CtlHeapAllocImpl



//=--------------------------------------------------------------------------=
// CtlHeapReAllocImpl:
//   
//=--------------------------------------------------------------------------=
LPVOID CtlHeapReAllocImpl(
			  HANDLE g_hHeap, 
			  DWORD dwFlags, 
			  LPVOID lpvMem, 
			  DWORD dwBytesRequested, 
			  LPSTR lpszFile, 
			  UINT line
			 )
{
  LPVOID lpvRet;
  CAddressNode * pn;
  int byte;
  DWORD cbOffset, dwBytes;
  LPTSTR lpTypeofAlloc = "HeapReAlloc ";

  //  Move pointer to beginning of header
  lpvMem = (LPVOID)((char *)lpvMem - HEADERSIZE);

  //  Find instance in hash table
  pn = FindInst(lpvMem);
  if (!pn)
    {
    FAIL("CtlHeapReAllocImpl - could not find lpvMem in the instance table.  See debug \
          output for more info.");
    AnalyzeInst(lpvMem);
    return 0;
    }

  //  Increase size to make space for header and trailer signatures
  dwBytes = dwBytesRequested + HEADERSIZE + TRAILERSIZE;
  lpvRet = HeapReAlloc(g_hHeap, dwFlags, lpvMem, dwBytes);
  if (lpvRet)
    {
    //	If the reallocation grew, we must intialize new memory
    if (dwBytesRequested > pn->m_cb)
      {
      if (dwFlags & HEAP_ZERO_MEMORY)
        byte = 0x0;
      else
        byte = 0xAF;

      //  Get the byte offset of trailer in the old allocation
      cbOffset = pn->m_cb + HEADERSIZE;
      memset((char *)lpvRet + cbOffset, byte, dwBytes - cbOffset);
      }
    //	Update hash table
    EnterCriticalSection(&g_csHeap);
    DeleteInst(lpvMem);
    AddInst(lpvRet, dwBytesRequested, lpszFile, line);
    LeaveCriticalSection(&g_csHeap); 

    //	Trace Allocations if switch is on
    if (FSWITCH(fTraceCtlAllocs))
      {
      CAddressNode *pn = FindInst(lpvRet);
      DumpInst(pn, lpTypeofAlloc);
      }

    //	Advance pointer past header signature.
    lpvRet = (LPVOID)((char *)lpvRet + HEADERSIZE);
    }
  return lpvRet;
} //  CtlHeapReAllocImpl

			       

//=--------------------------------------------------------------------------=
//  CtlHeapFreeImpl:
//	Debug wrapper for HeapFree
//=--------------------------------------------------------------------------=
BOOL CtlHeapFreeImpl(
		     HANDLE g_hHeap, 
		     DWORD dwFlags,
		     LPVOID lpvMem
		    )
{
  BOOL fRet = FALSE;
  CAddressNode * pn;
  LPTSTR lpTypeofAlloc = "HeapFree    ";


  //  If someone tries to de-allocate memory after PROCCESS_DETATCH (such as in a 
  //  global destructor), Re-initialize critical section and free memory.
  //
  if (!g_fInitCrit)
    InitializeCriticalSection(&g_csHeap);
	

  //  Move pointer to beginning of header
  lpvMem = (LPVOID) ((char *)lpvMem - HEADERSIZE);

  //  Find the instance in the hash table
  pn = FindInst(lpvMem);
  if (pn)
    {
    //	Verify the memory has not been overwritten 
    VerifyHeaderTrailer(pn);

    //	Trace allocations if switch is on
    if (FSWITCH(fTraceCtlAllocs))
      {
      CAddressNode *pn = FindInst(lpvMem);
      DumpInst(pn, lpTypeofAlloc);
      }

    //	Free memory  -- NOTE: WinNT will set free memory to 0xEEFEEEFE which is "����"
    fRet = HeapFree(g_hHeap, 0, lpvMem);
    if (!fRet)
      FAIL("CtlHeapFreeImpl - lpvMem was found to be allocated in the heap passed in \
	    but HeapFree() failed.  Maybe the pointer was already freed.");
    }

  //  Remove instance from hash table
  if (fRet)
    DeleteInst(lpvMem);  

  //  Make sure this memory wasn't allocated in a global constructor
  else if (!g_flagConstructorAlloc)
    {
    FAIL("CtlHeapFreeImpl - could not find lpvMem in the instance table.  See debug \
          output for more info.");
    AnalyzeInst(lpvMem);
    }
  else
    fRet = TRUE;
  
  //  If called after PROCESS_DETATCH delete critical section and Check for leaks again
  //  NOTE:  Only the LAST Assert will have the exact leak information.  All previous
  //	     Asserts will not take into account a HeapFree which occurs after PROCESS_DETACH.
  //	     This only occurs in controls using global static destructors.
  if (!g_fInitCrit)
    {
    CheckForLeaks();
    DeleteCriticalSection(&g_csHeap);
    }

  return fRet;
} //  CtlHeapFreeImpl



//=--------------------------------------------------------------------------=
//  CheckForLeaks:
//    We are calling PROCESS_DETATCH so check if hash table is empty.  If not
//    dump info on memory that has been leaked.
//=--------------------------------------------------------------------------=
VOID CheckForLeaks(VOID)
{
  CAddressNode * pn = EnumReset();
  BOOL IsEmpty = (pn == NULL);	  //  FALSE if there are leaks

  //  First check for memory trashing of any leaked memory
  HeapCheck();
  
  if (!IsEmpty)
    {

    //	First find out which OCX/DLL is leaking
    TCHAR lpCtlName[128];
    DWORD nSize = 128;
    DWORD fValidPath;
    fValidPath = GetModuleFileName(g_hInstance, (LPTSTR)lpCtlName, nSize);

    LPSTR lpLeaks;
    // Allocate some memory to hold the data but use GlobalAlloc since we
    // don't want to use the vb memory stuff since it will muck things up.
    lpLeaks = (LPSTR)GlobalLock(GlobalAlloc(GMEM_MOVEABLE,128));

    lstrcpy(lpLeaks, lpCtlName);
    lstrcat(lpLeaks, " has leaked memory.\nUse PutBreakPointHere() in macros.cpp to debug.\r\n");

    //  Collect all leak info
    lpLeaks = DumpInstTable(lpLeaks);
    
    //  Dump output to file if "fOutputFile" switch is on
    if (FSWITCH(fOutputFile))
      OutputToFile(lpLeaks);

    //  Dump output to an assert as long as "fNoLeakAsserts" is off
    else if (!FSWITCH(fNoLeakAsserts))
      {
      //  Truncate output so it fits into DisplayAssert (512 Max)
      if (lstrlen(lpLeaks) > 500)
	{
	lstrcpyn(lpLeaks, lpLeaks, 500);
	lstrcat(lpLeaks, "\nMore...");
	}
      DisplayAssert(lpLeaks, "FAIL", NULL, 0);
      }

    //	Release memory used to store leak info
    GlobalUnlock((HGLOBAL)GlobalHandle(lpLeaks)), 
	      (BOOL)GlobalFree((HGLOBAL)GlobalHandle(lpLeaks));

    }
  return;
} //  CheckForLeaks



//=--------------------------------------------------------------------------=
//  AddInst:
//    A heap allocation occured so here we add the allocation information to 
//    the instance table.  To debug memory leaks where you need to use pass 
//    counts, set a passcount breakpoint in this function using the passcount 
//    value given in the debug output.
//=--------------------------------------------------------------------------=
VOID AddInst(
	     VOID * pv, 
	     DWORD dwBytes, 
	     LPSZ szFile, 
	     UINT uLine
	    )
{
  UINT uHash;
  CAddressNode * pn = new CAddressNode();
  ASSERT(pn,"");
  
  EnterCriticalSection(&g_csHeap);

  m_cGlobalPassCount++;

  pn->m_pv = pv;                        //  Memory address of allocation
  pn->m_cb = dwBytes;                   //  Bytes requested to be allocated
  pn->m_cAlloc = m_cGlobalPassCount;    //  This is the pass count value in debug output.
  pn->m_szFile = szFile;                //  Source file the allocation call was made
  pn->m_uLine = uLine;                  //  Line number in source file.

  PutBreakPointHere(pv, dwBytes, m_cGlobalPassCount, szFile, uLine);

  //  Add instance to proper position in table
  uHash = HashInst(pv);
  pn->m_pnNext = m_rInstTable[uHash];
  m_rInstTable[uHash] = pn;

  //  Copy header and trailer signatures.
  memcpy((char *)pv, g_szHeader, HEADERSIZE);
  memcpy((char *)pv + HEADERSIZE + dwBytes, g_szTrailer, TRAILERSIZE);

  LeaveCriticalSection(&g_csHeap);

  //  Track extra memory debug info
  DebugInst( dwBytes );
} //  AddInst



//=--------------------------------------------------------------------------=
//  DebugInst:
//    Updates the memory debug information
//=--------------------------------------------------------------------------=
VOID DebugInst(
	       ULONG cb
	      )
{
  EnterCriticalSection(&g_csHeap);

  ++m_cCurNumAllocs;
  ++m_cNumAllocs;
  ++m_OverallCurAlloc;
  m_cCurNumBytesAllocated+=cb;
  m_cNumBytesAllocated+=cb;
  m_OverallCurBytes+=cb;

  m_HWAllocs = (m_HWAllocs < m_cCurNumAllocs) ? m_cCurNumAllocs : m_HWAllocs;
  m_HWBytes = (m_HWBytes < m_cCurNumBytesAllocated) ? m_cCurNumBytesAllocated : m_HWBytes;
  m_OverallHWAlloc = (m_OverallHWAlloc < m_OverallCurAlloc) 
						    ? m_OverallCurAlloc : m_OverallHWAlloc;
  m_OverallHWBytes = (m_OverallHWBytes < m_OverallCurBytes) 
						    ? m_OverallCurBytes : m_OverallHWBytes;

  LeaveCriticalSection(&g_csHeap);

} //  DebugInst



//=--------------------------------------------------------------------------=
//  FindInst:
//    Give a pointer to an allocation, return a pointer to the debug 
//    allocation information.
//=--------------------------------------------------------------------------=
CAddressNode * FindInst(
			LPVOID pv
		       )
{
  CAddressNode * pn;

  EnterCriticalSection(&g_csHeap);

  pn = m_rInstTable[HashInst(pv)];
  while (pn && pn->m_pv != pv)
    pn = pn->m_pnNext;

  LeaveCriticalSection(&g_csHeap);
  return pn;

} //  FindInst



//=--------------------------------------------------------------------------=
//  AnalyzeInst:
//    Given a pointer try determine if it is a valid Read and Write pointer
//    and if it was allocated.
//=--------------------------------------------------------------------------=
VOID AnalyzeInst(
		 LPVOID pv
		)
{
  LPTSTR lpTypeofAlloc = "Bad lpvMem ";
  CAddressNode * pn = NULL;

  //  Either we have a bad pointer or the pointer does not point to any
  //  known heap allocations.   Here we check if it points to readable or 
  //  writable memory.
  BOOL fBadPointer = (IsBadReadPtr(pv, 4) || IsBadWritePtr(pv, 4));
    
  // Report what we know about the memory address
  if (fBadPointer)
    DebugPrintf("AnalyzeInst found that pointer pv=0x%lX is not writable\n\r" \
		"or readable.  The allocation is either outside the addressable range\n\r" \
		"for this operating system or the allocation was already freed.\n\r",pv);
  else
    DebugPrintf("AnalyzeInst found that pointer pv=0x%lX is readable and writable,\n\r"  \
		"so the allocation was made without being added to instance table\n\r" \
		"(prior to PROCESS_ATTATCH), or the memory was already freed.\n\r",pv);
    
} //  AnanlyzeInst



//=--------------------------------------------------------------------------=
//  DumpInst:
//    Dump instance information out to an assert window.
//=--------------------------------------------------------------------------=
VOID DumpInst(
	      CAddressNode * pn,
	      LPTSTR lpTypeofAlloc
	     )
{  
  char szOutput[255];

  //  Format output
  wsprintf(szOutput, "%s: %s(%u) Address=0x%lx  nAlloc=%ld  Bytes=%ld\r\n", lpTypeofAlloc,
	   pn->m_szFile, pn->m_uLine, (ULONG)pn->m_pv, (ULONG)pn->m_cAlloc, (ULONG)pn->m_cb);
  
  //  Dump output to file if switch is turned on
  if (FSWITCH(fOutputFile))
    OutputToFile(szOutput);
  else if (FSWITCH(fNoLeakAsserts))
    DebugPrintf(szOutput);
      
  //  Else display output in assert
  else
    DisplayAssert(szOutput, "FAIL", _szThisFile, __LINE__);;

} //  DumpInst



//=--------------------------------------------------------------------------=
//  DumpInstTable:
//    Memory leak has been detected so dump the entire instance table.
//=--------------------------------------------------------------------------=
LPSTR DumpInstTable(
		    LPSTR lpLeak
		   )
{
  CAddressNode * pn = EnumReset();
  DWORD sizeoflpLeak;
  LPSTR lpTemp;

  EnterCriticalSection(&g_csHeap);

  DebugPrintf(lpLeak);

  while (pn)
    {
    //	Format the leak info
    char szOut[250] = {NULL};
    wsprintf(szOut, "\t%s(%u) Address=0x%lx  nAlloc=%ld  Bytes=%ld\r\n", pn->m_szFile,
           pn->m_uLine, (ULONG)pn->m_pv, (ULONG)pn->m_cAlloc, (ULONG)pn->m_cb);

    DebugPrintf(szOut);
    
    //  Convert lpLeak to a handle and get its current allocation size
    sizeoflpLeak = GlobalSize(GlobalHandle(lpLeak));

    //	Reallocate memory to make space for more leak info
    lpTemp = (LPSTR) (GlobalUnlock((HGLOBAL)GlobalHandle(lpLeak)), 
	      GlobalLock(GlobalReAlloc((HGLOBAL)GlobalHandle(lpLeak), 
	      sizeoflpLeak + lstrlen(szOut) + 1, GMEM_MOVEABLE)));

    //	Add new leak info to lpLeak
    if(lpTemp)
      {
      lpLeak = lpTemp;
      lstrcat(lpLeak, szOut);
      }

    //	Get the next leak
    pn = EnumNext();
    }
  LeaveCriticalSection(&g_csHeap);
  return lpLeak;

} //  DumpInstTable



//=--------------------------------------------------------------------------=
//  DeleteInst:
//    A heap allocation got free or was reallocated so remove the
//    information from the instance table and check for memory trashing.
//=--------------------------------------------------------------------------=
VOID DeleteInst(
		LPVOID pv
	       )
{
  CAddressNode ** ppn, * pnDead;
  ppn = &m_rInstTable[HashInst(pv)];

  EnterCriticalSection(&g_csHeap);
  
  //  Find allocation instance 
  while (*ppn != NULL)
    {
    if ((*ppn)->m_pv == pv)
      {
      pnDead = *ppn;
      *ppn = (*ppn)->m_pnNext;

      //  Correct memory debug info
      --m_cCurNumAllocs;
      m_cCurNumBytesAllocated -= pnDead->m_cb;
      --m_OverallCurAlloc;
      m_OverallCurBytes -= pnDead->m_cb;

      //  Remove instance
      delete pnDead;
		  LeaveCriticalSection(&g_csHeap);
      return;
      }	//  if

    ppn = &((*ppn)->m_pnNext);
    } //  while

    FAIL("DeleteInst - memory instance not found");
} //  DeleteInst



//=--------------------------------------------------------------------------=
//  VerifyHeaderTrailer:
//    Inspect allocation for header and trailer signature overwrites
//=--------------------------------------------------------------------------=
VOID VerifyHeaderTrailer(
			 CAddressNode * pn
			)
{
  LPTSTR lpTypeofAlloc = "Memory trashed ";

  //Verify the header
  if (memcmp((char *)pn->m_pv, g_szHeader, HEADERSIZE) != 0)
    {
    FAIL("Heap block header has been trashed.");
    DebugPrintf("Heap block header trashed.");
    DebugPrintf("\r\n");
    DumpInst(pn, lpTypeofAlloc);
    }

  //Verify the trailer
  if (memcmp((char *)pn->m_pv + pn->m_cb + HEADERSIZE, g_szTrailer, TRAILERSIZE) != 0)
    {
    FAIL("Heap block trailer has been trashed.");
    DebugPrintf("Heap block trailer trashed.");
    DebugPrintf("\r\n");
    DumpInst(pn, lpTypeofAlloc);
    }
  return;

} //  VerifyHeaderTrailer




//=--------------------------------------------------------------------------=
//  HeapCheck:
//    Inspect all of the allocations for header and trailer signature 
//    overwrites.
//=--------------------------------------------------------------------------=
VOID HeapCheck(VOID)
{
  ASSERT(HeapValidate(g_hHeap, 0, NULL) != 0, "OS Says heap is corrupt");

  CAddressNode * pn = EnumReset();
  while (pn)
    {
    VerifyHeaderTrailer(pn);
    pn = EnumNext();
    }
  return;
} //  HeapCheck



//=-------------------------------------------------------------------------=
//  For use with CAddresssNode
//=-------------------------------------------------------------------------=
#define MEM_cAddressNodes 128		  //  Nodes are block allocated
#define UNUSED(var)	  ((var) = (var)) //  Used to avoid warnings

//  The free list is common
CAddressNode * CAddressNode::m_pnFreeList = NULL;

//=--------------------------------------------------------------------------=
//  CAddressNode::operator new:
//    Returns a pointer to an allocated address node. If there are none on 
//    the free list then we allocate a block of address nodes, chain them 
//    together and add them to the free list.   These nodes are never 
//    actually freed so it is ok to allocate them in blocks.
//=--------------------------------------------------------------------------=
void * CAddressNode::operator new(
				  size_t cb
				 )
{
  CAddressNode * pn;
  UNUSED(cb);

  EnterCriticalSection(&g_csHeap); // needed for static m_pnFreeList

  if (m_pnFreeList == NULL)
    {
    UINT cbSize = sizeof(CAddressNode) * MEM_cAddressNodes;  //allocate a block
    pn = (CAddressNode *) HeapAlloc(g_hHeap, 0, cbSize);
    //chain all except the first node together.  the first node
    //is the one returned
    for (int i = 1; i < MEM_cAddressNodes - 1; ++i)
      pn[i].m_pnNext = &pn[i+1];
    pn[MEM_cAddressNodes - 1].m_pnNext = NULL;
    m_pnFreeList = &pn[1];
    }
  else
    {
    pn = m_pnFreeList;
    m_pnFreeList = pn->m_pnNext;
    }

  LeaveCriticalSection(&g_csHeap);
  return pn;
} //  CAddressNode::operator new



//=--------------------------------------------------------------------------=
//  CAddressNode::operator delete
//    Return the address node to the free list.  We never actually free
//    the node since nodes are allocated in blocks.
//=--------------------------------------------------------------------------=
void CAddressNode::operator delete(
				   void * pv
				  )
{
  EnterCriticalSection(&g_csHeap); // needed for static m_pnFreeList

  CAddressNode * pn = (CAddressNode *) pv;
  pn->m_pnNext = m_pnFreeList;
  m_pnFreeList = pn;

  LeaveCriticalSection(&g_csHeap);
} //  CAddressNode::operator delete



//=--------------------------------------------------------------------------=
//  EnumReset:
//    Reset the enumerator and return the first node.  NULL if empty.
//=--------------------------------------------------------------------------=
CAddressNode * EnumReset()
{
  m_pnEnumNode = NULL;
  for (m_uEnumIndex = 0; m_uEnumIndex < NUM_INST_TABLE_ENTRIES; ++m_uEnumIndex)
    {
    m_pnEnumNode = m_rInstTable[m_uEnumIndex];
    if (m_pnEnumNode != NULL)
      return m_pnEnumNode;
    }
  return NULL;  //Instance table is empty
} //  EnumReset



//=--------------------------------------------------------------------------=
//  EnumNext:
//    Return the next node in the enumeration.  m_pnEnumNode points to the last
//    node returned.  It is NULL if no more left.
//=--------------------------------------------------------------------------=
CAddressNode * EnumNext()
{
  ASSERT(m_uEnumIndex <= NUM_INST_TABLE_ENTRIES, "");

  if (m_pnEnumNode == NULL)
    return NULL;    //end of enumeration

  m_pnEnumNode = m_pnEnumNode->m_pnNext;
  if (m_pnEnumNode == NULL)
    {
    //at end of this linked list so search for next list
    m_uEnumIndex++;
    while (m_uEnumIndex < NUM_INST_TABLE_ENTRIES && m_rInstTable[m_uEnumIndex] == NULL)
      m_uEnumIndex++;
    if (m_uEnumIndex < NUM_INST_TABLE_ENTRIES)
      m_pnEnumNode = m_rInstTable[m_uEnumIndex];
    }
  return m_pnEnumNode;
} //  EnumNext



//=---------------------------------------------------------------------------=
//  OutputToFile:
//    Dumps output to file "ctldebug.log"
//=---------------------------------------------------------------------------=
VOID OutputToFile
(
    LPSTR szOutput
)
{
    DWORD nPathSize;
    DWORD nDirPathSize = 128;
    TCHAR lpFilePath[128];
    LPCTSTR lpFileName = "\\CtlDebug.log";
    HANDLE hFile;
    BOOL fWritten, fClosed = FALSE;
    DWORD nBytesWritten;

    //	Create path to output file
    nPathSize = GetCurrentDirectory(nDirPathSize, (LPTSTR)lpFilePath);
    if (nPathSize == 0)
      FAIL("Unable to get current directory...");
    lstrcat(lpFilePath, lpFileName);

    //	Open and write to file
    hFile = CreateFile((LPCTSTR)lpFilePath, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, 
			                                FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD SetPtr = SetFilePointer(hFile, NULL, NULL, FILE_END);
    fWritten = WriteFile(hFile, (LPCVOID)szOutput, (DWORD)strlen(szOutput), 
			                                        &nBytesWritten, NULL); 
    if (!fWritten)
      FAIL("Unable to write output to file...");

    //	Close file handle
    fClosed = CloseHandle(hFile);
    if (!fClosed)
      FAIL("Unable to close output file...");

} //  OutputToFile


//
//  End of Debug Memory Leak implemntation
//
//=--------------------------------------------------------------------------=


//=--------------------------------------------------------------------------=
// This routine outputs through DebugPrintf some information if the 
// given hr fails to succeed.  This is used by RRETURN to output where
// a function that returns a failing error code.
//=--------------------------------------------------------------------------=
HRESULT HrDebugTraceReturn
(
  HRESULT hr,
  char *pszFile,
  int iLine
)
{
  // We only output information if the hr fails.
  if (FAILED(hr))
    {
    char szMessageError[128];
    szMessageError[0] = '\0';
    BOOL fMessage;

#if RBY_MAC
    fMessage = FALSE; // FormatMessage not available on the mac
#else
    // Get the message from the system
    // CONSIDER, t-tshort 10/95: Getting some messages from us instead 
    //                           of the system?
    fMessage = FormatMessage(FORMAT_MESSAGE_MAX_WIDTH_MASK
			      | FORMAT_MESSAGE_FROM_SYSTEM,
			     NULL, hr,
			     MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),
			     szMessageError, sizeof(szMessageError), NULL);
#endif

    // Erps didn't get a message.
    if(!fMessage)
      lstrcpy(szMessageError,"Unknown Hresult");

    // Output the information that we want.
    DebugPrintf("FAILED RETURN: %s(%d) : 0x%08lx, %s\n", 
                pszFile, iLine, hr, szMessageError);
    }

  return hr;
}

//---------------------------------------------------------------------
// The following is a common output formatting buffer shared by several
// of the following debug routines.
//---------------------------------------------------------------------
char s_rgchOutput[2048]; // pretty big...


//=--------------------------------------------------------------------------=
// Emit debugging information
//=--------------------------------------------------------------------------=
void _DebugOutput(char* pszOutput)
{
  OutputDebugString(pszOutput);
}


//=--------------------------------------------------------------------------=
// Emit a formatted debugging string to the location specified in
// the debug options dialog.
//=--------------------------------------------------------------------------=
void _DebugPrintf(char* pszFmt, ...) 
{
  va_list  args;

  va_start(args, pszFmt);
  wvsprintf(s_rgchOutput, pszFmt, args);
  va_end(args);

  // sqwak if we overrun the formatting buffer!
  ASSERT(strlen(s_rgchOutput) < sizeof(s_rgchOutput), "");

  _DebugOutput(s_rgchOutput);
}

//=--------------------------------------------------------------------------=
// Conditional form of DebugPrintf
//=--------------------------------------------------------------------------=
void _DebugPrintIf(BOOL fPrint, char* pszFmt, ...)
{
  va_list  args;

  if (!fPrint)
    return;

  va_start(args, pszFmt);
  wvsprintf(s_rgchOutput, pszFmt, args);
  va_end(args);

  // sqwak if we overrun the formatting buffer!
  ASSERT(strlen(s_rgchOutput) < sizeof(s_rgchOutput), "");

  _DebugOutput(s_rgchOutput);
}


#endif // DEBUG