36
38
# define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
39
/* If this pointer is non-zero, run the specified function upon each
40
allocation failure. It is initialized to zero. */
41
extern void (*xalloc_fail_func) PARAMS ((void));
43
/* If XALLOC_FAIL_FUNC is undefined or a function that returns, this
44
message is output. It is translated via gettext.
45
Its value is "memory exhausted". */
46
extern char const xalloc_msg_memory_exhausted[];
48
/* This function is always triggered when memory is exhausted. It is
49
in charge of honoring the three previous items. This is the
41
# ifndef ATTRIBUTE_MALLOC
43
# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
45
# define ATTRIBUTE_MALLOC
49
/* This function is always triggered when memory is exhausted.
50
It must be defined by the application, either explicitly
51
or by using gnulib's xalloc-die module. This is the
50
52
function to call when one wants the program to die because of a
51
53
memory allocation failure. */
52
extern void xalloc_die PARAMS ((void)) ATTRIBUTE_NORETURN;
54
void *xmalloc PARAMS ((size_t n));
55
void *xcalloc PARAMS ((size_t n, size_t s));
56
void *xrealloc PARAMS ((void *p, size_t n));
57
char *xstrdup PARAMS ((const char *str));
59
# define XMALLOC(Type, N_items) ((Type *) xmalloc (sizeof (Type) * (N_items)))
60
# define XCALLOC(Type, N_items) ((Type *) xcalloc (sizeof (Type), (N_items)))
61
# define XREALLOC(Ptr, Type, N_items) \
62
((Type *) xrealloc ((void *) (Ptr), sizeof (Type) * (N_items)))
64
/* Declare and alloc memory for VAR of type TYPE. */
65
# define NEW(Type, Var) Type *(Var) = XMALLOC (Type, 1)
67
/* Free VAR only if non NULL. */
74
/* Return a pointer to a malloc'ed copy of the array SRC of NUM elements. */
75
# define CCLONE(Src, Num) \
76
(memcpy (xmalloc (sizeof (*Src) * (Num)), (Src), sizeof (*Src) * (Num)))
78
/* Return a malloc'ed copy of SRC. */
79
# define CLONE(Src) CCLONE (Src, 1)
54
extern void xalloc_die (void) ATTRIBUTE_NORETURN;
56
void *xmalloc (size_t s) ATTRIBUTE_MALLOC;
57
void *xzalloc (size_t s) ATTRIBUTE_MALLOC;
58
void *xcalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
59
void *xrealloc (void *p, size_t s);
60
void *x2realloc (void *p, size_t *pn);
61
void *xmemdup (void const *p, size_t s) ATTRIBUTE_MALLOC;
62
char *xstrdup (char const *str) ATTRIBUTE_MALLOC;
64
/* Return 1 if an array of N objects, each of size S, cannot exist due
65
to size arithmetic overflow. S must be positive and N must be
66
nonnegative. This is a macro, not an inline function, so that it
67
works correctly even when SIZE_MAX < N.
69
By gnulib convention, SIZE_MAX represents overflow in size
70
calculations, so the conservative dividend to use here is
71
SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value.
72
However, malloc (SIZE_MAX) fails on all known hosts where
73
sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for
74
exactly-SIZE_MAX allocations on such hosts; this avoids a test and
75
branch when S is known to be 1. */
76
# define xalloc_oversized(n, s) \
77
((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n))
80
/* In the following macros, T must be an elementary or structure/union or
81
typedef'ed type, or a pointer to such a type. To apply one of the
82
following macros to a function pointer or array type, you need to typedef
83
it first and use the typedef name. */
85
/* Allocate an object of type T dynamically, with error checking. */
86
/* extern t *XMALLOC (typename t); */
87
# define XMALLOC(t) ((t *) xmalloc (sizeof (t)))
89
/* Allocate memory for N elements of type T, with error checking. */
90
/* extern t *XNMALLOC (size_t n, typename t); */
91
# define XNMALLOC(n, t) \
92
((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t))))
94
/* Allocate an object of type T dynamically, with error checking,
96
/* extern t *XZALLOC (typename t); */
97
# define XZALLOC(t) ((t *) xzalloc (sizeof (t)))
99
/* Allocate memory for N elements of type T, with error checking,
101
/* extern t *XCALLOC (size_t n, typename t); */
102
# define XCALLOC(n, t) \
103
((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t))))
107
# define static_inline static inline
109
void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
110
void *xnrealloc (void *p, size_t n, size_t s);
111
void *x2nrealloc (void *p, size_t *pn, size_t s);
112
char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
115
# ifdef static_inline
117
/* Allocate an array of N objects, each with S bytes of memory,
118
dynamically, with error checking. S must be nonzero. */
120
static_inline void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC;
122
xnmalloc (size_t n, size_t s)
124
if (xalloc_oversized (n, s))
126
return xmalloc (n * s);
129
/* Change the size of an allocated block of memory P to an array of N
130
objects each of S bytes, with error checking. S must be nonzero. */
133
xnrealloc (void *p, size_t n, size_t s)
135
if (xalloc_oversized (n, s))
137
return xrealloc (p, n * s);
140
/* If P is null, allocate a block of at least *PN such objects;
141
otherwise, reallocate P so that it contains more than *PN objects
142
each of S bytes. *PN must be nonzero unless P is null, and S must
143
be nonzero. Set *PN to the new number of objects, and return the
144
pointer to the new block. *PN is never set to zero, and the
145
returned pointer is never null.
147
Repeated reallocations are guaranteed to make progress, either by
148
allocating an initial block with a nonzero size, or by allocating a
151
In the following implementation, nonzero sizes are increased by a
152
factor of approximately 1.5 so that repeated reallocations have
153
O(N) overall cost rather than O(N**2) cost, but the
154
specification for this function does not guarantee that rate.
156
Here is an example of use:
160
size_t allocated = 0;
163
append_int (int value)
165
if (used == allocated)
166
p = x2nrealloc (p, &allocated, sizeof *p);
170
This causes x2nrealloc to allocate a block of some nonzero size the
171
first time it is called.
173
To have finer-grained control over the initial size, set *PN to a
174
nonzero value before calling this function with P == NULL. For
179
size_t allocated = 0;
180
size_t allocated1 = 1000;
183
append_int (int value)
185
if (used == allocated)
187
p = x2nrealloc (p, &allocated1, sizeof *p);
188
allocated = allocated1;
196
x2nrealloc (void *p, size_t *pn, size_t s)
204
/* The approximate size to use for initial small allocation
205
requests, when the invoking code specifies an old size of
206
zero. 64 bytes is the largest "small" request for the
207
GNU C library malloc. */
208
enum { DEFAULT_MXFAST = 64 };
210
n = DEFAULT_MXFAST / s;
216
/* Set N = ceil (1.5 * N) so that progress is made if N == 1.
217
Check for overflow, so that N * S stays in size_t range.
218
The check is slightly conservative, but an exact check isn't
219
worth the trouble. */
220
if ((size_t) -1 / 3 * 2 / s <= n)
226
return xrealloc (p, n * s);
229
/* Return a pointer to a new buffer of N bytes. This is like xmalloc,
230
except it returns char *. */
232
static_inline char *xcharalloc (size_t n) ATTRIBUTE_MALLOC;
234
xcharalloc (size_t n)
236
return XNMALLOC (n, char);
244
/* C++ does not allow conversions from void * to other pointer types
245
without a cast. Use templates to work around the problem when
248
template <typename T> inline T *
249
xrealloc (T *p, size_t s)
251
return (T *) xrealloc ((void *) p, s);
254
template <typename T> inline T *
255
xnrealloc (T *p, size_t n, size_t s)
257
return (T *) xnrealloc ((void *) p, n, s);
260
template <typename T> inline T *
261
x2realloc (T *p, size_t *pn)
263
return (T *) x2realloc ((void *) p, pn);
266
template <typename T> inline T *
267
x2nrealloc (T *p, size_t *pn, size_t s)
269
return (T *) x2nrealloc ((void *) p, pn, s);
272
template <typename T> inline T *
273
xmemdup (T const *p, size_t s)
275
return (T *) xmemdup ((void const *) p, s);
82
281
#endif /* !XALLOC_H_ */
added
removed
lib/xalloc.h
