unx_memmgr.c

smallbasic for linux

/*
*	unx_memmgr
*
*	PalmOS memory manager emulation for unix
*
*	Nicholas Christopoulos
*
*	This program is distributed under the terms of the GPL v2.0 or later
*	Download the GNU Public License (GPL) from www.gnu.org
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#define	UMM_MODULE
#include "unx_memmgr.h"
#include "panic.h"
#if defined(_BCB_W32_IDE)
	#include "win32/bcb.h"
#endif

#if defined(_BCB_W32_IDE)
	#define	xprintf		bcb_mgrerr
#else
	#define	xprintf		printf
#endif

struct palm_mem_node	{
	char	module[256];
	int		deleted;
	int		line;
	int		size;			/* memory block size, in bytes */
	int		lock;			/* lock count */
	void	*ptr;			/* data pointer */
	};
typedef struct palm_mem_node memnode;


#define	GROWSIZE		8192
#define	MAX_UNDEF_SIZE	1024

static memnode	*memtable;
static int		umm_size;
static int		umm_count;
static int		max_alloc;	/* maximum size of memory allocation */
static int		cur_alloc;	/* remain allocated (size) */

#if defined(CHECK_PTRS_LEV2)
static char		err_module[256];
static int		err_line;
#endif

/*
*/
int		memmgr_getalloc()
{
	return cur_alloc;
}

/*
*	memory dump
*/
void	hex_dump(const unsigned char *block, int size)
{
	int		i, j;
	
	xprintf("\n---HexDump---\n\t");
	for ( i = 0; i < size; i ++ )	{

		xprintf("%02X ", block[i]);
		if	( ((i+1) % 8) == 0 )	{
			xprintf("  ");
			for ( j = i - 7; j <= i; j ++ )	{
				if	( block[j] < 32 )
					xprintf(".");
				else
					xprintf("%c", block[j]);
				}
			xprintf("\n\t");
			}
		}

	xprintf("\n");
}

/*
*/
void	uuerr(int expf, const char *fmt, ...)
{
	va_list	ap;
	#if defined(_BCB_W32_IDE)
	char	buf[1024];
	#endif

	if	( expf )	{
		#if defined(CHECK_PTRS_LEV2)
		xprintf("\n\n=== MemMgr: BUG located at %s:%d ===\n", err_module, err_line);
		#endif

		va_start(ap, fmt);
		#if defined(_BCB_W32_IDE)
		vsprintf(buf, fmt, ap);
		bcb_mgrerr("%s", buf);
		#else
		vprintf(fmt, ap);
		#endif
		va_end(ap);

		#if !defined(_BCB_W32_IDE)
		exit(1);
		#endif
		}
}

/*
*	memory manager
*/
void	memmgr_close()
{
	int		i;

	xprintf("\n");
	xprintf("MemMgr: Max. Alloc.: %d, Leak: %d\n", max_alloc, cur_alloc);
	if	( cur_alloc )	{
		xprintf("-------------------------------------------------------\n");
		for ( i = 0; i < umm_count; i ++ )	{
			if	( memtable[i].size != 0 )	{
				xprintf("%s:%d --- Handle: %d, Size: %d, LockCount: %d\n", memtable[i].module, memtable[i].line, i+1, memtable[i].size, memtable[i].lock);
				hex_dump(memtable[i].ptr, memtable[i].size);
				free(memtable[i].ptr);
				}
			}
		}

	free(memtable);
}

void	memmgr_init()
{
	max_alloc = 0;
	cur_alloc = 0;
	umm_count = 0;
	umm_size  = GROWSIZE;
	memtable = (memnode *) malloc(sizeof(memnode) * umm_size);
	#if !defined(_BCB_W32_IDE)
	atexit(memmgr_close);
	#endif
}

/*
*	allocate a memory block of "storage" RAM
*/
MemHandle	MemHandleNewX(int size, const char *file, int line)
{
	int		i;

#if defined(CHECK_PTRS_LEV2)
	strcpy(err_module, file);	err_line = line;
#endif
	if	( size <= 0 )	{
		uuerr(1,"\n\aMemMgr: MemHandleNewX(h), size <= 0\n");
		return 0;
		}

	for ( i = 0; i < umm_count; i ++ )	{
		if	( memtable[i].deleted )	{
			strcpy(memtable[i].module, file);
			memtable[i].line = line;

			memtable[i].ptr = (void *) malloc(size);
			memtable[i].size = size;
			memtable[i].deleted = 0;
			memtable[i].lock = 0;
			cur_alloc += size;
			if	( cur_alloc > max_alloc )
				max_alloc = cur_alloc;
			return i+1;
			}
		}

	if	( umm_count >= umm_size )	{
		umm_size += GROWSIZE;
		memtable  = (memnode *) realloc(memtable, sizeof(memnode) * umm_size);
		}

	i = umm_count;
	umm_count ++;

	strcpy(memtable[i].module, file);
	memtable[i].line = line;

	memtable[i].deleted = 0;
	memtable[i].ptr = (void *) malloc(size);
	memtable[i].size = size;
	memtable[i].lock = 0;
	cur_alloc += size;
	if	( cur_alloc > max_alloc )
		max_alloc = cur_alloc;

	return i+1;
}

/*
*	deallocate a storage-RAM memory block
*/
void	MemHandleFreeX(MemHandle h, const char *file, int line)
{
	int		i = h-1;

#if defined(CHECK_PTRS_LEV2)
	strcpy(err_module, file);	err_line = line;
#endif

	if	( i >= 0 && i < umm_count )	{
		if	( !memtable[i].deleted )	{
			if	( memtable[i].lock )
				xprintf("MemMgr: mem is locked\n");

			cur_alloc -= memtable[i].size;
			free(memtable[i].ptr);
			memtable[i].ptr = NULL;
			memtable[i].size = 0;
			memtable[i].lock = 0;
			memtable[i].deleted = 1;
			}
		else
			uuerr(1,"\n\aMemMgr: MemHandleFree(h), handle is empty\n");
		}
	else
		uuerr(1,"\n\aMemMgr: MemHandleFree(h), handle does not exists\n");
}

/*
*	returns the handle of pointer!
*/
MemHandle	MemPtrRecoverHandleX(MemPtr p, const char *file, int line)
{
	int		i;

#if defined(CHECK_PTRS_LEV2)
	strcpy(err_module, file);	err_line = line;
	uuerr(!p, "\n\aMemMgr: MemPtrRecoverHandle(p), pointer is NULL\n");
#endif
	for ( i = 0; i < umm_count; i ++ )	{
		if	( memtable[i].ptr == p )	
			return i+1;
		}

	uuerr(1,"\n\aMemMgr: MemPtrRecoverHandle(ptr), ptr does not exists\n");
	return 0;
}

/*
*	returns the size of the memory block in bytes
*/
int		MemHandleSizeX(MemHandle h, const char *file, int line)
{
#if defined(CHECK_PTRS_LEV2)
	strcpy(err_module, file);	err_line = line;
	if	( (h < 1) || (h > umm_count) )
		uuerr(1,"\n\aMemMgr: MemHandleSize(h), invalid handle\n");
	if	( memtable[h-1].deleted || (memtable[h-1].ptr == NULL) )	
		uuerr(1,"\n\aMemMgr: MemHandleSize(h), deleted block\n");
#endif
	return memtable[h-1].size;
}

/*
*	lock a memory block (move it to dynamic-RAM)
*	returns the data-pointer of the memory block
*/
MemPtr	MemHandleLockX(MemHandle h, const char *file, int line)
{
#if defined(CHECK_PTRS_LEV2)
	strcpy(err_module, file);	err_line = line;
	if	( (h < 1) || (h > umm_count) )
		uuerr(1,"\n\aMemMgr: MemHandleLock(h), invalid handle\n");
	if	( memtable[h-1].deleted || (memtable[h-1].ptr == NULL) )	
		uuerr(1,"\n\aMemMgr: MemHandleLock(h), deleted block\n");
#endif
	memtable[h-1].lock ++;
	return	memtable[h-1].ptr;
}

/*
*	unlocks a memory block (move it back to storage-RAM)
*/
void	MemHandleUnlockX(MemHandle h, const char *file, int line)
{
#if defined(CHECK_PTRS_LEV2)
	strcpy(err_module, file);	err_line = line;
	if	( (h < 1) || (h > umm_count) )
		uuerr(1,"\n\aMemMgr: MemHandleUnlock(h), invalid handle\n");
	if	( memtable[h-1].deleted || (memtable[h-1].ptr == NULL) )	
		uuerr(1,"\n\aMemMgr: MemHandleUnlock(h), deleted block\n");
	if	( memtable[h-1].lock < 1 )	
		uuerr(1,"\n\aMemMgr: MemHandleUnlock(h), lock count < 0\n");
#endif
	memtable[h-1].lock --;
}

/*
*	resize a memory block (storage RAM)
*/
int		MemHandleResizeX(MemHandle h, int new_size, const char *file, int line)
{
	char	*np;

#if defined(CHECK_PTRS_LEV2)