void Purify_free (void * mem)
{
MemHash * hash = Purify_FindMemory (mem);
PMemoryNode * node;
if (!hash)
{
Purify_Error = IllPointer;
Purify_PrintError ("free(addr=%p)", mem);
}
else
{
node = (PMemoryNode *)(hash->data);
Purify_SetMemoryFlags (hash, 0, hash->size, PURIFY_MemFlag_Free);
Purify_RememberCallers (&node->free);
}
}
MemHash * Purify_AddMemory (void * memory, int size, int flag, int type)
{
MemHash * node = xmalloc (sizeof (MemHash));
int hashcode;
node->mem = memory;
node->flags = xmalloc (size);
node->size = size;
node->type = type;
node->data = NULL;
if (flag != -1)
Purify_SetMemoryFlags (node, 0, size, flag);
hashcode = CalcHash (memory);
node->next = memHash[hashcode];
memHash[hashcode] = node;
return node;
}
void * Purify_realloc (void * mem, size_t size)
{
PMemoryNode * oldnode, * newnode;
MemHash * oldmem, * newmem;
if (size)
{
newnode = malloc (sizeof (PMemoryNode) + size);
if (!newnode)
return NULL;
Purify_RememberCallers (&newnode->alloc);
newnode->free.nstack = -1; /* Not freed yet */
newnode->memptr = ALIGN(newnode->mem);
newmem = Purify_AddMemory (newnode->memptr, size,
PURIFY_MemFlag_Writable
| PURIFY_MemFlag_Empty
, PURIFY_MemType_Heap
);
newmem->data = newnode;
}
else
newnode = NULL;
if (mem && size)
{
memcpy (newnode->memptr, mem, size);
}
if (mem)
{
oldmem = Purify_FindMemory (mem);
if (!oldmem)
{
Purify_Error = IllPointer;
Purify_PrintError ("realloc(addr=%p, size=%ld)", mem, size);
}
else
{
oldnode = (PMemoryNode *)(oldmem->data);
if (newnode)
{
if (size > oldmem->size)
size = oldmem->size;
memcpy (newnode->memptr, oldnode->memptr, size);
Purify_SetMemoryFlags (newmem, 0, size,
PURIFY_MemFlag_Readable | PURIFY_MemFlag_Writable
);
}
Purify_SetMemoryFlags (oldmem, 0, oldmem->size, PURIFY_MemFlag_Free);
Purify_RememberCallers (&oldnode->free);
}
}
return newnode ? newnode->memptr : NULL;
}
