Index: bison/src/bison/2.4.1/bison-2.4.1-src/lib/xalloc.h |
=================================================================== |
--- bison/src/bison/2.4.1/bison-2.4.1-src/lib/xalloc.h (revision 0) |
+++ bison/src/bison/2.4.1/bison-2.4.1-src/lib/xalloc.h (revision 0) |
@@ -0,0 +1,280 @@ |
+/* xalloc.h -- malloc with out-of-memory checking |
+ |
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
+ 1999, 2000, 2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc. |
+ |
+ This program is free software: you can redistribute it and/or modify |
+ it under the terms of the GNU General Public License as published by |
+ the Free Software Foundation; either version 3 of the License, or |
+ (at your option) any later version. |
+ |
+ This program is distributed in the hope that it will be useful, |
+ but WITHOUT ANY WARRANTY; without even the implied warranty of |
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
+ GNU General Public License for more details. |
+ |
+ You should have received a copy of the GNU General Public License |
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
+ |
+#ifndef XALLOC_H_ |
+# define XALLOC_H_ |
+ |
+# include <stddef.h> |
+ |
+ |
+# ifdef __cplusplus |
+extern "C" { |
+# endif |
+ |
+ |
+# ifndef __attribute__ |
+# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8) |
+# define __attribute__(x) |
+# endif |
+# endif |
+ |
+# ifndef ATTRIBUTE_NORETURN |
+# define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__)) |
+# endif |
+ |
+# ifndef ATTRIBUTE_MALLOC |
+# if __GNUC__ >= 3 |
+# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) |
+# else |
+# define ATTRIBUTE_MALLOC |
+# endif |
+# endif |
+ |
+/* This function is always triggered when memory is exhausted. |
+ It must be defined by the application, either explicitly |
+ or by using gnulib's xalloc-die module. This is the |
+ function to call when one wants the program to die because of a |
+ memory allocation failure. */ |
+extern void xalloc_die (void) ATTRIBUTE_NORETURN; |
+ |
+void *xmalloc (size_t s) ATTRIBUTE_MALLOC; |
+void *xzalloc (size_t s) ATTRIBUTE_MALLOC; |
+void *xcalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; |
+void *xrealloc (void *p, size_t s); |
+void *x2realloc (void *p, size_t *pn); |
+void *xmemdup (void const *p, size_t s) ATTRIBUTE_MALLOC; |
+char *xstrdup (char const *str) ATTRIBUTE_MALLOC; |
+ |
+/* Return 1 if an array of N objects, each of size S, cannot exist due |
+ to size arithmetic overflow. S must be positive and N must be |
+ nonnegative. This is a macro, not an inline function, so that it |
+ works correctly even when SIZE_MAX < N. |
+ |
+ By gnulib convention, SIZE_MAX represents overflow in size |
+ calculations, so the conservative dividend to use here is |
+ SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value. |
+ However, malloc (SIZE_MAX) fails on all known hosts where |
+ sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for |
+ exactly-SIZE_MAX allocations on such hosts; this avoids a test and |
+ branch when S is known to be 1. */ |
+# define xalloc_oversized(n, s) \ |
+ ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n)) |
+ |
+ |
+/* In the following macros, T must be an elementary or structure/union or |
+ typedef'ed type, or a pointer to such a type. To apply one of the |
+ following macros to a function pointer or array type, you need to typedef |
+ it first and use the typedef name. */ |
+ |
+/* Allocate an object of type T dynamically, with error checking. */ |
+/* extern t *XMALLOC (typename t); */ |
+# define XMALLOC(t) ((t *) xmalloc (sizeof (t))) |
+ |
+/* Allocate memory for N elements of type T, with error checking. */ |
+/* extern t *XNMALLOC (size_t n, typename t); */ |
+# define XNMALLOC(n, t) \ |
+ ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t)))) |
+ |
+/* Allocate an object of type T dynamically, with error checking, |
+ and zero it. */ |
+/* extern t *XZALLOC (typename t); */ |
+# define XZALLOC(t) ((t *) xzalloc (sizeof (t))) |
+ |
+/* Allocate memory for N elements of type T, with error checking, |
+ and zero it. */ |
+/* extern t *XCALLOC (size_t n, typename t); */ |
+# define XCALLOC(n, t) \ |
+ ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t)))) |
+ |
+ |
+# if HAVE_INLINE |
+# define static_inline static inline |
+# else |
+ void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; |
+ void *xnrealloc (void *p, size_t n, size_t s); |
+ void *x2nrealloc (void *p, size_t *pn, size_t s); |
+ char *xcharalloc (size_t n) ATTRIBUTE_MALLOC; |
+# endif |
+ |
+# ifdef static_inline |
+ |
+/* Allocate an array of N objects, each with S bytes of memory, |
+ dynamically, with error checking. S must be nonzero. */ |
+ |
+static_inline void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; |
+static_inline void * |
+xnmalloc (size_t n, size_t s) |
+{ |
+ if (xalloc_oversized (n, s)) |
+ xalloc_die (); |
+ return xmalloc (n * s); |
+} |
+ |
+/* Change the size of an allocated block of memory P to an array of N |
+ objects each of S bytes, with error checking. S must be nonzero. */ |
+ |
+static_inline void * |
+xnrealloc (void *p, size_t n, size_t s) |
+{ |
+ if (xalloc_oversized (n, s)) |
+ xalloc_die (); |
+ return xrealloc (p, n * s); |
+} |
+ |
+/* If P is null, allocate a block of at least *PN such objects; |
+ otherwise, reallocate P so that it contains more than *PN objects |
+ each of S bytes. *PN must be nonzero unless P is null, and S must |
+ be nonzero. Set *PN to the new number of objects, and return the |
+ pointer to the new block. *PN is never set to zero, and the |
+ returned pointer is never null. |
+ |
+ Repeated reallocations are guaranteed to make progress, either by |
+ allocating an initial block with a nonzero size, or by allocating a |
+ larger block. |
+ |
+ In the following implementation, nonzero sizes are increased by a |
+ factor of approximately 1.5 so that repeated reallocations have |
+ O(N) overall cost rather than O(N**2) cost, but the |
+ specification for this function does not guarantee that rate. |
+ |
+ Here is an example of use: |
+ |
+ int *p = NULL; |
+ size_t used = 0; |
+ size_t allocated = 0; |
+ |
+ void |
+ append_int (int value) |
+ { |
+ if (used == allocated) |
+ p = x2nrealloc (p, &allocated, sizeof *p); |
+ p[used++] = value; |
+ } |
+ |
+ This causes x2nrealloc to allocate a block of some nonzero size the |
+ first time it is called. |
+ |
+ To have finer-grained control over the initial size, set *PN to a |
+ nonzero value before calling this function with P == NULL. For |
+ example: |
+ |
+ int *p = NULL; |
+ size_t used = 0; |
+ size_t allocated = 0; |
+ size_t allocated1 = 1000; |
+ |
+ void |
+ append_int (int value) |
+ { |
+ if (used == allocated) |
+ { |
+ p = x2nrealloc (p, &allocated1, sizeof *p); |
+ allocated = allocated1; |
+ } |
+ p[used++] = value; |
+ } |
+ |
+ */ |
+ |
+static_inline void * |
+x2nrealloc (void *p, size_t *pn, size_t s) |
+{ |
+ size_t n = *pn; |
+ |
+ if (! p) |
+ { |
+ if (! n) |
+ { |
+ /* The approximate size to use for initial small allocation |
+ requests, when the invoking code specifies an old size of |
+ zero. 64 bytes is the largest "small" request for the |
+ GNU C library malloc. */ |
+ enum { DEFAULT_MXFAST = 64 }; |
+ |
+ n = DEFAULT_MXFAST / s; |
+ n += !n; |
+ } |
+ } |
+ else |
+ { |
+ /* Set N = ceil (1.5 * N) so that progress is made if N == 1. |
+ Check for overflow, so that N * S stays in size_t range. |
+ The check is slightly conservative, but an exact check isn't |
+ worth the trouble. */ |
+ if ((size_t) -1 / 3 * 2 / s <= n) |
+ xalloc_die (); |
+ n += (n + 1) / 2; |
+ } |
+ |
+ *pn = n; |
+ return xrealloc (p, n * s); |
+} |
+ |
+/* Return a pointer to a new buffer of N bytes. This is like xmalloc, |
+ except it returns char *. */ |
+ |
+static_inline char *xcharalloc (size_t n) ATTRIBUTE_MALLOC; |
+static_inline char * |
+xcharalloc (size_t n) |
+{ |
+ return XNMALLOC (n, char); |
+} |
+ |
+# endif |
+ |
+# ifdef __cplusplus |
+} |
+ |
+/* C++ does not allow conversions from void * to other pointer types |
+ without a cast. Use templates to work around the problem when |
+ possible. */ |
+ |
+template <typename T> inline T * |
+xrealloc (T *p, size_t s) |
+{ |
+ return (T *) xrealloc ((void *) p, s); |
+} |
+ |
+template <typename T> inline T * |
+xnrealloc (T *p, size_t n, size_t s) |
+{ |
+ return (T *) xnrealloc ((void *) p, n, s); |
+} |
+ |
+template <typename T> inline T * |
+x2realloc (T *p, size_t *pn) |
+{ |
+ return (T *) x2realloc ((void *) p, pn); |
+} |
+ |
+template <typename T> inline T * |
+x2nrealloc (T *p, size_t *pn, size_t s) |
+{ |
+ return (T *) x2nrealloc ((void *) p, pn, s); |
+} |
+ |
+template <typename T> inline T * |
+xmemdup (T const *p, size_t s) |
+{ |
+ return (T *) xmemdup ((void const *) p, s); |
+} |
+ |
+# endif |
+ |
+ |
+#endif /* !XALLOC_H_ */ |
Property changes on: bison\src\bison\2.4.1\bison-2.4.1-src\lib\xalloc.h |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |