raw
vtools_genesis          1 #ifndef XALLOC_H_
vtools_genesis          2 #define XALLOC_H_
vtools_genesis          3 
vtools_genesis          4 #include <stddef.h>
vtools_genesis          5 #include <stdint.h>
vtools_genesis          6 #include "system.h"
vtools_genesis          7 
vtools_genesis          8 /* This function is always triggered when memory is exhausted.  It
vtools_genesis          9    must be defined by the application, either explicitly or by using
vtools_genesis         10    gnulib's xalloc-die module.  This is the function to call when one
vtools_genesis         11    wants the program to die because of a memory allocation
vtools_genesis         12    failure.  */
vdiff_fixes_newli...   13 extern void xalloc_die(void) __attribute__((noreturn));
vtools_genesis         14 
vtools_genesis         15 void *xmalloc(size_t s);
vtools_genesis         16 void *xzalloc(size_t s);
vtools_genesis         17 void *xcalloc(size_t n, size_t s);
vtools_genesis         18 void *xrealloc(void *p, size_t s);
vtools_genesis         19 void *x2realloc(void *p, size_t *pn);
vtools_genesis         20 void *xmemdup(void const *p, size_t s);
vtools_genesis         21 char *xstrdup(char const *str);
vtools_genesis         22 
vtools_genesis         23 /* In the following macros, |t| must be an elementary or
vtools_genesis         24    structure/union or typedef'ed type, or a pointer to such a type.
vtools_genesis         25    To apply one of the following macros to a function pointer or array
vtools_genesis         26    type, you need to typedef it first and use the typedef name.  */
vtools_genesis         27 
vtools_genesis         28 /* Allocate an object of type |t| dynamically, with error checking. */
vtools_genesis         29 #define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
vtools_genesis         30 
vtools_genesis         31 /* Allocate memory for |n| elements of type |t|, with error
vtools_genesis         32    checking. */
vtools_genesis         33 #define XNMALLOC(n, t) \
vtools_genesis         34    ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
vtools_genesis         35 
vtools_genesis         36 /* Allocate an object of type |t| dynamically, with error checking,
vtools_genesis         37    and zero it.  */
vtools_genesis         38 #define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
vtools_genesis         39 
vtools_genesis         40 /* Allocate memory for |n| elements of type |t|, with error checking,
vtools_genesis         41    and zero it.  */
vtools_genesis         42 #define XCALLOC(n, t) \
vtools_genesis         43    ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
vtools_genesis         44 
vtools_genesis         45 
vtools_genesis         46 /* Allocate an array of |n| objects, each with |s| bytes of memory,
vtools_genesis         47    dynamically, with error checking.  |s| must be nonzero.  */
vtools_genesis         48 
vtools_fixes_stat...   49 static inline void *xnmalloc(size_t n, size_t s);
vtools_genesis         50 
vtools_fixes_stat...   51 static inline void *
vtools_genesis         52 xnmalloc(size_t n, size_t s) {
vtools_genesis         53     if (xalloc_oversized (n, s))
vtools_genesis         54         xalloc_die();
vtools_genesis         55     return xmalloc(n * s);
vtools_genesis         56 }
vtools_genesis         57 
vtools_genesis         58 /* Change the size of an allocated block of memory |p| to an array of
vtools_genesis         59    |n| objects each of |s| bytes, with error checking.  |s| must be
vtools_genesis         60    nonzero.  */
vtools_genesis         61 
vtools_fixes_stat...   62 static inline void *xnrealloc(void *p, size_t n, size_t s);
vtools_genesis         63 
vtools_fixes_stat...   64 static inline void *
vtools_genesis         65 xnrealloc(void *p, size_t n, size_t s) {
vtools_genesis         66     if (xalloc_oversized (n, s))
vtools_genesis         67         xalloc_die();
vtools_genesis         68     return xrealloc(p, n * s);
vtools_genesis         69 }
vtools_genesis         70 
vtools_genesis         71 /* If |p| is |NULL|, allocate a block of at least |*pn| such objects;
vtools_genesis         72    otherwise, reallocate |p| so that it contains more than |*pn|
vtools_genesis         73    objects each of |s| bytes.  |s| must be nonzero.  Set |*pn| to the
vtools_genesis         74    new number of objects, and return the pointer to the new block.
vtools_genesis         75    |*PN| is never set to zero, and the returned pointer is never |NULL|.
vtools_genesis         76 
vtools_genesis         77    Repeated reallocations are guaranteed to make progress, either by
vtools_genesis         78    allocating an initial block with a nonzero size, or by allocating a
vtools_genesis         79    larger block.
vtools_genesis         80 
vtools_genesis         81    In the following implementation, nonzero sizes are increased by a
vtools_genesis         82    factor of approximately 1.5 so that repeated reallocations have
vtools_genesis         83    $O(N)$ overall cost rather than $O(N^2)$ cost, but the
vtools_genesis         84    specification for this function does not guarantee that rate.
vtools_genesis         85 
vtools_genesis         86    Here is an example of use:
vtools_genesis         87 
vtools_genesis         88      |int *p = NULL;
vtools_genesis         89      size_t used = 0;
vtools_genesis         90      size_t allocated = 0;
vtools_genesis         91 
vtools_genesis         92      void
vtools_genesis         93      append_int (int value)
vtools_genesis         94        {
vtools_genesis         95          if (used == allocated)
vtools_genesis         96            p = x2nrealloc (p, &allocated, sizeof *p);
vtools_genesis         97          p[used++] = value;
vtools_genesis         98        }|
vtools_genesis         99 
vtools_genesis        100    This causes |x2nrealloc| to allocate a block of some nonzero size
vtools_genesis        101    the first time it is called.
vtools_genesis        102 
vtools_genesis        103    To have finer-grained control over the initial size, set |*pn| to a
vtools_genesis        104    nonzero value before calling this function with |p == NULL|.  For
vtools_genesis        105    example:
vtools_genesis        106 
vtools_genesis        107      |int *p = NULL;
vtools_genesis        108      size_t used = 0;
vtools_genesis        109      size_t allocated = 0;
vtools_genesis        110      size_t allocated1 = 1000;
vtools_genesis        111 
vtools_genesis        112      void
vtools_genesis        113      append_int (int value)
vtools_genesis        114        {
vtools_genesis        115          if (used == allocated)
vtools_genesis        116            {
vtools_genesis        117              p = x2nrealloc (p, &allocated1, sizeof *p);
vtools_genesis        118              allocated = allocated1;
vtools_genesis        119            }
vtools_genesis        120          p[used++] = value;
vtools_genesis        121        }|
vtools_genesis        122 
vtools_genesis        123    */
vtools_genesis        124 
vtools_genesis        125 static inline void *
vtools_genesis        126 x2nrealloc(void *p, size_t *pn, size_t s) {
vtools_genesis        127     size_t n = *pn;
vtools_genesis        128 
vtools_genesis        129     if (!p) {
vtools_genesis        130         if (!n) {
vtools_genesis        131             /* The approximate size to use for initial small
vtools_genesis        132                allocation requests, when the invoking code specifies
vtools_genesis        133                an old size of zero.  This is the largest "small"
vtools_genesis        134                request for the GNU C library malloc.  */
vtools_genesis        135             enum {
vtools_genesis        136                 DEFAULT_MXFAST = 64 * sizeof(size_t) / 4
vtools_genesis        137             };
vtools_genesis        138 
vtools_genesis        139             n = DEFAULT_MXFAST / s;
vtools_genesis        140             n += !n;
vtools_genesis        141         }
vtools_genesis        142         if (xalloc_oversized (n, s))
vtools_genesis        143             xalloc_die();
vtools_genesis        144     } else {
vtools_genesis        145         /* Set $n = \lfloor 1.5 * n \rfloor + 1$ so that progress is
vtools_genesis        146            made even if $n = 0$.  Check for overflow, so that $n * s$
vtools_genesis        147            stays in both |ptrdiff_t| and |size_t| range.  The check
vtools_genesis        148            may be slightly conservative, but an exact check isn't
vtools_genesis        149            worth the trouble.  */
vtools_genesis        150         if ((PTRDIFF_MAX < SIZE_MAX ? PTRDIFF_MAX : SIZE_MAX) / 3 * 2 / s
vtools_genesis        151             <= n)
vtools_genesis        152             xalloc_die();
vtools_genesis        153         n += n / 2 + 1;
vtools_genesis        154     }
vtools_genesis        155 
vtools_genesis        156     *pn = n;
vtools_genesis        157     return xrealloc(p, n * s);
vtools_genesis        158 }
vtools_genesis        159 
vtools_genesis        160 /* Return a pointer to a new buffer of |n| bytes.  This is like
vtools_genesis        161    xmalloc, except it returns |char *|.  */
vtools_genesis        162 
vtools_genesis        163 static inline char *xcharalloc(size_t n);
vtools_genesis        164 
vtools_genesis        165 static inline char *
vtools_genesis        166 xcharalloc(size_t n) {
vtools_genesis        167     return XNMALLOC (n, char);
vtools_genesis        168 }
vtools_genesis        169 
vtools_genesis        170 #endif