void* mymalloc(char* file, int line, size_t size)
{
storageElement* s = malloc(sizeof(storageElement));
s->file = malloc(strlen(file)+1);
strcpy(s->file, file);
s->line = line;
s->ptr = malloc(size);
s->size = size;
//Log(LOG_DEBUG, "Allocating %d bytes in heap at file %s line %d ptr %p\n", size, file, line, s->ptr);
ListAppendNoMalloc(&heap, s, malloc(sizeof(ListElement)), sizeof(ListElement));
state.current_size += size;
if (state.current_size > state.max_size)
state.max_size = state.current_size;
return s->ptr;
}
/**
* Insert an item to a list at a specific position.
* @param aList the list to which the item is to be added
* @param content the list item content itself
* @param size the size of the element
* @param index the position in the list. If NULL, this function is equivalent
* to ListAppend.
*/
void ListInsert(List* aList, void* content, size_t size, ListElement* index)
{
ListElement* newel = malloc(sizeof(ListElement));
if ( index == NULL )
ListAppendNoMalloc(aList, content, newel, size);
else
{
newel->content = content;
newel->next = index;
newel->prev = index->prev;
index->prev = newel;
if ( newel->prev != NULL )
newel->prev->next = newel;
else
aList->first = newel;
++(aList->count);
aList->size += size;
}
}
/**
* Allocates a block of memory. A direct replacement for malloc, but keeps track of items
* allocated in a list, so that free can check that a item is being freed correctly and that
* we can check that all memory is freed at shutdown.
* @param file use the __FILE__ macro to indicate which file this item was allocated in
* @param line use the __LINE__ macro to indicate which line this item was allocated at
* @param size the size of the item to be allocated
* @return pointer to the allocated item, or NULL if there was an error
*/
void* mymalloc(char* file, int line, size_t size)
{
ListElement* e = NULL;
storageElement* s = NULL;
static char* errmsg = "Memory allocation error";
if ((s = malloc(sizeof(storageElement))) == NULL)
{
Log(LOG_ERROR, -1, errmsg);
return NULL;
}
if ((s->file = malloc(strlen(file)+1)) == NULL)
{
Log(LOG_ERROR, -1, errmsg);
free(s);
return NULL;
}
strcpy(s->file, file);
s->line = line;
if ((s->ptr = malloc(size)) == NULL)
{
Log(LOG_ERROR, -1, errmsg);
free(s->file);
free(s);
return NULL;
}
s->size = size;
s->stack = NULL;
if (trace_settings.trace_level == TRACE_MAXIMUM)
{
if ((s->stack = StackTrace_get(Thread_getid())) == NULL)
{
Log(LOG_ERROR, -1, errmsg);
free(s->ptr);
free(s->file);
free(s);
return NULL;
}
else
{
Log(TRACE_MAX, -1, "Allocating %d bytes in heap at line %d of file %s, ptr %p, heap use now %d bytes",
s->size, line, file, s->ptr, state.current_size);
Log(TRACE_MAX, -1, "Stack trace is %s", s->stack);
}
}
if ((e = malloc(sizeof(ListElement))) == NULL)
{
Log(LOG_ERROR, -1, errmsg);
if (s->stack)
free(s->stack);
free(s->ptr);
free(s->file);
free(s);
return NULL;
}
ListAppendNoMalloc(&heap, s, e, sizeof(ListElement));
state.current_size += size;
if (state.current_size > state.max_size)
state.max_size = state.current_size;
return s->ptr;
}
/**
* Append an item to a list.
* @param aList the list to which the item is to be added
* @param content the list item content itself
* @param size the size of the element
*/
void ListAppend(List* aList, void* content, size_t size)
{
ListElement* newel = malloc(sizeof(ListElement));
ListAppendNoMalloc(aList, content, newel, size);
}
