~vcs-imports/gawk/master

/* 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, 2009, 2010 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))))

/*

 * Gawk uses this file only to keep dfa.c happy.

 * We're therefore safe in manually defining HAVE_INLINE to

 * make the !@#$%^&*() thing just work.

 */

#ifdef GAWK

#define HAVE_INLINE	1	/* so there. nyah, nyah, nyah. */

#endif

# 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);

}

#ifdef GAWK

#include <errno.h>

extern void r_fatal(const char *msg, ...) ATTRIBUTE_NORETURN ;

/* Allocate an array of N objects, each with S bytes of memory,

   dynamically, with error checking.  S must be nonzero.

   Clear the contents afterwards.  */

void *

xcalloc(size_t nmemb, size_t size)

{

  void *p = xmalloc (nmemb * size);

  memset(p, '\0', nmemb * size);

  return p;

}

/* Reallocate a pointer to a new size, with error checking. */

void *

xrealloc(void *p, size_t size)

{

   void *new_p = realloc(p, size);

   if (new_p ==  0)

     xalloc_die ();

   return new_p;

}

/* xalloc_die --- fatal error message when malloc fails, needed by dfa.c */

void

xalloc_die (void)

{

	r_fatal(_("xalloc: malloc failed: %s"), strerror(errno));

}

/* Clone an object P of size S, with error checking.  There's no need

   for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any

   need for an arithmetic overflow check.  */

void *

xmemdup (void const *p, size_t s)

{

  return memcpy (xmalloc (s), p, s);

}

/* xstrdup --- strdup and die if fails */

char *xstrdup(const char *s)

{

	char *p;

	int l;

	if (s == NULL)

		r_fatal(_("xstrdup: null parameter"));

	l = strlen(s);

	p = xmemdup(s, l + 1);

	p[l] = '\0';

	return p;

}

#endif

/* 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 * sizeof (size_t) / 4 };

          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 / 2 + 1;

    }

  *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);

}

/* Allocate S bytes of zeroed memory dynamically, with error checking.

   There's no need for xnzalloc (N, S), since it would be equivalent

   to xcalloc (N, S).  */

inline void *

xzalloc (size_t s)

{

  return memset (xmalloc (s), 0, s);

}

# 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_ */