/* xmalloc.c -- malloc with out of memory checking

   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2002, 2003, 2004, 2005, 2006 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 2, 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, write to the Free Software Foundation,

   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */

#include <config.h>

#if ! HAVE_INLINE

# define static_inline

#endif

#include "xalloc.h"

#undef static_inline

#include <stdlib.h>

#include <string.h>

#ifndef SIZE_MAX

# define SIZE_MAX ((size_t) -1)

#endif

/* 1 if calloc is known to be compatible with GNU calloc.  This

   matters if we are not also using the calloc module, which defines

   HAVE_CALLOC and supports the GNU API even on non-GNU platforms.  */

#if defined HAVE_CALLOC || defined __GLIBC__

enum { HAVE_GNU_CALLOC = 1 };

#else

enum { HAVE_GNU_CALLOC = 0 };

#endif

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

void *

xmalloc (size_t n)

{

  void *p = malloc (n);

  if (!p && n != 0)

    xalloc_die ();

  return p;

}

/* Change the size of an allocated block of memory P to N bytes,

   with error checking.  */

void *

xrealloc (void *p, size_t n)

{

  p = realloc (p, n);

  if (!p && n != 0)

    xalloc_die ();

  return p;

}

/* If P is null, allocate a block of at least *PN bytes; otherwise,

   reallocate P so that it contains more than *PN bytes.  *PN must be

   nonzero unless P is null.  Set *PN to the new block's size, and

   return the pointer to the new block.  *PN is never set to zero, and

   the returned pointer is never null.  */

void *

x2realloc (void *p, size_t *pn)

{

  return x2nrealloc (p, pn, 1);

}

/* 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).  */

void *

xzalloc (size_t s)

{

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

}

/* Allocate zeroed memory for N elements of S bytes, with error

   checking.  S must be nonzero.  */

void *

xcalloc (size_t n, size_t s)

{

  void *p;

  /* Test for overflow, since some calloc implementations don't have

     proper overflow checks.  But omit overflow and size-zero tests if

     HAVE_GNU_CALLOC, since GNU calloc catches overflow and never

     returns NULL if successful.  */

  if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s))

      || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0)))

    xalloc_die ();

  return p;

}

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

}

/* Clone STRING.  */

char *

xstrdup (char const *string)

{

  return xmemdup (string, strlen (string) + 1);

}