CWE-ou-minkata/Sources/Plasma/CoreLib/hsMemory.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#if HS_BUILD_FOR_MAC
	#include <Memory.h>
#else
	#include <string.h>
#endif

#include "hsMemory.h"
#include "hsExceptions.h"

#define DO_MEMORY_REPORTS 		// dumps memory reports upon start up of engine

///////////////////////////////////////////////////////////////////////////////////////////

#if HS_BUILD_FOR_MAC
	void HSMemory::BlockMove(const void* src, void* dst, UInt32 length)
	{
		::BlockMoveData(src, dst, length);
	}
#else
	void HSMemory::BlockMove(const void* src, void* dst, UInt32 length)
	{
		memmove(dst, src, length);
	}
#endif

hsBool HSMemory::EqualBlocks(const void* block1, const void* block2, UInt32 length)
{
	const Byte*	byte1 = (Byte*)block1;
	const Byte*	byte2 = (Byte*)block2;

	while (length--)
		if (*byte1++ != *byte2++)
			return false;
	return true;
}

void* HSMemory::New(UInt32 size)
{
	return TRACKED_NEW UInt32[(size + 3) >> 2];
}

void HSMemory::Delete(void* block)
{
	delete[] (UInt32*)block;
}

void* HSMemory::Copy(UInt32 length, const void* source)
{
	void* destination = HSMemory::New(length);

	HSMemory::BlockMove(source, destination, length);
	return destination;
}

void HSMemory::Clear(void* m, UInt32 byteLen)
{
	UInt8*	mem = (UInt8*)m;
	UInt8*	memStop = mem + byteLen;

	if (byteLen > 8)
	{	while (UInt32(mem) & 3)
			*mem++ = 0;
		
		UInt32*	mem32 = (UInt32*)mem;
		UInt32*	mem32Stop = (UInt32*)(UInt32(memStop) & ~3);
		do {
			*mem32++ = 0;
		} while (mem32 < mem32Stop);
		
		mem = (UInt8*)mem32;
		// fall through to finish any remaining bytes (0..3)
	}
	while (mem < memStop)
		*mem++ = 0;

	hsAssert(mem == memStop, "oops");
}

//////////////////////////////////////////////////////////////////////////////////////

#if 0
template <class T> T* hsSoftNew(T*& obj)
{
	try {
		obj = TRACKED_NEW T;
	}
	catch (...) {
		obj = nil;
	}
	return obj;
}

inline template <class T> T* hsSoftNew(T*& obj, unsigned count)
{
	try {
		obj = TRACKED_NEW T[count];
	}
	catch (...) {
		obj = nil;
	}
	return obj;
}
#endif

void* HSMemory::SoftNew(UInt32 size)
{
	UInt32*	p;

	hsTry {
		p = TRACKED_NEW UInt32[(size + 3) >> 2];
	} hsCatch(...) {
		p = nil;
	}
	return p;
}

//////////////////////////////////////////////////////////////////////////////////////

struct hsPrivateChunk {
	hsPrivateChunk*	fNext;
	char*			fAvailableAddr;
	UInt32			fAvailableSize;

	hsDebugCode(UInt32	fSize;)
	hsDebugCode(UInt32	fCount;)

	static hsPrivateChunk* NewPrivateChunk(hsPrivateChunk* next, UInt32 chunkSize);
};

hsPrivateChunk* hsPrivateChunk::NewPrivateChunk(hsPrivateChunk* next, UInt32 chunkSize)
{
	hsPrivateChunk*	chunk = (hsPrivateChunk*)HSMemory::New(sizeof(hsPrivateChunk) + chunkSize);

	chunk->fNext			= next;
	chunk->fAvailableAddr	= (char*)chunk + sizeof(hsPrivateChunk);
	chunk->fAvailableSize	= chunkSize;
	hsDebugCode(chunk->fSize = chunkSize;)
	hsDebugCode(chunk->fCount = 0;)

	return chunk;
}

hsChunkAllocator::hsChunkAllocator(UInt32 chunkSize) : fChunkSize(chunkSize), fChunk(nil)
{
	hsDebugCode(fChunkCount = 0;)
}

hsChunkAllocator::~hsChunkAllocator()
{
	this->Reset();
}

void hsChunkAllocator::Reset()
{
	hsPrivateChunk*	chunk = fChunk;

	while (chunk)
	{	hsPrivateChunk*	next = chunk->fNext;
		HSMemory::Delete(chunk);
		chunk = next;
	}
	fChunk = nil;
	hsDebugCode(fChunkCount = 0;)
}

void hsChunkAllocator::SetChunkSize(UInt32 chunkSize)
{
	fChunkSize = chunkSize;
}

void* hsChunkAllocator::Allocate(UInt32 size, const void* data)
{
	void*	addr;

	if (fChunk == nil || fChunk->fAvailableSize < size)
	{	if (size > fChunkSize)
			fChunkSize = size;
		fChunk = hsPrivateChunk::NewPrivateChunk(fChunk, fChunkSize);
		hsDebugCode(fChunkCount += 1;)
	}

	addr = fChunk->fAvailableAddr;
	fChunk->fAvailableAddr += size;
	fChunk->fAvailableSize -= size;
	hsDebugCode(fChunk->fCount += 1;)

	if (data)
		HSMemory::BlockMove(data, addr, size);

	return addr;
}

void* hsChunkAllocator::SoftAllocate(UInt32 size, const void* data)
{
	void*	addr;

	hsTry {
		addr = this->Allocate(size, data);
	}
	hsCatch(...) {
		addr = nil;
	}
	return addr;
}

//////////////////////////////////////////////////////////////////////////////////////

struct hsAppenderHead {
	struct hsAppenderHead*	fNext;
	struct hsAppenderHead*	fPrev;
	void*	fFirst;
	void*	fStop;
	void*	fBottom;
	
	void*	GetTop() const { return (char*)this + sizeof(*this); }
	void*	GetBottom() const { return fBottom; }
	void*	GetStop() const { return fStop; }

	void*	GetFirst() const { return fFirst; }
	void*	GetLast(UInt32 elemSize) const { return (char*)fStop - elemSize; }
	UInt32	GetSize() const { return (char*)fStop - (char*)fFirst; }

	hsBool	CanPrepend() const { return fFirst != this->GetTop(); }
	int		PrependSize() const { return (char*)fFirst - (char*)this->GetTop(); }
	hsBool	CanAppend() const { return fStop != this->GetBottom(); }
	int		AppendSize() const { return (char*)this->GetBottom() - (char*)fStop; }
	
	void* Prepend(UInt32 elemSize)
	{
		hsAssert(this->CanPrepend(), "bad prepend");
		fFirst = (char*)fFirst - elemSize;
		hsAssert((char*)fFirst >= (char*)this->GetTop(), "bad elemSize");
		return fFirst;
	}
	void* Append(UInt32 elemSize)
	{
		hsAssert(this->CanAppend(), "bad append");
		void* data = fStop;
		fStop = (char*)fStop + elemSize;
		hsAssert((char*)fStop <= (char*)fBottom, "bad elemSize");
		return data;
	}
	hsBool PopHead(UInt32 elemSize, void* data)
	{
		hsAssert(fFirst != fStop, "Empty");
		if( data )
			HSMemory::BlockMove(fFirst, data, elemSize);
		fFirst = (char*)fFirst + elemSize;
		return fFirst == fStop;
	}
	hsBool PopTail(UInt32 elemSize, void* data)
	{
		hsAssert(fFirst != fStop, "Empty");
		fStop = (char*)fStop - elemSize;
		if( data )
			HSMemory::BlockMove(fStop, data, elemSize);
		return fFirst == fStop;
	}

	static hsAppenderHead* NewAppend(UInt32 elemSize, UInt32 elemCount, hsAppenderHead* prev)
	{
		UInt32			dataSize = elemSize * elemCount;
		 hsAppenderHead*	head = (hsAppenderHead*)HSMemory::New(sizeof(hsAppenderHead) + dataSize);

		head->fNext	= nil;
		head->fPrev = prev;
		head->fFirst	= head->GetTop();
		head->fStop	= head->fFirst;
		head->fBottom	= (char*)head->fFirst + dataSize;
		return head;
	}
	static hsAppenderHead* NewPrepend(UInt32 elemSize, UInt32 elemCount, hsAppenderHead* next)
	{
		UInt32			dataSize = elemSize * elemCount;
		 hsAppenderHead*	head = (hsAppenderHead*)HSMemory::New(sizeof(hsAppenderHead) + dataSize);

		head->fNext	= next;
		head->fPrev = nil;
		head->fBottom	= (char*)head->GetTop() + dataSize;
		head->fFirst	= head->fBottom;
		head->fStop	= head->fBottom;
		return head;
	}
};

////////////////////////////////////////////////////////////////////////////////////////

hsAppender::hsAppender(UInt32 elemSize, UInt32 elemCount)
		: fFirstBlock(nil), fElemSize(elemSize), fElemCount(elemCount), fCount(0)
{
}

hsAppender::~hsAppender()
{
	this->Reset();
}

UInt32 hsAppender::CopyInto(void* data) const
{
	if (data)
	{	const hsAppenderHead*	head = fFirstBlock;
		hsDebugCode(UInt32 totalSize = 0;)

		while (head != nil)
		{	UInt32	size = head->GetSize();
			HSMemory::BlockMove(head->GetFirst(), data, size);
			
			data = (char*)data + size;
			head = head->fNext;
			hsDebugCode(totalSize += size;)
		}
		hsAssert(totalSize == fCount * fElemSize, "bad size");
	}
	return fCount * fElemSize;
}

void hsAppender::Reset()
{
	hsAppenderHead*	head = fFirstBlock;

	while (head != nil)
	{	hsAppenderHead* next = head->fNext;
		HSMemory::Delete(head);
		head = next;
	}

	fCount = 0;
	fFirstBlock = nil;
	fLastBlock = nil;
}

void* hsAppender::PushHead()
{
	if (fFirstBlock == nil)
	{	fFirstBlock	= hsAppenderHead::NewPrepend(fElemSize, fElemCount, nil);
		fLastBlock		= fFirstBlock;
	}
	else if (fFirstBlock->CanPrepend() == false)
		fFirstBlock	= hsAppenderHead::NewPrepend(fElemSize, fElemCount, fFirstBlock);

	fCount += 1;
	return fFirstBlock->Prepend(fElemSize);
}

void hsAppender::PushHead(const void* data)
{
	void*	addr = this->PushHead();
	if (data)
		HSMemory::BlockMove(data, addr, fElemSize);
}

void* hsAppender::PeekHead() const
{
	if (fFirstBlock)
		return (char*)fFirstBlock->fFirst;
	else
		return nil;
}

hsBool hsAppender::PopHead(void* data)
{
	if (fCount == 0)
		return false;

	fCount -= 1;

	if (fFirstBlock->PopHead(fElemSize, data))
	{	hsAppenderHead*	next = fFirstBlock->fNext;
		if (next)
			next->fPrev = nil;
		HSMemory::Delete(fFirstBlock);
		fFirstBlock = next;
		if (next == nil)
			fLastBlock = nil;
	}
	return true;
}

int hsAppender::PopHead(int count, void* data)
{
	hsThrowIfBadParam(count >= 0);

	int	sizeNeeded = count * fElemSize;
	int	origCount = fCount;

	while (fCount > 0)
	{	int	size = fFirstBlock->GetSize();
		if (size > sizeNeeded)
			size = sizeNeeded;

		if (fFirstBlock->PopHead(size, data))
		{	hsAppenderHead*	next = fFirstBlock->fNext;
			if (next)
				next->fPrev = nil;
			HSMemory::Delete(fFirstBlock);
			fFirstBlock = next;
			if (next == nil)
				fLastBlock = nil;
		}

		if (data)
			data = (void*)((char*)data + size);
		sizeNeeded -= size;
		fCount -= size / fElemSize;
		hsAssert(int(fCount) >= 0, "bad fElemSize");
	}
	return origCount - fCount;		// return number of elements popped
}

void* hsAppender::PushTail()
{
	if (fFirstBlock == nil)
	{	fFirstBlock	= hsAppenderHead::NewAppend(fElemSize, fElemCount, nil);
		fLastBlock		= fFirstBlock;
	}
	else if (fLastBlock->CanAppend() == false)
	{	fLastBlock->fNext	= hsAppenderHead::NewAppend(fElemSize, fElemCount, fLastBlock);
		fLastBlock 		= fLastBlock->fNext;
	}
	
	fCount += 1;
	return fLastBlock->Append(fElemSize);
}

void hsAppender::PushTail(const void* data)
{
	void*	addr = this->PushTail();
	if (data)
		HSMemory::BlockMove(data, addr, fElemSize);
}

void hsAppender::PushTail(int count, const void* data)
{
	hsThrowIfBadParam(count < 0);

	int	sizeNeeded = count * fElemSize;

	while (sizeNeeded > 0)
	{	if (fFirstBlock == nil)
		{	hsAssert(fCount == 0, "uninited count");
			fFirstBlock	= hsAppenderHead::NewAppend(fElemSize, fElemCount, nil);
			fLastBlock		= fFirstBlock;
		}
		else if (fLastBlock->CanAppend() == false)
		{	fLastBlock->fNext	= hsAppenderHead::NewAppend(fElemSize, fElemCount, fLastBlock);
			fLastBlock 		= fLastBlock->fNext;
		}

		int		size = fLastBlock->AppendSize();
		hsAssert(size > 0, "bad appendsize");
		if (size > sizeNeeded)
			size = sizeNeeded;
		void*	dst = fLastBlock->Append(size);

		if (data)
		{	HSMemory::BlockMove(data, dst, size);
			data = (char*)data + size;
		}
		sizeNeeded -= size;
	}
	fCount += count;
}

void* hsAppender::PeekTail() const
{
	if (fLastBlock)
		return (char*)fLastBlock->fStop - fElemSize;
	else
		return nil;
}

hsBool hsAppender::PopTail(void* data)
{
	if (fCount == 0)
		return false;

	fCount -= 1;

	if (fLastBlock->PopTail(fElemSize, data))
	{	hsAppenderHead*	prev = fLastBlock->fPrev;
		if (prev)
			prev->fNext = nil;
		HSMemory::Delete(fLastBlock);
		fLastBlock = prev;
		if (prev == nil)
			fFirstBlock = nil;
	}
	return true;
}

//////////////////////////////////////////////////////////////////////////

hsAppenderIterator::hsAppenderIterator(const hsAppender* list)
{
	this->ResetToHead(list);
}
			
void hsAppenderIterator::ResetToHead(const hsAppender* list)
{
	fAppender = list;
	fCurrBlock = nil;

	if (fAppender)
	{	fCurrBlock = fAppender->fFirstBlock;
		if (fCurrBlock)
			fCurrItem = fCurrBlock->GetFirst();
	}
}

void hsAppenderIterator::ResetToTail(const hsAppender* list)
{
	fAppender = list;
	fCurrBlock = nil;

	if (fAppender)
	{	fCurrBlock = fAppender->fLastBlock;
		if (fCurrBlock)
			fCurrItem = fCurrBlock->GetLast(fAppender->fElemSize);
	}
}

void* hsAppenderIterator::Next()
{
	void*	item = nil;

	if (fCurrBlock)
	{	item = fCurrItem;
		fCurrItem = (char*)fCurrItem + fAppender->fElemSize;
		if (fCurrItem == fCurrBlock->GetBottom())
		{	fCurrBlock = fCurrBlock->fNext;
			if (fCurrBlock)
				fCurrItem = fCurrBlock->GetFirst();
		}
		else if (fCurrItem == fCurrBlock->GetStop())
		{	hsAssert(fCurrBlock->fNext == nil, "oops");
			fCurrBlock = nil;
		}
	}
	return item;
}

hsBool hsAppenderIterator::Next(void* data)
{
	void*	addr = this->Next();
	if (addr)
	{	if (data)
			HSMemory::BlockMove(addr, data, fAppender->fElemSize);
		return true;
	}
	return false;
}

int hsAppenderIterator::Next(int count, void* data)
{
	int	origCount = count;
	
	while (count > 0 && this->Next(data))
	{	if (data)
			data = (void*)((char*)data + fAppender->fElemSize);
		count -= 1;
	}
	return origCount - count;
}

void* hsAppenderIterator::Prev()
{
	void*	item = nil;

	if (fCurrBlock)
	{	item = fCurrItem;
		fCurrItem = (char*)fCurrItem - fAppender->fElemSize;
		if (item == fCurrBlock->GetTop())
		{	fCurrBlock = fCurrBlock->fPrev;
			if (fCurrBlock)
				fCurrItem = fCurrBlock->GetLast(fAppender->fElemSize);
		}
		else if (item == fCurrBlock->GetFirst())
		{	hsAssert(fCurrBlock->fPrev == nil, "oops");
			fCurrBlock = nil;
		}
	}
	return item;
}

hsBool hsAppenderIterator::Prev(void* data)
{
	void*	addr = this->Prev();
	if (addr)
	{	if (data)
			HSMemory::BlockMove(addr, data, fAppender->fElemSize);
		return true;
	}
	return false;
}

//-------------------------------------------------------------
//
//		MEMORY USE REPORTING CODE
//
//-------------------------------------------------------------

#if 1//!(defined(HS_DEBUGGING)&&(HS_BUILD_FOR_WIN32)&& defined(HS_FIND_MEM_LEAKS))
	// EMPTY STUB
void SortNDumpUnfreedMemory(const char *, bool ) // file name base, and FULL report indicator
{
}

#else
  
typedef struct _CrtMemBlockHeader
{
// Pointer to the block allocated just before this one:
   struct _CrtMemBlockHeader *pBlockHeaderNext; 
// Pointer to the block allocated just after this one:
   struct _CrtMemBlockHeader *pBlockHeaderPrev; 
   char *szFileName;   // File name
   int nLine;          // Line number
   size_t nDataSize;   // Size of user block
   int nBlockUse;      // Type of block
   long lRequest;      // Allocation number
// Buffer just before (lower than) the user's memory:
   unsigned char gap[4];  
} _CrtMemBlockHeader;

/* In an actual memory block in the debug heap,
 * this structure is followed by:
 *    unsigned char data[nDataSize];
 *    unsigned char anotherGap[4];
 */

//
// Dump formatted string to OutputDebugString
//
void __cdecl DebugMsg( LPSTR fmt, ... )
{

    char buff[256];
    wvsprintf(buff, fmt, (char *)(&fmt+1));
    hsStatusMessage(buff);

}

char *TrimFileName(char *name)		// Trim file name of leading Directories
{
	int len = 0;
	char *ptr;
	if (!name) return NULL;

	len = strlen(name);
	ptr = name + len;
	for ( ptr--; ptr > name; ptr--)
	{
		if (*ptr == '\\')
		{
			ptr++;
			break;
		}
	}
	return ptr;
}

//
// Loop thru all unfreed blocks in the heap and dump out detailed info
//

struct looktbl {
	char * fName;		// Name of file
//	long	fAllocs;	// Number of Alloc calls
	long	fBytes;		// Total Bytes Alloc'd
};
#define LTBLMAX 300

//---------------------------------------------------------------------------
// This routine will report on the memory used in the engine.
// If argument full is true, it gives a full dump from the start of the program
// if !full, then each time the routine is called it remembers where it finishes off, then the next
// call with !full, it will (attempt) to report on the newest allocations, backward to the last checkpoint
//--------------------------------------------------------------------------

void SortNDumpUnfreedMemory(const char *nm, bool full) // file name base, and FULL report indicator
{
#ifndef DO_MEMORY_REPORTS
	if (!full)					// full is launched by control M...partials are called each time the engine starts
		return;
#endif

	char fname[512];
	sprintf(fname,"%s_dmp.txt",nm);
	char *errStr = "";


	_CrtMemState heap_state;
static  UInt32 GrandTotal =0;
static 	_CrtMemBlockHeader *cmbh_last;	// Remember this header for next incremental check DANGER this 
				        // could break if this is freed...(gives bad report)
	_CrtMemBlockHeader *cmbh_last_good;
	
	_CrtMemBlockHeader *cmbh;
	// Get Current heap state

	_CrtMemCheckpoint(&heap_state);

	cmbh = heap_state.pBlockHeader;

	long totsize= 0;		// Track Total Bytes
	long normsize = 0;		// Track total of NORMAL Blocks

	looktbl *ltb = TRACKED_NEW looktbl[LTBLMAX];
	long tblEnd=1;			// first is "NULL";

	memset((void *)ltb,0,sizeof(looktbl) * LTBLMAX);		// clear table area

	char *ftrim;


	ltb[0].fName = "NULL";		// Use first Table Pos for NULL

	long tblpos;
	while (cmbh != NULL)		// Accumulate Stats to table
	{
		if (cmbh == cmbh_last && !full)	// full indicates ignore last "checkpoint", stop at last checkpoint if !full
			break;
		cmbh_last_good = cmbh;
		totsize += cmbh->nDataSize;
		if (cmbh->nBlockUse == _NORMAL_BLOCK) 
		{
			normsize += cmbh->nDataSize; 
			
			if (cmbh->szFileName != NULL)				// Shorten to just the file name, looks better, and strcmps faster
			{
				ftrim = TrimFileName(cmbh->szFileName);
				for (tblpos  = 1; tblpos < tblEnd; tblpos++)	// find the name in the table
				{	
					if (!strcmp(ftrim,ltb[tblpos].fName))
						break;	// found it
				}
			}
			else
			{	
				tblpos = 0;		// Use "NULL", first pos of table
			}

			if (tblpos == tblEnd)		// Did not find it...add it
			{
				tblEnd++;
				if (tblEnd >= LTBLMAX) 
				{	DebugMsg("DumpUnfreedMemoryInfo: EXCEED MAX TABLE LENGTH\n");
					tblEnd--;
					break;
				}
				ltb[tblpos].fName = ftrim;	// Add name
			}
				// Add Stats
//			ltb[tblpos].fAllocs++;
			ltb[tblpos].fBytes += cmbh->nDataSize;

			
		}
		cmbh = cmbh->pBlockHeaderNext;
		
	}
		// This Code relies on the _CrtMemBlockHeader *cmbh_last_good for the "last" checkpoint to still be around...
		// If the following occurs, that chunk has been deleted.  we could fix this by allocating our own
		// chunk and keeping it (watch for mem leaks though) or figuring out an "approximat" re syncying routine
		// that works before we run thru collecting data. PBG

	if (cmbh_last && !full && cmbh == NULL)
	{
		//hsAssert(0,"Stats error: incremental mem check point has been deleted");
		errStr = "CHECK POINT ERROR, Results Inacurate";
	}

	if (normsize)		// Don't write out about nothing
	{
		
		CreateDirectory("Reports",NULL);			// stick em in a sub directory
		char fnm[512];
		sprintf(fnm,"Reports\\%s",fname);
 
		FILE * DumpLogFile = fopen( fnm, "w" );
//		long allocs=0;
		if ( DumpLogFile != NULL )
		{
				// Print Stats
			fprintf(DumpLogFile, "Filename                Total=%ld(k) %s\n",(normsize + 500)/1000,errStr);
			for (int i = 0; i < tblEnd; i++)
			{	//fprintf(DumpLogFile,"%s\t%ld\n",ltb[i].fName, (ltb[i].fBytes+500)/1000);//,ltb[i].fAllocs);
				fprintf(DumpLogFile,"%s ",ltb[i].fName);
				int len = strlen(ltb[i].fName);

				for(int x=len; x < 25; x++)
					fputc(' ',DumpLogFile);				// make even columns
				fprintf(DumpLogFile,"%5ld K\n",(UInt32)( ltb[i].fBytes+500)/1000);//,ltb[i].fAllocs);
				
				//allocs += ltb[i].fAllocs;
			}

			DebugMsg("MEMORY USE FILE DUMPED TO %s \n",fname);
			DebugMsg("MEMORY Check: Total size %ld, Normal Size: %ld\n",totsize,normsize);

			fclose(DumpLogFile);
		}
		static int first=1;
		if (!full)			// if this is a partial mem dump, write to the ROOMS.txt file a summary
		{	
			sprintf(fnm,"Reports\\%s","ROOMS.txt");
 
			if (first)
			{	DumpLogFile = fopen( fnm, "w" );	// first time clobber the old
				if (DumpLogFile)
					fprintf(DumpLogFile, "Filename              Memory-Used(K)       RunningTotal\n");//  \tAllocation Calls \n" );
				first = 0;
			}
			else
				DumpLogFile = fopen( fnm, "a+" );
			if( DumpLogFile)
			{	fprintf(DumpLogFile,"%s ",nm);
				int len = strlen(nm);
				GrandTotal += (UInt32)(normsize+500)/1000;

				for(int x=len; x < 25; x++)
					fputc(' ',DumpLogFile);					// make even columns
				fprintf(DumpLogFile,"%5ld K           %5ld  %s\n",(UInt32)(normsize+500)/1000,GrandTotal,errStr);//, allocs);
				fclose(DumpLogFile);
			}
		}
	}


	cmbh_last = heap_state.pBlockHeader;
	delete ltb;
}
#endif