xemacs-beta: src/gmalloc.c comparison

comparison src/gmalloc.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	4be1180a9e89
children	51092a27c943

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 /* Limit of valid info table indices.  */
 extern __malloc_size_t _heaplimit;
 /* Doubly linked lists of free fragments.  */
 struct list
 {
 struct list *next;
 struct list *prev;
 };
 /* Free list headers for each fragment size.  */
 extern struct list _fraghead[];
 /* List of blocks allocated with `memalign' (or `valloc').  */
 struct alignlist
 {
 struct alignlist *next;
 __ptr_t aligned;		/* The address that memaligned returned.  */
 __ptr_t exact;		/* The address that malloc returned.  */
 };
 extern struct alignlist *_aligned_blocks;
 /* Instrumentation.  */
 extern __malloc_size_t _chunks_used;
 extern __malloc_size_t _bytes_used;
 extern __ptr_t (*__realloc_hook) __P ((__ptr_t __ptr, size_t __size));
 /* Return values for `mprobe': these are the kinds of inconsistencies that
 `mcheck' enables detection of.  */
 enum mcheck_status
 {
-MCHECK_DISABLED = -1,	/* Consistency checking is not turned on.  */
+MCHECK_DISABLED = -1,		/* Consistency checking is not turned on.  */
 MCHECK_OK,			/* Block is fine.  */
-MCHECK_FREE,		/* Block freed twice.  */
+MCHECK_FREE,			/* Block freed twice.  */
-MCHECK_HEAD,		/* Memory before the block was clobbered.  */
+MCHECK_HEAD,			/* Memory before the block was clobbered.  */
 MCHECK_TAIL			/* Memory after the block was clobbered.  */
 };
 /* Activate a standard collection of debugging hooks.  This must be called
 before `malloc' is ever called.  ABORTFUNC is called with an error code
 (see enum above) when an inconsistency is detected.  If ABORTFUNC is
 null, the standard function prints on stderr and then calls `abort'.  */
 extern void mtrace __P ((void));
 extern void muntrace __P ((void));
 /* Statistics available to the user.  */
 struct mstats
 {
-__malloc_size_t bytes_total; /* Total size of the heap. */
+__malloc_size_t bytes_total;	/* Total size of the heap. */
-__malloc_size_t chunks_used; /* Chunks allocated by the user. */
+__malloc_size_t chunks_used;	/* Chunks allocated by the user. */
 __malloc_size_t bytes_used;	/* Byte total of user-allocated chunks. */
-__malloc_size_t chunks_free; /* Chunks in the free list. */
+__malloc_size_t chunks_free;	/* Chunks in the free list. */
 __malloc_size_t bytes_free;	/* Byte total of chunks in the free list. */
 };
 /* Pick up the current statistics. */
 extern struct mstats mstats __P ((void));
 /* Call WARNFUN with a warning message when memory usage is high.  */
 #endif
 static __malloc_size_t pagesize;
 __ptr_t
-valloc (size)
+valloc (__malloc_size_t size)
-__malloc_size_t size;
 {
 if (pagesize == 0)
 pagesize = __getpagesize ();
 return memalign (pagesize, size);
 void (*__after_morecore_hook) __P ((void));
 /* Aligned allocation.  */
 static __ptr_t align __P ((__malloc_size_t));
 static __ptr_t
-align (size)
+align (__malloc_size_t size)
-__malloc_size_t size;
 {
 __ptr_t result;
 unsigned long int adj;
 result = (*__morecore) (size);
 /* Get neatly aligned memory, initializing or
 growing the heap info table as necessary. */
 static __ptr_t morecore __P ((__malloc_size_t));
 static __ptr_t
-morecore (size)
+morecore (__malloc_size_t size)
-__malloc_size_t size;
 {
 __ptr_t result;
 malloc_info *newinfo, *oldinfo;
 __malloc_size_t newsize;
 return result;
 }
 /* Allocate memory from the heap.  */
 __ptr_t
-malloc (size)
+malloc (__malloc_size_t size)
-__malloc_size_t size;
 {
 __ptr_t result;
 __malloc_size_t block, blocks, lastblocks, start;
 __malloc_size_t i;
 struct list *next;
 struct alignlist *_aligned_blocks = NULL;
 /* Return memory to the heap.
 Like `free' but don't call a __free_hook if there is one.  */
 void
-_free_internal (ptr)
+_free_internal (__ptr_t ptr)
-__ptr_t ptr;
 {
 int type;
 __malloc_size_t block, blocks;
 __malloc_size_t i;
 struct list *prev, *next;
 }
 }
 /* Return memory to the heap.  */
 __free_ret_t
-free (ptr)
+free (__ptr_t ptr)
-__ptr_t ptr;
 {
 struct alignlist *l;
 if (ptr == NULL)
 return;
 #ifndef emacs
 /* Like bcopy except never gets confused by overlap.  */
 static void
-safe_bcopy (from, to, size)
+safe_bcopy (char *from, char *to, int size)
-char *from, *to;
-int size;
 {
 if (size <= 0 || from == to)
 return;
 /* If the source and destination don't overlap, then bcopy can
 	     little left over.  The amount left over is
 	     (endt + (to - from)) - to, which is endt - from.  */
 	  bcopy (from, to, endt - from);
 	}
 }
 }
 #endif	/* Not emacs.  */
 #define memmove(to, from, size) safe_bcopy ((from), (to), (size))
 #endif
 some benchmarks seem to indicate that greater compactness is
 achieved by unconditionally allocating and copying to a
 new region.  This module has incestuous knowledge of the
 internals of both free and malloc. */
 __ptr_t
-realloc (ptr, size)
+realloc (__ptr_t ptr, __malloc_size_t size)
-__ptr_t ptr;
-__malloc_size_t size;
 {
 __ptr_t result;
 int type;
 __malloc_size_t block, blocks, oldlimit;
 #endif
 /* Allocate an array of NMEMB elements each SIZE bytes long.
 The entire array is initialized to zeros.  */
 __ptr_t
-calloc (nmemb, size)
+calloc (__malloc_size_t nmemb, __malloc_size_t size)
-__malloc_size_t nmemb;
-__malloc_size_t size;
 {
 __ptr_t result = malloc (nmemb * size);
 if (result != NULL)
 (void) memset (result, 0, nmemb * size);
 /* Allocate INCREMENT more bytes of data space,
 and return the start of data space, or NULL on errors.
 If INCREMENT is negative, shrink data space.  */
 __ptr_t
-__default_morecore (increment)
+__default_morecore (
 #ifdef __STDC__
-ptrdiff_t increment;
+ptrdiff_t increment
 #else
 #ifdef OSF1
-long increment;
+long increment
 #else
-int increment;
+int increment
 #endif
 #endif
+)
 {
 #ifdef OSF1
 __ptr_t result = (__ptr_t) __sbrk ((ssize_t) increment);
 #else
 __ptr_t result = (__ptr_t) __sbrk ((int) increment);
 #define _MALLOC_INTERNAL
 #include <malloc.h>
 #endif
 __ptr_t
-memalign (alignment, size)
+memalign (__malloc_size_t alignment, __malloc_size_t size)
-__malloc_size_t alignment;
-__malloc_size_t size;
 {
 __ptr_t result;
 unsigned long int adj;
 size = ((size + alignment - 1) / alignment) * alignment;

Mercurial > hg > xemacs-beta

comparison src/gmalloc.c @ 185:3d6bfa290dbd r20-3b19