OLD | NEW |
(Empty) | |
| 1 /* xalloc.h -- malloc with out-of-memory checking |
| 2 |
| 3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
| 4 1999, 2000, 2003, 2004, 2006, 2007, 2008 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 3 of the License, or |
| 9 (at your option) 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, see <http://www.gnu.org/licenses/>. */ |
| 18 |
| 19 #ifndef XALLOC_H_ |
| 20 # define XALLOC_H_ |
| 21 |
| 22 # include <stddef.h> |
| 23 |
| 24 |
| 25 # ifdef __cplusplus |
| 26 extern "C" { |
| 27 # endif |
| 28 |
| 29 |
| 30 # ifndef __attribute__ |
| 31 # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8) |
| 32 # define __attribute__(x) |
| 33 # endif |
| 34 # endif |
| 35 |
| 36 # ifndef ATTRIBUTE_NORETURN |
| 37 # define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__)) |
| 38 # endif |
| 39 |
| 40 # ifndef ATTRIBUTE_MALLOC |
| 41 # if __GNUC__ >= 3 |
| 42 # define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) |
| 43 # else |
| 44 # define ATTRIBUTE_MALLOC |
| 45 # endif |
| 46 # endif |
| 47 |
| 48 /* This function is always triggered when memory is exhausted. |
| 49 It must be defined by the application, either explicitly |
| 50 or by using gnulib's xalloc-die module. This is the |
| 51 function to call when one wants the program to die because of a |
| 52 memory allocation failure. */ |
| 53 extern void xalloc_die (void) ATTRIBUTE_NORETURN; |
| 54 |
| 55 void *xmalloc (size_t s) ATTRIBUTE_MALLOC; |
| 56 void *xzalloc (size_t s) ATTRIBUTE_MALLOC; |
| 57 void *xcalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; |
| 58 void *xrealloc (void *p, size_t s); |
| 59 void *x2realloc (void *p, size_t *pn); |
| 60 void *xmemdup (void const *p, size_t s) ATTRIBUTE_MALLOC; |
| 61 char *xstrdup (char const *str) ATTRIBUTE_MALLOC; |
| 62 |
| 63 /* Return 1 if an array of N objects, each of size S, cannot exist due |
| 64 to size arithmetic overflow. S must be positive and N must be |
| 65 nonnegative. This is a macro, not an inline function, so that it |
| 66 works correctly even when SIZE_MAX < N. |
| 67 |
| 68 By gnulib convention, SIZE_MAX represents overflow in size |
| 69 calculations, so the conservative dividend to use here is |
| 70 SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value. |
| 71 However, malloc (SIZE_MAX) fails on all known hosts where |
| 72 sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for |
| 73 exactly-SIZE_MAX allocations on such hosts; this avoids a test and |
| 74 branch when S is known to be 1. */ |
| 75 # define xalloc_oversized(n, s) \ |
| 76 ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n)) |
| 77 |
| 78 |
| 79 /* In the following macros, T must be an elementary or structure/union or |
| 80 typedef'ed type, or a pointer to such a type. To apply one of the |
| 81 following macros to a function pointer or array type, you need to typedef |
| 82 it first and use the typedef name. */ |
| 83 |
| 84 /* Allocate an object of type T dynamically, with error checking. */ |
| 85 /* extern t *XMALLOC (typename t); */ |
| 86 # define XMALLOC(t) ((t *) xmalloc (sizeof (t))) |
| 87 |
| 88 /* Allocate memory for N elements of type T, with error checking. */ |
| 89 /* extern t *XNMALLOC (size_t n, typename t); */ |
| 90 # define XNMALLOC(n, t) \ |
| 91 ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t)))) |
| 92 |
| 93 /* Allocate an object of type T dynamically, with error checking, |
| 94 and zero it. */ |
| 95 /* extern t *XZALLOC (typename t); */ |
| 96 # define XZALLOC(t) ((t *) xzalloc (sizeof (t))) |
| 97 |
| 98 /* Allocate memory for N elements of type T, with error checking, |
| 99 and zero it. */ |
| 100 /* extern t *XCALLOC (size_t n, typename t); */ |
| 101 # define XCALLOC(n, t) \ |
| 102 ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t)))) |
| 103 |
| 104 |
| 105 # if HAVE_INLINE |
| 106 # define static_inline static inline |
| 107 # else |
| 108 void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; |
| 109 void *xnrealloc (void *p, size_t n, size_t s); |
| 110 void *x2nrealloc (void *p, size_t *pn, size_t s); |
| 111 char *xcharalloc (size_t n) ATTRIBUTE_MALLOC; |
| 112 # endif |
| 113 |
| 114 # ifdef static_inline |
| 115 |
| 116 /* Allocate an array of N objects, each with S bytes of memory, |
| 117 dynamically, with error checking. S must be nonzero. */ |
| 118 |
| 119 static_inline void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; |
| 120 static_inline void * |
| 121 xnmalloc (size_t n, size_t s) |
| 122 { |
| 123 if (xalloc_oversized (n, s)) |
| 124 xalloc_die (); |
| 125 return xmalloc (n * s); |
| 126 } |
| 127 |
| 128 /* Change the size of an allocated block of memory P to an array of N |
| 129 objects each of S bytes, with error checking. S must be nonzero. */ |
| 130 |
| 131 static_inline void * |
| 132 xnrealloc (void *p, size_t n, size_t s) |
| 133 { |
| 134 if (xalloc_oversized (n, s)) |
| 135 xalloc_die (); |
| 136 return xrealloc (p, n * s); |
| 137 } |
| 138 |
| 139 /* If P is null, allocate a block of at least *PN such objects; |
| 140 otherwise, reallocate P so that it contains more than *PN objects |
| 141 each of S bytes. *PN must be nonzero unless P is null, and S must |
| 142 be nonzero. Set *PN to the new number of objects, and return the |
| 143 pointer to the new block. *PN is never set to zero, and the |
| 144 returned pointer is never null. |
| 145 |
| 146 Repeated reallocations are guaranteed to make progress, either by |
| 147 allocating an initial block with a nonzero size, or by allocating a |
| 148 larger block. |
| 149 |
| 150 In the following implementation, nonzero sizes are increased by a |
| 151 factor of approximately 1.5 so that repeated reallocations have |
| 152 O(N) overall cost rather than O(N**2) cost, but the |
| 153 specification for this function does not guarantee that rate. |
| 154 |
| 155 Here is an example of use: |
| 156 |
| 157 int *p = NULL; |
| 158 size_t used = 0; |
| 159 size_t allocated = 0; |
| 160 |
| 161 void |
| 162 append_int (int value) |
| 163 { |
| 164 if (used == allocated) |
| 165 p = x2nrealloc (p, &allocated, sizeof *p); |
| 166 p[used++] = value; |
| 167 } |
| 168 |
| 169 This causes x2nrealloc to allocate a block of some nonzero size the |
| 170 first time it is called. |
| 171 |
| 172 To have finer-grained control over the initial size, set *PN to a |
| 173 nonzero value before calling this function with P == NULL. For |
| 174 example: |
| 175 |
| 176 int *p = NULL; |
| 177 size_t used = 0; |
| 178 size_t allocated = 0; |
| 179 size_t allocated1 = 1000; |
| 180 |
| 181 void |
| 182 append_int (int value) |
| 183 { |
| 184 if (used == allocated) |
| 185 { |
| 186 p = x2nrealloc (p, &allocated1, sizeof *p); |
| 187 allocated = allocated1; |
| 188 } |
| 189 p[used++] = value; |
| 190 } |
| 191 |
| 192 */ |
| 193 |
| 194 static_inline void * |
| 195 x2nrealloc (void *p, size_t *pn, size_t s) |
| 196 { |
| 197 size_t n = *pn; |
| 198 |
| 199 if (! p) |
| 200 { |
| 201 if (! n) |
| 202 { |
| 203 /* The approximate size to use for initial small allocation |
| 204 requests, when the invoking code specifies an old size of |
| 205 zero. 64 bytes is the largest "small" request for the |
| 206 GNU C library malloc. */ |
| 207 enum { DEFAULT_MXFAST = 64 }; |
| 208 |
| 209 n = DEFAULT_MXFAST / s; |
| 210 n += !n; |
| 211 } |
| 212 } |
| 213 else |
| 214 { |
| 215 /* Set N = ceil (1.5 * N) so that progress is made if N == 1. |
| 216 Check for overflow, so that N * S stays in size_t range. |
| 217 The check is slightly conservative, but an exact check isn't |
| 218 worth the trouble. */ |
| 219 if ((size_t) -1 / 3 * 2 / s <= n) |
| 220 xalloc_die (); |
| 221 n += (n + 1) / 2; |
| 222 } |
| 223 |
| 224 *pn = n; |
| 225 return xrealloc (p, n * s); |
| 226 } |
| 227 |
| 228 /* Return a pointer to a new buffer of N bytes. This is like xmalloc, |
| 229 except it returns char *. */ |
| 230 |
| 231 static_inline char *xcharalloc (size_t n) ATTRIBUTE_MALLOC; |
| 232 static_inline char * |
| 233 xcharalloc (size_t n) |
| 234 { |
| 235 return XNMALLOC (n, char); |
| 236 } |
| 237 |
| 238 # endif |
| 239 |
| 240 # ifdef __cplusplus |
| 241 } |
| 242 |
| 243 /* C++ does not allow conversions from void * to other pointer types |
| 244 without a cast. Use templates to work around the problem when |
| 245 possible. */ |
| 246 |
| 247 template <typename T> inline T * |
| 248 xrealloc (T *p, size_t s) |
| 249 { |
| 250 return (T *) xrealloc ((void *) p, s); |
| 251 } |
| 252 |
| 253 template <typename T> inline T * |
| 254 xnrealloc (T *p, size_t n, size_t s) |
| 255 { |
| 256 return (T *) xnrealloc ((void *) p, n, s); |
| 257 } |
| 258 |
| 259 template <typename T> inline T * |
| 260 x2realloc (T *p, size_t *pn) |
| 261 { |
| 262 return (T *) x2realloc ((void *) p, pn); |
| 263 } |
| 264 |
| 265 template <typename T> inline T * |
| 266 x2nrealloc (T *p, size_t *pn, size_t s) |
| 267 { |
| 268 return (T *) x2nrealloc ((void *) p, pn, s); |
| 269 } |
| 270 |
| 271 template <typename T> inline T * |
| 272 xmemdup (T const *p, size_t s) |
| 273 { |
| 274 return (T *) xmemdup ((void const *) p, s); |
| 275 } |
| 276 |
| 277 # endif |
| 278 |
| 279 |
| 280 #endif /* !XALLOC_H_ */ |
OLD | NEW |