The R Project SVN – R – Diff – /trunk/src/gnuwin32/malloc.c

 static int cpuinfo (int whole, unsigned long*kernel, unsigned long*user);
 */
 #endif
-/*
-  __STD_C should be nonzero if using ANSI-standard C compiler, a C++
-  compiler, or a C compiler sufficiently close to ANSI to get away
-  with it.
-*/
-#ifndef __STD_C
-#if defined(__STDC__) || defined(_cplusplus)
-#define __STD_C     1
-#else
-#define __STD_C     0
-#endif
-#endif /*__STD_C*/
 /*
   Void_t* is the pointer type that malloc should say it returns
 */
 #ifndef Void_t
-#if (__STD_C || defined(WIN32))
 #define Void_t      void
-#else
-#define Void_t      char
-#endif
 #endif /*Void_t*/
-#if __STD_C
 #include <stddef.h>   /* for size_t */
-#else
-#include <sys/types.h>
-#endif
 #ifdef __cplusplus
 extern "C" {
 #endif
 #define USE_MEMCPY 0
 #endif
 #endif
-#if (__STD_C || defined(HAVE_MEMCPY))
+#if (defined(HAVE_MEMCPY))
 #ifdef WIN32
 /* On Win32 memset and memcpy are already declared in windows.h */
 #else
-#if __STD_C
 void* memset(void*, int, size_t);
 void* memcpy(void*, const void*, size_t);
-#else
-Void_t* memset();
-Void_t* memcpy();
-#endif
 #endif
 #endif
 /*
   MALLOC_FAILURE_ACTION is the action to take before "return 0" when
   By default, sets errno if running on STD_C platform, else does nothing.
 */
 #ifndef MALLOC_FAILURE_ACTION
-#if __STD_C
 #define MALLOC_FAILURE_ACTION \
    errno = ENOMEM;
-#else
-#define MALLOC_FAILURE_ACTION
-#endif
 #endif
 /*
   MORECORE-related declarations. By default, rely on sbrk
 */
 #ifdef LACKS_UNISTD_H
 #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-#if __STD_C
 extern Void_t*     sbrk(ptrdiff_t);
-#else
-extern Void_t*     sbrk();
-#endif
 #endif
 #endif
 /*
   MORECORE is the name of the routine to call to obtain more memory
   with negative arguments are interpreted as requests for huge amounts
   of space, which will often fail. The maximum supported value of n
   differs across systems, but is in all cases less than the maximum
   representable value of a size_t.
 */
-#if __STD_C
 Void_t*  public_mALLOc(size_t);
-#else
-Void_t*  public_mALLOc();
-#endif
 /*
   free(Void_t* p)
   Releases the chunk of memory pointed to by p, that had been previously
   allocated using malloc or a related routine such as realloc.
   Unless disabled (using mallopt), freeing very large spaces will
   when possible, automatically trigger operations that give
   back unused memory to the system, thus reducing program footprint.
 */
-#if __STD_C
 void     public_fREe(Void_t*);
-#else
-void     public_fREe();
-#endif
 /*
   calloc(size_t n_elements, size_t element_size);
   Returns a pointer to n_elements * element_size bytes, with all locations
   set to zero.
 */
-#if __STD_C
 Void_t*  public_cALLOc(size_t, size_t);
-#else
-Void_t*  public_cALLOc();
-#endif
 /*
   realloc(Void_t* p, size_t n)
   Returns a pointer to a chunk of size n that contains the same data
   as does chunk p up to the minimum of (n, p's size) bytes, or null
   the system supports MREMAP (currently only linux).
   The old unix realloc convention of allowing the last-free'd chunk
   to be used as an argument to realloc is not supported.
 */
-#if __STD_C
 Void_t*  public_rEALLOc(Void_t*, size_t);
-#else
-Void_t*  public_rEALLOc();
-#endif
 /*
   memalign(size_t alignment, size_t n);
   Returns a pointer to a newly allocated chunk of n bytes, aligned
   in accord with the alignment argument.
 -byte alignment is guaranteed by normal malloc calls, so don't
   bother calling memalign with an argument of 8 or less.
   Overreliance on memalign is a sure way to fragment space.
 */
-#if __STD_C
 Void_t*  public_mEMALIGn(size_t, size_t);
-#else
-Void_t*  public_mEMALIGn();
-#endif
 /*
   valloc(size_t n);
   Equivalent to memalign(pagesize, n), where pagesize is the page
   size of the system. If the pagesize is unknown, 4096 is used.
 */
-#if __STD_C
 Void_t*  public_vALLOc(size_t);
-#else
-Void_t*  public_vALLOc();
-#endif
 /*
   mallopt(int parameter_number, int parameter_value)
   Sets tunable parameters The format is to provide a
   M_TRIM_THRESHOLD -1         256*1024   any   (-1U disables trimming)
   M_TOP_PAD        -2         0          any
   M_MMAP_THRESHOLD -3         256*1024   any   (or 0 if no MMAP support)
   M_MMAP_MAX       -4         65536      any   (0 disables use of mmap)
 */
-#if __STD_C
 int      public_mALLOPt(int, int);
-#else
-int      public_mALLOPt();
-#endif
 /*
   mallinfo()
   Returns (by copy) a struct containing various summary statistics:
   Because these fields are ints, but internal bookkeeping may
   be kept as longs, the reported values may wrap around zero and
   thus be inaccurate.
 */
-#if __STD_C
 struct mallinfo public_mALLINFo(void);
-#else
-struct mallinfo public_mALLINFo();
-#endif
 /*
   independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
   independent_calloc is similar to calloc, but instead of returning a
       pool[i]->next = pool[i+1];
     free(pool);     // Can now free the array (or not, if it is needed later)
     return first;
+  }
 */
-#if __STD_C
 Void_t** public_iCALLOc(size_t, size_t, Void_t**);
-#else
-Void_t** public_iCALLOc();
-#endif
 /*
   independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
   independent_comalloc allocates, all at once, a set of n_elements
   Overuse of independent_comalloc can increase overall memory usage,
   since it cannot reuse existing noncontiguous small chunks that
   might be available for some of the elements.
 */
-#if __STD_C
 Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
-#else
-Void_t** public_iCOMALLOc();
-#endif
 /*
   pvalloc(size_t n);
   Equivalent to valloc(minimum-page-that-holds(n)), that is,
   round up n to nearest pagesize.
  */
-#if __STD_C
 Void_t*  public_pVALLOc(size_t);
-#else
-Void_t*  public_pVALLOc();
-#endif
 /*
   cfree(Void_t* p);
   Equivalent to free(p).
   cfree is needed/defined on some systems that pair it with calloc,
   for odd historical reasons (such as: cfree is used in example
   code in the first edition of K&R).
 */
-#if __STD_C
 void     public_cFREe(Void_t*);
-#else
-void     public_cFREe();
-#endif
 /*
   malloc_trim(size_t pad);
   If possible, gives memory back to the system (via negative
   Malloc_trim returns 1 if it actually released any memory, else 0.
   On systems that do not support "negative sbrks", it will always
   rreturn 0.
 */
-#if __STD_C
 int      public_mTRIm(size_t);
-#else
-int      public_mTRIm();
-#endif
 /*
   malloc_usable_size(Void_t* p);
   Returns the number of bytes you can actually use in
   p = malloc(n);
   assert(malloc_usable_size(p) >= 256);
 */
-#if __STD_C
 size_t   public_mUSABLe(Void_t*);
-#else
-size_t   public_mUSABLe();
-#endif
 /*
   malloc_stats();
   Prints on stderr the amount of space obtained from the system (both
   via sbrk and mmap), the maximum amount (which may be more than
   malloc_stats prints only the most commonly interesting statistics.
   More information can be obtained by calling mallinfo.
 */
-#if __STD_C
-void     public_mSTATs();
-#else
 void     public_mSTATs();
-#endif
 /* mallopt tuning options */
 /*
   M_MXFAST is the maximum request size used for "fastbins", special bins
 /* --------------------- public wrappers ---------------------- */
 #ifdef USE_PUBLIC_MALLOC_WRAPPERS
 /* Declare all routines as internal */
-#if __STD_C
 static Void_t*  mALLOc(size_t);
 static void     fREe(Void_t*);
 static Void_t*  rEALLOc(Void_t*, size_t);
 static Void_t*  mEMALIGn(size_t, size_t);
 static Void_t*  vALLOc(size_t);
 static int      mTRIm(size_t);
 static size_t   mUSABLe(Void_t*);
 static void     mSTATs();
 static int      mALLOPt(int, int);
 static struct mallinfo mALLINFo(void);
-#else
-static Void_t*  mALLOc();
-static void     fREe();
-static Void_t*  rEALLOc();
-static Void_t*  mEMALIGn();
-static Void_t*  vALLOc();
-static Void_t*  pVALLOc();
-static Void_t*  cALLOc();
-static Void_t** iCALLOc();
-static Void_t** iCOMALLOc();
-static void     cFREe();
-static int      mTRIm();
-static size_t   mUSABLe();
-static void     mSTATs();
-static int      mALLOPt();
-static struct mallinfo mALLINFo();
-#endif
 /*
   MALLOC_PREACTION and MALLOC_POSTACTION should be
   defined to return 0 on success, and nonzero on failure.
   The return value of MALLOC_POSTACTION is currently ignored
   outside of malloc_consolidate because some optimizing compilers try
   to inline it at all call points, which turns out not to be an
   optimization at all. (Inlining it in malloc_consolidate is fine though.)
 */
-#if __STD_C
 static void malloc_init_state(mstate av)
-#else
-static void malloc_init_state(av) mstate av;
-#endif
+{
   int     i;
   mbinptr bin;
   /* Establish circular links for normal bins */
 /*
    Other internal utilities operating on mstates
 */
-#if __STD_C
 static Void_t*  sYSMALLOc(INTERNAL_SIZE_T, mstate);
 #ifndef MORECORE_CANNOT_TRIM
 static int      sYSTRIm(size_t, mstate);
 #endif
 static void     malloc_consolidate(mstate);
 static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
-#else
-static Void_t*  sYSMALLOc();
-#ifndef MORECORE_CANNOT_TRIM
-static int      sYSTRIm();
-#endif
-static void     malloc_consolidate();
-static Void_t** iALLOc();
-#endif
 /*
   Debugging support
   These routines make a number of assertions about the states
 /*
   Properties of all chunks
 */
-#if __STD_C
 static void do_check_chunk(mchunkptr p)
-#else
-static void do_check_chunk(p) mchunkptr p;
-#endif
+{
   mstate av = get_malloc_state();
   CHUNK_SIZE_T  sz = chunksize(p);
   /* min and max possible addresses assuming contiguous allocation */
   char* max_address = (char*)(av->top) + chunksize(av->top);
 /*
   Properties of free chunks
 */
-#if __STD_C
 static void do_check_free_chunk(mchunkptr p)
-#else
-static void do_check_free_chunk(p) mchunkptr p;
-#endif
+{
   mstate av = get_malloc_state();
   INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
   mchunkptr next = chunk_at_offset(p, sz);
 /*
   Properties of inuse chunks
 */
-#if __STD_C
 static void do_check_inuse_chunk(mchunkptr p)
-#else
-static void do_check_inuse_chunk(p) mchunkptr p;
-#endif
+{
   mstate av = get_malloc_state();
   mchunkptr next;
   do_check_chunk(p);
 /*
   Properties of chunks recycled from fastbins
 */
-#if __STD_C
 static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-#else
-static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-#endif
+{
   INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
   do_check_inuse_chunk(p);
 /*
   Properties of nonrecycled chunks at the point they are malloced
 */
-#if __STD_C
 static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-#else
-static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-#endif
+{
   /* same as recycled case ... */
   do_check_remalloced_chunk(p, s);
   /*
   On entry, it is assumed that av->top does not have enough
   space to service request for nb bytes, thus requiring that av->top
   be extended or replaced.
 */
-#if __STD_C
 static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
-#else
-static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
-#endif
+{
   mchunkptr       old_top;        /* incoming value of av->top */
   INTERNAL_SIZE_T old_size;       /* its size */
   char*           old_end;        /* its end address */
   automatically by free() when top space exceeds the trim
   threshold. It is also called by the public malloc_trim routine.  It
   returns 1 if it actually released any memory, else 0.
 */
-#if __STD_C
 static int sYSTRIm(size_t pad, mstate av)
-#else
-static int sYSTRIm(pad, av) size_t pad; mstate av;
-#endif
+{
   long  top_size;        /* Amount of top-most memory */
   long  extra;           /* Amount to release */
   long  released;        /* Amount actually released */
   char* current_brk;     /* address returned by pre-check sbrk call */
 /*
   ------------------------------ malloc ------------------------------
 */
-#if __STD_C
 Void_t* mALLOc(size_t bytes)
-#else
-  Void_t* mALLOc(bytes) size_t bytes;
-#endif
+{
   mstate av = get_malloc_state();
   INTERNAL_SIZE_T nb;               /* normalized request size */
   unsigned int    idx;              /* associated bin index */
 /*
   ------------------------------ free ------------------------------
 */
-#if __STD_C
 void fREe(Void_t* mem)
-#else
-void fREe(mem) Void_t* mem;
-#endif
+{
   mstate av = get_malloc_state();
   mchunkptr       p;           /* chunk corresponding to mem */
   INTERNAL_SIZE_T size;        /* its size */
   Also, because this routine needs to be called the first time through
   malloc anyway, it turns out to be the perfect place to trigger
   initialization code.
 */
-#if __STD_C
 static void malloc_consolidate(mstate av)
-#else
-static void malloc_consolidate(av) mstate av;
-#endif
+{
   mfastbinptr*    fb;                 /* current fastbin being consolidated */
   mfastbinptr*    maxfb;              /* last fastbin (for loop control) */
   mchunkptr       p;                  /* current chunk being consolidated */
   mchunkptr       nextp;              /* next chunk to consolidate */
 /*
   ------------------------------ realloc ------------------------------
 */
-#if __STD_C
 Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
-#else
-Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
-#endif
+{
   mstate av = get_malloc_state();
   INTERNAL_SIZE_T  nb;              /* padded request size */
 /*
   ------------------------------ memalign ------------------------------
 */
-#if __STD_C
 Void_t* mEMALIGn(size_t alignment, size_t bytes)
-#else
-Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
-#endif
+{
   INTERNAL_SIZE_T nb;             /* padded  request size */
   char*           m;              /* memory returned by malloc call */
   mchunkptr       p;              /* corresponding chunk */
   char*           brk;            /* alignment point within p */
 /*
   ------------------------------ calloc ------------------------------
 */
-#if __STD_C
 Void_t* cALLOc(size_t n_elements, size_t elem_size)
-#else
-Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
-#endif
+{
   mchunkptr p;
   CHUNK_SIZE_T  clearsize;
   CHUNK_SIZE_T  nclears;
   INTERNAL_SIZE_T* d;
 /*
   ------------------------------ cfree ------------------------------
 */
-#if __STD_C
 void cFREe(Void_t *mem)
-#else
-void cFREe(mem) Void_t *mem;
-#endif
+{
   fREe(mem);
+}
 /*
   ------------------------- independent_calloc -------------------------
 */
-#if __STD_C
 Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
-#else
-Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
-#endif
+{
   size_t sz = elem_size; /* serves as 1-element array */
   /* opts arg of 3 means all elements are same size, and should be cleared */
   return iALLOc(n_elements, &sz, 3, chunks);
+}
 /*
   ------------------------- independent_comalloc -------------------------
 */
-#if __STD_C
 Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
-#else
-Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
-#endif
+{
   return iALLOc(n_elements, sizes, 0, chunks);
+}
     bit 0 set if all elements are same size (using sizes[0])
     bit 1 set if elements should be zeroed
 */
-#if __STD_C
 static Void_t** iALLOc(size_t n_elements,
                        size_t* sizes,
                        int opts,
                        Void_t* chunks[])
-#else
-static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
-#endif
+{
   mstate av = get_malloc_state();
   INTERNAL_SIZE_T element_size;   /* chunksize of each element, if all same */
   INTERNAL_SIZE_T contents_size;  /* total size of elements */
   INTERNAL_SIZE_T array_size;     /* request size of pointer array */
 /*
   ------------------------------ valloc ------------------------------
 */
-#if __STD_C
 Void_t* vALLOc(size_t bytes)
-#else
-Void_t* vALLOc(bytes) size_t bytes;
-#endif
+{
   /* Ensure initialization */
   mstate av = get_malloc_state();
   if (av->max_fast == 0) malloc_consolidate(av);
   return mEMALIGn(av->pagesize, bytes);
 /*
   ------------------------------ pvalloc ------------------------------
 */
-#if __STD_C
 Void_t* pVALLOc(size_t bytes)
-#else
-Void_t* pVALLOc(bytes) size_t bytes;
-#endif
+{
   mstate av = get_malloc_state();
   size_t pagesz;
   /* Ensure initialization */
 /*
   ------------------------------ malloc_trim ------------------------------
 */
-#if __STD_C
 int mTRIm(size_t pad)
-#else
-int mTRIm(pad) size_t pad;
-#endif
+{
   mstate av = get_malloc_state();
   /* Ensure initialization/consolidation */
   malloc_consolidate(av);
 /*
   ------------------------- malloc_usable_size -------------------------
 */
-#if __STD_C
 size_t mUSABLe(Void_t* mem)
-#else
-size_t mUSABLe(mem) Void_t* mem;
-#endif
+{
   mchunkptr p;
   if (mem != 0) {
     p = mem2chunk(mem);
     if (chunk_is_mmapped(p))
 /*
   ------------------------------ mallopt ------------------------------
 */
-#if __STD_C
 int mALLOPt(int param_number, int value)
-#else
-int mALLOPt(param_number, value) int param_number; int value;
-#endif
+{
   mstate av = get_malloc_state();
   /* Ensure initialization/consolidation */
   malloc_consolidate(av);

The R Project SVN R

(root)/trunk/src/gnuwin32/malloc.c @ 31849 – Rev 26945 → 29208