--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,22 @@
+2006-11-07  Paul Eggert  <eggert@cs.ucla.edu>
+
+	* lib/xalloc.h (XMALLOC, XNMALLOC, XZALLOC, XCALLOC): Move
+	definitions up, to avoid colliding with change below.
+	(static_inline) [HAVE_INLINE]: New macro.
+	(xnmalloc, xnrealloc, x2nrealloc, xcharalloc):
+	Provide extern decls when !HAVE_INLINE.  Do not define unless
+	static_inline is defined, either by us or by xmalloc.c.  Use
+	static_inline rather than static inline.
+	(XCALLOC): Optimize sizeof(T) = 1 case.
+	* lib/xmalloc.c (static_inline) [!HAVE_INLINE]: New macro.
+
+2006-11-07  Bruno Haible  <bruno@clisp.org>
+
+	* lib/xalloc.h (XNMALLOC): Restore optimization of sizeof(T) = 1 case.
+	* m4/xalloc.m4 (gl_PREREQ_XALLOC): Require gl_INLINE instead of
+	AC_C_INLINE.
+	* modules/xalloc (Files): Add m4/inline.m4.
+
 2006-11-07  Ralf Wildenhues  <Ralf.Wildenhues@gmx.de>
 
 	* README: Fix typo.

--- a/lib/xalloc.h
+++ b/lib/xalloc.h
@@ -68,10 +68,48 @@
 # 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);
+   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);
+# 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 *
+static_inline void *
 xnmalloc (size_t n, size_t s)
 {
   if (xalloc_oversized (n, s))
@@ -82,7 +120,7 @@
 /* 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 *
+static_inline void *
 xnrealloc (void *p, size_t n, size_t s)
 {
   if (xalloc_oversized (n, s))
@@ -145,7 +183,7 @@
 
    */
 
-static inline void *
+static_inline void *
 x2nrealloc (void *p, size_t *pn, size_t s)
 {
   size_t n = *pn;
@@ -175,37 +213,17 @@
   return xrealloc (p, n * s);
 }
 
-/* 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 *) 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 *) xcalloc (n, sizeof (t)))
-
 /* Return a pointer to a new buffer of N bytes.  This is like xmalloc,
    except it returns char *.  */
-static inline char *
+
+static_inline char *
 xcharalloc (size_t n)
 {
   return XNMALLOC (n, char);
 }
 
+# endif
+
 # ifdef __cplusplus
 }
 

--- a/lib/xmalloc.c
+++ b/lib/xmalloc.c
@@ -20,7 +20,11 @@
 
 #include <config.h>
 
+#if ! HAVE_INLINE
+# define static_inline
+#endif
 #include "xalloc.h"
+#undef static_inline
 
 #include <stdlib.h>
 #include <string.h>

--- a/m4/xalloc.m4
+++ b/m4/xalloc.m4
@@ -1,4 +1,4 @@
-# xalloc.m4 serial 15
+# xalloc.m4 serial 16
 dnl Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
@@ -14,7 +14,7 @@
 
 # Prerequisites of lib/xalloc.h.
 AC_DEFUN([gl_PREREQ_XALLOC], [
-  AC_REQUIRE([AC_C_INLINE])
+  AC_REQUIRE([gl_INLINE])
   :
 ])
 

--- a/modules/xalloc
+++ b/modules/xalloc
@@ -5,6 +5,7 @@
 lib/xalloc.h
 lib/xmalloc.c
 m4/xalloc.m4
+m4/inline.m4
 
 Depends-on:
 xalloc-die