contrib/diffutils-2.8/lib/xmalloc.c

   1 /* xmalloc.c -- malloc with out of memory checking
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2003,
   4    1999, 2000, 2002, 2003 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software Foundation,
  18    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #if HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include "xalloc.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "gettext.h"
  30 #define _(msgid) gettext (msgid)
  31 #define N_(msgid) msgid
  32
  33 #include "error.h"
  34 #include "exitfail.h"
  35
  36 #ifndef SIZE_MAX
  37 # define SIZE_MAX ((size_t) -1)
  38 #endif
  39
  40 #ifndef HAVE_MALLOC
  41 "you must run the autoconf test for a GNU libc compatible malloc"
  42 #endif
  43
  44 #ifndef HAVE_REALLOC
  45 "you must run the autoconf test for a GNU libc compatible realloc"
  46 #endif
  47
  48 /* If non NULL, call this function when memory is exhausted. */
  49 void (*xalloc_fail_func) (void) = 0;
  50
  51 /* If XALLOC_FAIL_FUNC is NULL, or does return, display this message
  52    before exiting when memory is exhausted.  Goes through gettext. */
  53 char const xalloc_msg_memory_exhausted[] = N_("memory exhausted");
  54
  55 void
  56 xalloc_die (void)
  57 {
  58   if (xalloc_fail_func)
  59     (*xalloc_fail_func) ();
  60   error (exit_failure, 0, "%s", _(xalloc_msg_memory_exhausted));
  61   /* The `noreturn' cannot be given to error, since it may return if
  62      its first argument is 0.  To help compilers understand the
  63      xalloc_die does terminate, call abort.  */
  64   abort ();
  65 }
  66
  67 /* Allocate an array of N objects, each with S bytes of memory,
  68    dynamically, with error checking.  S must be nonzero.  */
  69
  70 static inline void *
  71 xnmalloc_inline (size_t n, size_t s)
  72 {
  73   void *p;
  74   if (xalloc_oversized (n, s) || ! (p = malloc (n * s)))
  75     xalloc_die ();
  76   return p;
  77 }
  78
  79 void *
  80 xnmalloc (size_t n, size_t s)
  81 {
  82   return xnmalloc_inline (n, s);
  83 }
  84
  85 /* Allocate N bytes of memory dynamically, with error checking.  */
  86
  87 void *
  88 xmalloc (size_t n)
  89 {
  90   return xnmalloc_inline (n, 1);
  91 }
  92
  93 /* Change the size of an allocated block of memory P to an array of N
  94    objects each of S bytes, with error checking.  S must be nonzero.  */
  95
  96 static inline void *
  97 xnrealloc_inline (void *p, size_t n, size_t s)
  98 {
  99   if (xalloc_oversized (n, s) || ! (p = realloc (p, n * s)))
 100     xalloc_die ();
 101   return p;
 102 }
 103
 104 void *
 105 xnrealloc (void *p, size_t n, size_t s)
 106 {
 107   return xnrealloc_inline (p, n, s);
 108 }
 109
 110 /* Change the size of an allocated block of memory P to N bytes,
 111    with error checking.  */
 112
 113 void *
 114 xrealloc (void *p, size_t n)
 115 {
 116   return xnrealloc_inline (p, n, 1);
 117 }
 118
 119
 120 /* If P is null, allocate a block of at least *PN such objects;
 121    otherwise, reallocate P so that it contains more than *PN objects
 122    each of S bytes.  *PN must be nonzero unless P is null, and S must
 123    be nonzero.  Set *PN to the new number of objects, and return the
 124    pointer to the new block.  *PN is never set to zero, and the
 125    returned pointer is never null.
 126
 127    Repeated reallocations are guaranteed to make progress, either by
 128    allocating an initial block with a nonzero size, or by allocating a
 129    larger block.
 130
 131    In the following implementation, nonzero sizes are doubled so that
 132    repeated reallocations have O(N log N) overall cost rather than
 133    O(N**2) cost, but the specification for this function does not
 134    guarantee that sizes are doubled.
 135
 136    Here is an example of use:
 137
 138      int *p = NULL;
 139      size_t used = 0;
 140      size_t allocated = 0;
 141
 142      void
 143      append_int (int value)
 144        {
 145          if (used == allocated)
 146            p = x2nrealloc (p, &allocated, sizeof *p);
 147          p[used++] = value;
 148        }
 149
 150    This causes x2nrealloc to allocate a block of some nonzero size the
 151    first time it is called.
 152
 153    To have finer-grained control over the initial size, set *PN to a
 154    nonzero value before calling this function with P == NULL.  For
 155    example:
 156
 157      int *p = NULL;
 158      size_t used = 0;
 159      size_t allocated = 0;
 160      size_t allocated1 = 1000;
 161
 162      void
 163      append_int (int value)
 164        {
 165          if (used == allocated)
 166            {
 167              p = x2nrealloc (p, &allocated1, sizeof *p);
 168              allocated = allocated1;
 169            }
 170          p[used++] = value;
 171        }
 172
 173    */
 174
 175 static inline void *
 176 x2nrealloc_inline (void *p, size_t *pn, size_t s)
 177 {
 178   size_t n = *pn;
 179
 180   if (! p)
 181     {
 182       if (! n)
 183         {
 184           /* The approximate size to use for initial small allocation
 185              requests, when the invoking code specifies an old size of
 186              zero.  64 bytes is the largest "small" request for the
 187              GNU C library malloc.  */
 188           enum { DEFAULT_MXFAST = 64 };
 189
 190           n = DEFAULT_MXFAST / s;
 191           n += !n;
 192         }
 193     }
 194   else
 195     {
 196       if (SIZE_MAX / 2 / s < n)
 197         xalloc_die ();
 198       n *= 2;
 199     }
 200
 201   *pn = n;
 202   return xrealloc (p, n * s);
 203 }
 204
 205 void *
 206 x2nrealloc (void *p, size_t *pn, size_t s)
 207 {
 208   return x2nrealloc_inline (p, pn, s);
 209 }
 210
 211 /* If P is null, allocate a block of at least *PN bytes; otherwise,
 212    reallocate P so that it contains more than *PN bytes.  *PN must be
 213    nonzero unless P is null.  Set *PN to the new block's size, and
 214    return the pointer to the new block.  *PN is never set to zero, and
 215    the returned pointer is never null.  */
 216
 217 void *
 218 x2realloc (void *p, size_t *pn)
 219 {
 220   return x2nrealloc_inline (p, pn, 1);
 221 }
 222
 223 /* Allocate S bytes of zeroed memory dynamically, with error checking.
 224    There's no need for xnzalloc (N, S), since it would be equivalent
 225    to xcalloc (N, S).  */
 226
 227 void *
 228 xzalloc (size_t s)
 229 {
 230   return memset (xmalloc (s), 0, s);
 231 }
 232
 233 /* Allocate zeroed memory for N elements of S bytes, with error
 234    checking.  S must be nonzero.  */
 235
 236 void *
 237 xcalloc (size_t n, size_t s)
 238 {
 239   void *p;
 240   /* Test for overflow, since some calloc implementations don't have
 241      proper overflow checks.  */
 242   if (xalloc_oversized (n, s) || ! (p = calloc (n, s)))
 243     xalloc_die ();
 244   return p;
 245 }
 246
 247 /* Clone an object P of size S, with error checking.  There's no need
 248    for xnclone (P, N, S), since xclone (P, N * S) works without any
 249    need for an arithmetic overflow check.  */
 250
 251 void *
 252 xclone (void const *p, size_t s)
 253 {
 254   return memcpy (xmalloc (s), p, s);
 255 }