New function xmax.

diff --git a/lib/ChangeLog b/lib/ChangeLog
index 29fc9b9a2c4eca2dc3ddfda4acd5e3092d140eb0..85e3ced1d3f0eb640a62cfcab705cb6999e15d42 100644 (file)
--- a/lib/ChangeLog
+++ b/lib/ChangeLog
@@ -1,3 +1,8 @@
+2003-11-16  Bruno Haible  <bruno@clisp.org>
+
+       * xsize.h (xmax): New function.
+       (xsum, xsum3, xsum4): Declare as "pure" functions.
+
 2003-11-12  Paul Eggert  <eggert@twinsun.com>
 
        * xalloc.h: Do not include <limits.h> or <stdint.h>.

diff --git a/lib/xsize.h b/lib/xsize.h
index 42aa68a2a90da1f77ad0e3a13be6d540b9d436e4..7634c6d4d5a4047da0f1896b410b163bd4edbe40 100644 (file)
--- a/lib/xsize.h
+++ b/lib/xsize.h
@@ -37,11 +37,11 @@
    To avoid this, the functions and macros in this file check for overflow.
    The convention is that SIZE_MAX represents overflow.
    malloc (SIZE_MAX) is not guaranteed to fail -- think of a malloc
-   implementation that uses mmap --, it's recommended to use SIZE_OVERFLOW_P
-   before invoking malloc().
+   implementation that uses mmap --, it's recommended to use size_overflow_p()
+   or size_in_bounds_p() before invoking malloc().
    The example thus becomes:
       size_t size = xsum (header_size, xtimes (n, element_size));
-      void *p = (!SIZE_OVERFLOW_P (size) ? malloc (size) : NULL);
+      void *p = (size_in_bounds_p (size) ? malloc (size) : NULL);
 */
 
 /* Convert an arbitrary value >= 0 to type size_t.  */
@@ -50,6 +50,9 @@
 
 /* Sum of two sizes, with overflow check.  */
 static inline size_t
+#if __GNUC__ >= 3
+__attribute__ ((__pure__))
+#endif
 xsum (size_t size1, size_t size2)
 {
   size_t sum = size1 + size2;
@@ -58,6 +61,9 @@ xsum (size_t size1, size_t size2)
 
 /* Sum of three sizes, with overflow check.  */
 static inline size_t
+#if __GNUC__ >= 3
+__attribute__ ((__pure__))
+#endif
 xsum3 (size_t size1, size_t size2, size_t size3)
 {
   return xsum (xsum (size1, size2), size3);
@@ -65,11 +71,26 @@ xsum3 (size_t size1, size_t size2, size_t size3)
 
 /* Sum of four sizes, with overflow check.  */
 static inline size_t
+#if __GNUC__ >= 3
+__attribute__ ((__pure__))
+#endif
 xsum4 (size_t size1, size_t size2, size_t size3, size_t size4)
 {
   return xsum (xsum (xsum (size1, size2), size3), size4);
 }
 
+/* Maximum of two sizes, with overflow check.  */
+static inline size_t
+#if __GNUC__ >= 3
+__attribute__ ((__pure__))
+#endif
+xmax (size_t size1, size_t size2)
+{
+  /* No explicit check is needed here, because for any n:
+     max (SIZE_MAX, n) == SIZE_MAX and max (n, SIZE_MAX) == SIZE_MAX.  */
+  return (size1 >= size2 ? size1 : size2);
+}
+
 /* Multiplication of a count with an element size, with overflow check.
    The count must be >= 0 and the element size must be > 0.
    This is a macro, not an inline function, so that it works correctly even