#    define malloc_getpagesize sysconf(_SC_PAGE_SIZE)#  else#    if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)       extern size_t getpagesize();#      define malloc_getpagesize getpagesize()#    else#      ifdef WIN32 /* use supplied emulation of getpagesize */#        define malloc_getpagesize getpagesize() #      else#        ifndef LACKS_SYS_PARAM_H#          include <sys/param.h>#        endif#        ifdef EXEC_PAGESIZE#          define malloc_getpagesize EXEC_PAGESIZE#        else#          ifdef NBPG#            ifndef CLSIZE#              define malloc_getpagesize NBPG#            else#              define malloc_getpagesize (NBPG * CLSIZE)#            endif#          else#            ifdef NBPC#              define malloc_getpagesize NBPC#            else#              ifdef PAGESIZE#                define malloc_getpagesize PAGESIZE#              else /* just guess */#                define malloc_getpagesize (4096) #              endif#            endif#          endif#        endif#      endif#    endif#  endif#endif/*  This version of malloc supports the standard SVID/XPG mallinfo  routine that returns a struct containing usage properties and  statistics. It should work on any SVID/XPG compliant system that has  a /usr/include/malloc.h defining struct mallinfo. (If you'd like to  install such a thing yourself, cut out the preliminary declarations  as described above and below and save them in a malloc.h file. But  there's no compelling reason to bother to do this.)  The main declaration needed is the mallinfo struct that is returned  (by-copy) by mallinfo().  The SVID/XPG malloinfo struct contains a  bunch of field that are not even meaningful in this version of  malloc.  These fields are are instead filled by mallinfo() with  other numbers that might be of interest.  HAVE_USR_INCLUDE_MALLOC_H should be set if you have a  /usr/include/malloc.h file that includes a declaration of struct  mallinfo.  If so, it is included; else an SVID2/XPG2 compliant  version is declared below.  These must be precisely the same for  mallinfo() to work.  The original SVID version of this struct,  defined on most systems with mallinfo, declares all fields as  ints. But some others define as unsigned long. If your system  defines the fields using a type of different width than listed here,  you must #include your system version and #define  HAVE_USR_INCLUDE_MALLOC_H.*//* #define HAVE_USR_INCLUDE_MALLOC_H *//*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/#if 0#include "/usr/include/malloc.h"#else/* SVID2/XPG mallinfo structure */struct mallinfo {  int arena;    /* non-mmapped space allocated from system */  int ordblks;  /* number of free chunks */  int smblks;   /* number of fastbin blocks */  int hblks;    /* number of mmapped regions */  int hblkhd;   /* space in mmapped regions */  int usmblks;  /* maximum total allocated space */  int fsmblks;  /* space available in freed fastbin blocks */  int uordblks; /* total allocated space */  int fordblks; /* total free space */  int keepcost; /* top-most, releasable (via malloc_trim) space */};/*  SVID/XPG defines four standard parameter numbers for mallopt,  normally defined in malloc.h.  Only one of these (M_MXFAST) is used  in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,  so setting them has no effect. But this malloc also supports other  options in mallopt described below.*/#endif/* ---------- description of public routines ------------ *//*  malloc(size_t n)  Returns a pointer to a newly allocated chunk of at least n bytes, or null  if no space is available. Additionally, on failure, errno is  set to ENOMEM on ANSI C systems.  If n is zero, malloc returns a minumum-sized chunk. (The minimum  size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit  systems.)  On most systems, size_t is an unsigned type, so calls  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_CVoid_t*  public_mALLOc(size_t);#elseVoid_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.  It has no effect if p is null. It can have arbitrary (i.e., bad!)  effects if p has already been freed.  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_Cvoid     public_fREe(Void_t*);#elsevoid     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_CVoid_t*  public_cALLOc(size_t, size_t);#elseVoid_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  if no space is available.   The returned pointer may or may not be the same as p. The algorithm  prefers extending p when possible, otherwise it employs the  equivalent of a malloc-copy-free sequence.  If p is null, realloc is equivalent to malloc.    If space is not available, realloc returns null, errno is set (if on  ANSI) and p is NOT freed.  if n is for fewer bytes than already held by p, the newly unused  space is lopped off and freed if possible.  Unless the #define  REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of  zero (re)allocates a minimum-sized chunk.  Large chunks that were internally obtained via mmap will always  be reallocated using malloc-copy-free sequences unless  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_CVoid_t*  public_rEALLOc(Void_t*, size_t);#elseVoid_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.  The alignment argument should be a power of two. If the argument is  not a power of two, the nearest greater power is used.  8-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_CVoid_t*  public_mEMALIGn(size_t, size_t);#elseVoid_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_CVoid_t*  public_vALLOc(size_t);#elseVoid_t*  public_vALLOc();#endif/*  mallopt(int parameter_number, int parameter_value)  Sets tunable parameters The format is to provide a  (parameter-number, parameter-value) pair.  mallopt then sets the  corresponding parameter to the argument value if it can (i.e., so  long as the value is meaningful), and returns 1 if successful else  0.  SVID/XPG/ANSI defines four standard param numbers for mallopt,  normally defined in malloc.h.  Only one of these (M_MXFAST) is used  in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,  so setting them has no effect. But this malloc also supports four  other options in mallopt. See below for details.  Briefly, supported  parameters are as follows (listed defaults are for "typical"  configurations).  Symbol            param #   default    allowed param values  M_MXFAST          1         64         0-80  (0 disables fastbins)  M_TRIM_THRESHOLD -1         128*1024   any   (-1U disables trimming)  M_TOP_PAD        -2         0          any    M_MMAP_THRESHOLD -3         128*1024   any   (or 0 if no MMAP support)  M_MMAP_MAX       -4         65536      any   (0 disables use of mmap)*/#if __STD_Cint      public_mALLOPt(int, int);#elseint      public_mALLOPt();#endif/*  mallinfo()  Returns (by copy) a struct containing various summary statistics:  arena:     current total non-mmapped bytes allocated from system   ordblks:   the number of free chunks   smblks:    the number of fastbin blocks (i.e., small chunks that               have been freed but not use resused or consolidated)  hblks:     current number of mmapped regions   hblkhd:    total bytes held in mmapped regions   usmblks:   the maximum total allocated space. This will be greater                than current total if trimming has occurred.  fsmblks:   total bytes held in fastbin blocks   uordblks:  current total allocated space (normal or mmapped)  fordblks:  total free space   keepcost:  the maximum number of bytes that could ideally be released               back to system via malloc_trim. ("ideally" means that               it ignores page restrictions etc.)  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_Cstruct mallinfo public_mALLINFo(void);#elsestruct 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  single cleared space, it returns an array of pointers to n_elements  independent elements that can hold contents of size elem_size, each  of which starts out cleared, and can be independently freed,  realloc'ed etc. The elements are guaranteed to be adjacently  allocated (this is not guaranteed to occur with multiple callocs or  mallocs), which may also improve cache locality in some  applications.  The "chunks" argument is optional (i.e., may be null, which is  probably the most typical usage). If it is null, the returned array  is itself dynamically allocated and should also be freed when it is  no longer needed. Otherwise, the chunks array must be of at least  n_elements in length. It is filled in with the pointers to the  chunks.  In either case, independent_calloc returns this pointer array, or  null if the allocation failed.  If n_elements is zero and "chunks"  is null, it returns a chunk representing an array with zero elements  (which should be freed if not wanted).  Each element must be individually freed when it is no longer  needed. If you'd like to instead be able to free all at once, you  should instead use regular calloc and assign pointers into this  space to represent elements.  (In this case though, you cannot  independently free elements.)    independent_calloc simplifies and speeds up implementations of many  kinds of pools.  It may also be useful when constructing large data  structures that initially have a fixed number of fixed-sized nodes,  but the number is not known at compile time, and some of the nodes  may later need to be freed. For example:  struct Node { int item; struct Node* next; };    struct Node* build_list() {    struct Node** pool;    int n = read_number_of_nodes_needed();    if (n <= 0) return 0;    pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);    if (pool == 0) die();     // organize into a linked list...     struct Node* first = pool[0];    for (i = 0; i < n-1; ++i)       pool[i]->next = pool[i+1];    free(pool);     // Can now free the array (or not, if it is needed later)    return first;  }*/#if __STD_CVoid_t** public_iCALLOc(size_t, size_t, Void_t**);#elseVoid_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  chunks with sizes indicated in the "sizes" array.    It returns  an array of pointers to these elements, each of which can be  independently freed, realloc'ed etc. The elements are guaranteed to  be adjacently allocated (this is not guaranteed to occur with  multiple callocs or mallocs), which may also improve cache locality  in some applications.  The "chunks" argument is optional (i.e., may be null). If it is null  the returned array is itself dynamically allocated and should also  be freed when it is no longer needed. Otherwise, the chunks array  must be of at least n_elements in length. It is filled in with the  pointers to the chunks.  In either case, independent_comalloc returns this pointer array, or  null if the allocation failed.  If n_elements is zero and chunks is  null, it returns a chunk representing an array with zero elements  (which should be freed if not wanted).    Each element must be individually freed when it is no longer  needed. If you'd like to instead be able to free all at once, you  should instead use a single regular malloc, and assign pointers at  particular offsets in the aggregate space. (In this case though, you   cannot independently free elements.)  independent_comallac differs from independent_calloc in that each  element may have a different size, and also that it does not  automatically clear elements.  independent_comalloc can be used to speed up allocation in cases  where several structs or objects must always be allocated at the  same time.  For example:  struct Head { ... }  struct Foot { ... }  void send_message(char* msg) {    int msglen = strlen(msg);    size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };    void* chunks[3];    if (independent_comalloc(3, sizes, chunks) == 0)      die();    struct Head* head = (struct Head*)(chunks[0]);    char*        body = (char*)(chunks[1]);    struct Foot* foot = (struct Foot*)(chunks[2]);    // ...  }  In general though, independent_comalloc is worth using only for  larger values of n_elements. For small values, you probably won't  detect enough difference from series of malloc calls to bother.  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_CVoid_t** public_iCOMALLOc(size_t, size_t*, Void_t**);#elseVoid_t** public_iCOMALLOc();#endif/*  pvalloc(size_t n);  Equivalent to valloc(minimum-page-that-holds(n)), that is,  round up n to nearest pagesize.