Unnamed

/* * realloc.c */#include <stdlib.h>#include <string.h>#include <minmax.h>#include "malloc.h"void *realloc(void *ptr, size_t size){    struct free_arena_header *ah, *nah;    void *newptr;    size_t newsize, oldsize, xsize;    if (!ptr)	return malloc(size);    if (size == 0) {	free(ptr);	return NULL;    }    ah = (struct free_arena_header *)	((struct arena_header *)ptr - 1);    /* Actual size of the old block */    oldsize = ah->a.size;    /* Add the obligatory arena header, and round up */    newsize = (size + 2 * sizeof(struct arena_header) - 1) & ARENA_SIZE_MASK;    if (oldsize >= newsize && newsize >= (oldsize >> 2) &&	oldsize - newsize < 4096) {	/* This allocation is close enough already. */	return ptr;    } else {	xsize = oldsize;	nah = ah->a.next;	if ((char *)nah == (char *)ah + ah->a.size &&	    nah->a.type == ARENA_TYPE_FREE &&	    oldsize + nah->a.size >= newsize) {	    /* Merge in subsequent free block */	    ah->a.next = nah->a.next;	    ah->a.next->a.prev = ah;	    nah->next_free->prev_free = nah->prev_free;	    nah->prev_free->next_free = nah->next_free;	    xsize = (ah->a.size += nah->a.size);	}	if (xsize >= newsize) {	    /* We can reallocate in place */	    if (xsize >= newsize + 2 * sizeof(struct arena_header)) {		/* Residual free block at end */		nah = (struct free_arena_header *)((char *)ah + newsize);		nah->a.type = ARENA_TYPE_FREE;		nah->a.size = xsize - newsize;		ah->a.size = newsize;		/* Insert into block list */		nah->a.next = ah->a.next;		ah->a.next = nah;		nah->a.next->a.prev = nah;		nah->a.prev = ah;		/* Insert into free list */		if (newsize > oldsize) {		    /* Hack: this free block is in the path of a memory object		       which has already been grown at least once.  As such, put		       it at the *end* of the freelist instead of the beginning;		       trying to save it for future realloc()s of the same block. */		    nah->prev_free = __malloc_head.prev_free;		    nah->next_free = &__malloc_head;		    __malloc_head.prev_free = nah;		    nah->prev_free->next_free = nah;		} else {		    nah->next_free = __malloc_head.next_free;		    nah->prev_free = &__malloc_head;		    __malloc_head.next_free = nah;		    nah->next_free->prev_free = nah;		}	    }	    /* otherwise, use up the whole block */	    return ptr;	} else {	    /* Last resort: need to allocate a new block and copy */	    oldsize -= sizeof(struct arena_header);	    newptr = malloc(size);	    if (newptr) {		memcpy(newptr, ptr, min(size, oldsize));		free(ptr);	    }	    return newptr;	}    }}