Update from GNU gettext.

Author: bhaible

ChangeLog

@@ -1,3 +1,26 @@
+2007-10-23  Bruno Haible  <bruno@clisp.org>
+
+	Update from GNU gettext.
+	2006-11-26  Bruno Haible  <bruno@clisp.org>
+		* gnulib-local/lib/xalloc.h (xmemdup): Add a typesafe C++
+		template variant.
+		Based on a patch from Paul Eggert in gnulib.
+	2006-11-06  Bruno Haible  <bruno@clisp.org>
+		* gnulib-local/lib/xalloc.h (xcharalloc): New macro.
+		(xmemdup): New declaration.
+		* gnulib-local/lib/xstrdup.c (xmemdup): New function.
+	2006-11-03  Bruno Haible  <bruno@clisp.org>
+		* gnulib-local/lib/xalloc.h (XMALLOC, XNMALLOC, XZALLOC,
+		XCALLOC): New macros.
+		(xnboundedmalloc): New inline function.
+		* gnulib-local/lib/xstrdup.c (xstrdup): Use XNMALLOC instead of
+		xmalloc.
+	2006-11-02  Bruno Haible  <bruno@clisp.org>
+		* lib/xalloc.h (xnmalloc): New declaration. From gnulib
+		xalloc.h.
+		* lib/xmalloc.c (fixup_null_alloc): Write NULL, not 0.
+		(xnmalloc): New function.
+
 2007-10-23  Bruno Haible  <bruno@clisp.org>
 
 	Moved module xreadlink to gnulib.

gnulib-local/lib/xalloc.h

@@ -31,6 +31,10 @@ extern "C" {
 /* Allocate SIZE bytes of memory dynamically, with error checking.  */
 extern void *xmalloc (size_t size);
 
+/* Allocate memory for NMEMB elements of SIZE bytes, with error checking.
+   SIZE must be > 0.  */
+extern void *xnmalloc (size_t nmemb, size_t size);
+
 /* Allocate SIZE bytes of memory dynamically, with error checking,
    and zero it.  */
 extern void *xzalloc (size_t size);
@@ -47,7 +51,7 @@ extern void *xrealloc (void *ptr, size_t size);
 template <typename T>
   inline T * xrealloc (T * ptr, size_t size)
   {
-    return (T *) xrealloc((void *) ptr, size);
+    return (T *) xrealloc ((void *) ptr, size);
   }
 extern "C" {
 #endif
@@ -62,9 +66,70 @@ extern void xalloc_die (void)
 #endif
      ;
 
+/* 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 NMEMB elements of type T, with error checking.  */
+/* extern T *XNMALLOC (size_t nmemb, typename T); */
+#if HAVE_INLINE
+/* xnmalloc performs a division and multiplication by sizeof (T).  Arrange to
+   perform the division at compile-time and the multiplication with a factor
+   known at compile-time.  */
+# define XNMALLOC(N,T) \
+   ((T *) (sizeof (T) == 1 \
+	   ? xmalloc (N) \
+	   : xnboundedmalloc(N, (size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / sizeof (T), sizeof (T))))
+static inline void *
+xnboundedmalloc (size_t n, size_t bound, size_t s)
+{
+  if (n > bound)
+    xalloc_die ();
+  return xmalloc (n * s);
+}
+#else
+# define XNMALLOC(N,T) \
+   ((T *) (sizeof (T) == 1 ? xmalloc (N) : xnmalloc (N, sizeof (T))))
+#endif
+
+/* 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 NMEMB elements of type T, with error checking,
+   and zero it.  */
+/* extern T *XCALLOC (size_t nmemb, typename T); */
+#define XCALLOC(N,T) \
+  ((T *) xcalloc (N, sizeof (T)))
+
+/* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
+   except it returns char *.  */
+#define xcharalloc(N) \
+  XNMALLOC (N, char)
+
 
 /* Defined in xstrdup.c.  */
 
+/* Return a newly allocated copy of the N bytes of memory starting at P.  */
+extern void *xmemdup (const void *p, size_t n);
+#ifdef __cplusplus
+}
+template <typename T>
+  inline T * xmemdup (const T * p, size_t n)
+  {
+    return (T *) xmemdup ((const void *) p, n);
+  }
+extern "C" {
+#endif
+
 /* Return a newly allocated copy of STRING.  */
 extern char *xstrdup (const char *string);
 

gnulib-local/lib/xmalloc.c

@@ -46,7 +46,7 @@ fixup_null_alloc (size_t n)
 {
   void *p;
 
-  p = 0;
+  p = NULL;
   if (n == 0)
     p = malloc ((size_t) 1);
   if (p == NULL)
@@ -67,6 +67,24 @@ xmalloc (size_t n)
   return p;
 }
 
+/* Allocate memory for NMEMB elements of SIZE bytes, with error checking.
+   SIZE must be > 0.  */
+
+void *
+xnmalloc (size_t nmemb, size_t size)
+{
+  size_t n;
+  void *p;
+
+  if (xalloc_oversized (nmemb, size))
+    xalloc_die ();
+  n = nmemb * size;
+  p = malloc (n);
+  if (p == NULL)
+    p = fixup_null_alloc (n);
+  return p;
+}
+
 /* Allocate SIZE bytes of memory dynamically, with error checking,
    and zero it.  */
 

gnulib-local/lib/xstrdup.c

@@ -21,10 +21,20 @@
 
 #include <string.h>
 
+/* Return a newly allocated copy of the N bytes of memory starting at P.  */
+
+void *
+xmemdup (const void *p, size_t n)
+{
+  void *q = xmalloc (n);
+  memcpy (q, p, n);
+  return q;
+}
+
 /* Return a newly allocated copy of STRING.  */
 
 char *
 xstrdup (const char *string)
 {
-  return strcpy ((char *) xmalloc (strlen (string) + 1), string);
+  return strcpy (XNMALLOC (strlen (string) + 1, char), string);
 }