extern "C" void * MYCDECL CUSTOM_REALLOC (void * ptr, size_t sz)
{
if (ptr == NULL) {
ptr = CUSTOM_MALLOC (sz);
return ptr;
}
if (sz == 0) {
CUSTOM_FREE (ptr);
return NULL;
}
size_t objSize = CUSTOM_GETSIZE (ptr);
void * buf = CUSTOM_MALLOC ((size_t) (sz));
if (buf != NULL) {
// Copy the contents of the original object
// up to the size of the new block.
size_t minSize = (objSize < sz) ? objSize : sz;
memcpy (buf, ptr, minSize);
}
// Free the old block.
CUSTOM_FREE (ptr);
// Return a pointer to the new one.
return buf;
}
extern "C" void * MYCDECL CUSTOM_MEMALIGN (size_t alignment, size_t size)
{
// NOTE: This function is deprecated.
if (alignment == sizeof(double)) {
return CUSTOM_MALLOC (size);
} else {
void * ptr = CUSTOM_MALLOC (size + 2 * alignment);
void * alignedPtr = (void *) (((size_t) ptr + alignment - 1) & ~(alignment - 1));
return alignedPtr;
}
}
void * mymalloc (malloc_zone_t * zone, size_t size) {
void * ptr;
if (zone == theZone) {
ptr = CUSTOM_MALLOC(size);
} else {
ptr = originalMalloc (zone, size);
}
return ptr;
}
void * operator new[] (size_t size)
{
void * ptr = CUSTOM_MALLOC(size);
if (ptr == NULL) {
throw std::bad_alloc();
} else {
return ptr;
}
}
extern "C" wchar_t * MYCDECL CUSTOM_PREFIX(wcsdup) (const wchar_t * s)
{
wchar_t * newString = NULL;
if (s != NULL) {
if ((newString = (wchar_t *) CUSTOM_MALLOC(wcslen(s) + 1))) {
wcscpy(newString, s);
}
}
return newString;
}
extern "C" char * MYCDECL CUSTOM_PREFIX(strdup) (const char * s)
{
char * newString = NULL;
if (s != NULL) {
if ((newString = (char *) CUSTOM_MALLOC(strlen(s) + 1))) {
strcpy(newString, s);
}
}
return newString;
}
extern "C" void * MYCDECL CUSTOM_CALLOC (size_t nelem, size_t elsize)
{
size_t n = nelem * elsize;
void * ptr = CUSTOM_MALLOC (n);
// Zero out the malloc'd block.
if (ptr != NULL) {
memset (ptr, 0, n);
}
return ptr;
}
extern "C" char * MYCDECL CUSTOM_PREFIX(strndup) (const char * s, size_t sz)
{
char * newString = NULL;
if (s != NULL) {
size_t cappedLength = strnlen (s, sz);
if ((newString = (char *) CUSTOM_MALLOC(cappedLength + 1))) {
strncpy(newString, s, cappedLength);
newString[cappedLength] = '\0';
}
}
return newString;
}
extern "C" void * MYCDECL CUSTOM_PVALLOC (size_t sz)
{
// Rounds up to the next pagesize and then calls valloc. Hoard
// doesn't support aligned memory requests
return CUSTOM_MALLOC (sz);
}
extern "C" void * MYCDECL CUSTOM_VALLOC (size_t sz)
{
// Equivalent to memalign(pagesize, sz), which Hoard doesn't support
// anyway...
return CUSTOM_MALLOC (sz);
}
static void * my_malloc_hook (size_t size, const void *) {
void * result = CUSTOM_MALLOC(size);
return result;
}
extern "C" void * MYCDECL CUSTOM_MEMALIGN (size_t boundary, size_t size)
{
// NOTE: We align stuff, but it is not guaranteed to be freed.
void * buf = CUSTOM_MALLOC (2 * boundary + size);
return (void *) (((size_t) buf + boundary - 1) & ~(boundary - 1));
}
void * operator new[] (size_t sz, const std::nothrow_t&) throw() {
return CUSTOM_MALLOC (sz);
}
void * operator new[] (size_t size) throw(std::bad_alloc)
{
return CUSTOM_MALLOC(size);
}
void * operator new (size_t sz)
{
return CUSTOM_MALLOC (sz);
}
