/************************************************************************* * TinyFugue - programmable mud client * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2002, 2003, 2004, 2005, 2006-2007 Ken Keys * * TinyFugue (aka "tf") is protected under the terms of the GNU * General Public License. See the file "COPYING" for details. ************************************************************************/ /* $Id: malloc.h,v 35004.24 2007/01/13 23:12:39 kkeys Exp $ */ /* Function hierarchy: * xmalloc: will kill process if it fails. Calls dmalloc. * dmalloc: if USE_DMALLOC, do debugging. Calls mmalloc. * mmalloc: if USE_MMALLOC, use GNU mmalloc; otherwise call native functions. * malloc: if !USE_MMALLOC, use native functions; otherwise, call mmalloc. * * XMALLOC is like xmalloc, but has file and line built in. * MALLOC is like dmalloc, but has file and line built in. * * Most code will call XMALLOC() (for automatic error checking) or MALLOC() * (if it can handle failure itself). Code may call xmalloc() or dmalloc() * to use nonlocal file and line info. Code should almost never call * mmalloc() or malloc() directly. */ #ifndef MALLOC_H #define MALLOC_H extern int low_memory_warning; #if USE_MMALLOC # include "mmalloc/mmalloc.h" # define malloc(size) mmalloc(NULL, size) # define calloc(size) mcalloc(NULL, size) # define realloc(ptr, size) mrealloc(NULL, ptr, size) # define free(ptr) mfree(NULL, ptr) #else # define mmalloc(md, size) malloc(size) # define mcalloc(md, size) calloc(size) # define mrealloc(md, ptr, size) realloc(ptr, size) # define mfree(md, ptr) free(ptr) #endif #define XMALLOC(size) xmalloc(NULL, (size), __FILE__, __LINE__) #define XCALLOC(size) xcalloc(NULL, (size), __FILE__, __LINE__) #define XREALLOC(ptr, size) xrealloc(NULL, (ptr), (size), __FILE__, __LINE__) #define MALLOC(size) dmalloc(NULL, (size), __FILE__, __LINE__) #define CALLOC(size) dcalloc(NULL, (size), __FILE__, __LINE__) #define REALLOC(ptr, size) drealloc(NULL, (ptr), (size), __FILE__, __LINE__) #define FREE(ptr) xfree(NULL, (void*)(ptr), __FILE__, __LINE__) #if USE_DMALLOC extern void *dmalloc(void *md, long unsigned size, const char *file, const int line); extern void *dcalloc(void *md, long unsigned size, const char *file, const int line); extern void *drealloc(void *md, void *ptr, long unsigned size, const char *file, const int line); extern void dfree(void *md, void *ptr, const char *file, const int line); #else # define dmalloc(md, size, file, line) mmalloc(md, size) # define dcalloc(md, size, file, line) mcalloc(md, size) # define drealloc(md, ptr, size, file, line) \ mrealloc(md, (void*)(ptr), (size)) # define dfree(md, ptr, file, line) mfree(md, (void*)(ptr)) #endif extern void *xmalloc(void *md, long unsigned size, const char *file, const int line); extern void *xcalloc(void *md, long unsigned size, const char *file, const int line); extern void *xrealloc(void *md, void *ptr, long unsigned size, const char *file, const int line); extern void xfree(void *md, void *ptr, const char *file, const int line); extern void init_malloc(void); /* Fast allocation from pool. * Should be used only on objects which are freed frequently, with md==NULL. */ #define palloc(item, type, pool, next, file, line) \ ((pool) ? \ ((item) = (pool), (pool) = (void*)(pool)->next) : \ ((item) = (type *)xmalloc(NULL, sizeof(type), file, line))) #if !USE_DMALLOC # define pfree_fl(item, pool, next, file, line) \ ((item)->next = (void*)(pool), (pool) = (item)) # define pfreepool(type, pool, next) \ do { \ type *tmp; \ while (pool) { \ tmp = pool; \ pool = (type*)pool->next; \ FREE(tmp); \ } \ } while (0) #else # define pfree_fl(item, pool, next, file, line) \ dfree(NULL, item, file, line) # define pfreepool(type, pool, next) /* do nothing */ #endif #define pfree(item, pool, next) pfree_fl(item, pool, next, __FILE__, __LINE__) #if USE_DMALLOC extern void free_reserve(void); extern void debug_mstats(const char *s); #endif #endif /* MALLOC_H */