Avoid a test failure on AIX.

[gnulib.git] / m4 / inttypes.m4

diff --git a/m4/inttypes.m4 b/m4/inttypes.m4
index 095ace9..d84cead 100644 (file)
--- a/m4/inttypes.m4
+++ b/m4/inttypes.m4
@@ -1,5 +1,5 @@
-# inttypes.m4 serial 8
-dnl Copyright (C) 2006-2007 Free Software Foundation, Inc.
+# inttypes.m4 serial 12
+dnl Copyright (C) 2006-2008 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
@@ -32,12 +32,13 @@ AC_DEFUN([gl_INTTYPES_H],
        && test "$ac_cv_have_decl_strtoimax" = yes \
        && test "$ac_cv_have_decl_strtoumax" = yes; then
        AC_COMPILE_IFELSE([
-        AC_LANG_PROGRAM([
+        AC_LANG_PROGRAM([[
 #include <stddef.h>
 #define __STDC_LIMIT_MACROS 1 /* to make it work also in C++ mode */
 #define __STDC_CONSTANT_MACROS 1 /* to make it work also in C++ mode */
 #define __STDC_FORMAT_MACROS 1 /* to make it work also in C++ mode */
-#include ABSOLUTE_INTTYPES_H
+#define _GL_JUST_INCLUDE_SYSTEM_INTTYPES_H /* work if build isn't clean */
+#include <inttypes.h>
 
 /* No need to duplicate the tests of stdint.m4; they are subsumed by
    $gl_cv_header_working_stdint_h = yes.  */
@@ -130,7 +131,7 @@ const char *l = /* implicit string concatenation */
   SCNoPTR SCNuPTR SCNxPTR
 #endif
   ;
-        ])],
+        ]])],
         [gl_cv_header_working_inttypes_h=yes])
      fi])
 
@@ -141,14 +142,23 @@ const char *l = /* implicit string concatenation */
   else
 
     AC_REQUIRE([gl_INTTYPES_H_DEFAULTS])
-    dnl AC_INCLUDES_DEFAULT defines $ac_cv_header_inttypes_h.
-    if test $ac_cv_header_inttypes_h = yes; then
-      gl_ABSOLUTE_HEADER([inttypes.h])
-      ABSOLUTE_INTTYPES_H=\"$gl_cv_absolute_inttypes_h\"
-    else
-      ABSOLUTE_INTTYPES_H=\"no/such/file/inttypes.h\"
-    fi
-    AC_SUBST([ABSOLUTE_INTTYPES_H])
+    gl_CHECK_NEXT_HEADERS([inttypes.h])
+
+    dnl Ensure that <stdint.h> defines the limit macros, since gnulib's
+    dnl <inttypes.h> relies on them.  This macro is only needed when a
+    dnl C++ compiler is in use; it has no effect for a C compiler.
+    dnl Also be careful to define __STDC_LIMIT_MACROS only when gnulib's
+    dnl <inttypes.h> is going to be created, and to avoid redefinition warnings
+    dnl if the __STDC_LIMIT_MACROS is already defined through the CPPFLAGS.
+    AC_DEFINE([GL_TRIGGER_STDC_LIMIT_MACROS], 1,
+      [Define to make the limit macros in <stdint.h> visible.])
+    AH_VERBATIM([__STDC_LIMIT_MACROS_ZZZ],
+[/* Ensure that <stdint.h> defines the limit macros, since gnulib's
+   <inttypes.h> relies on them.  */
+#if defined __cplusplus && !defined __STDC_LIMIT_MACROS && GL_TRIGGER_STDC_LIMIT_MACROS
+# define __STDC_LIMIT_MACROS 1
+#endif
+])
 
     PRIPTR_PREFIX=
     if test -n "$STDINT_H"; then
@@ -164,9 +174,9 @@ const char *l = /* implicit string concatenation */
           I64) gltype1='__int64';;
         esac
         AC_COMPILE_IFELSE(
-          [AC_LANG_PROGRAM([#include <stdint.h>
+          [AC_LANG_PROGRAM([[#include <stdint.h>
              extern intptr_t foo;
-             extern $gltype1 foo;])],
+             extern $gltype1 foo;]])],
           [PRIPTR_PREFIX='"'$glpfx'"'])
         test -n "$PRIPTR_PREFIX" && break
       done
@@ -197,11 +207,73 @@ const char *l = /* implicit string concatenation */
       HAVE_DECL_STRTOUMAX=0
     fi
 
+    gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION(
+      [INT32_MAX_LT_INTMAX_MAX],
+      [defined INT32_MAX && defined INTMAX_MAX],
+      [INT32_MAX < INTMAX_MAX],
+      [sizeof (int) < sizeof (long long int)])
+    gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION(
+      [INT64_MAX_EQ_LONG_MAX],
+      [defined INT64_MAX],
+      [INT64_MAX == LONG_MAX],
+      [sizeof (long long int) == sizeof (long int)])
+    gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION(
+      [UINT32_MAX_LT_UINTMAX_MAX],
+      [defined UINT32_MAX && defined UINTMAX_MAX],
+      [UINT32_MAX < UINTMAX_MAX],
+      [sizeof (unsigned int) < sizeof (unsigned long long int)])
+    gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION(
+      [UINT64_MAX_EQ_ULONG_MAX],
+      [defined UINT64_MAX],
+      [UINT64_MAX == ULONG_MAX],
+      [sizeof (unsigned long long int) == sizeof (unsigned long int)])
+
     INTTYPES_H='inttypes.h'
   fi
   AC_SUBST(INTTYPES_H)
 ])
 
+# Define the symbol $1 to be 1 if the condition is true, 0 otherwise.
+# If $2 is true, the condition is $3; otherwise if long long int is supported
+# approximate the condition with $4; otherwise, assume the condition is false.
+# The condition should work on all C99 platforms; the approximations should be
+# good enough to work on all practical pre-C99 platforms.
+# $2 is evaluated by the C preprocessor, $3 and $4 as compile-time constants.
+AC_DEFUN([gl_INTTYPES_CHECK_LONG_LONG_INT_CONDITION],
+[
+  AC_CACHE_CHECK([whether $3],
+    [gl_cv_test_$1],
+    [AC_COMPILE_IFELSE(
+       [AC_LANG_PROGRAM(
+         [[/* Work also in C++ mode.  */
+           #define __STDC_LIMIT_MACROS 1
+
+           /* Work if build is not clean.  */
+           #define _GL_JUST_INCLUDE_SYSTEM_STDINT_H
+
+           #include <limits.h>
+           #if HAVE_STDINT_H
+            #include <stdint.h>
+           #endif
+
+           #if $2
+            #define CONDITION ($3)
+           #elif HAVE_LONG_LONG_INT
+            #define CONDITION ($4)
+           #else
+            #define CONDITION 0
+           #endif
+           int test[CONDITION ? 1 : -1];]])],
+       [gl_cv_test_$1=yes],
+       [gl_cv_test_$1=no])])
+  if test $gl_cv_test_$1 = yes; then
+    $1=1;
+  else
+    $1=0;
+  fi
+  AC_SUBST([$1])
+])
+
 AC_DEFUN([gl_INTTYPES_MODULE_INDICATOR],
 [
   dnl Use AC_REQUIRE here, so that the default settings are expanded once only.