nanosleep: Fix C++ test error on mingw.

diff --git a/ChangeLog b/ChangeLog
index 2e94a3ebd597c9a61f37570cc52a13fb14ff5a00..efb42c53cbe0052e8c6b0e7f5c98c119c3d324ca 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+2010-04-03  Bruno Haible  <bruno@clisp.org>
+
+       nanosleep: Fix C++ test error on mingw.
+       * lib/nanosleep.c (nanosleep): Renamed from rpl_nanosleep.
+       * lib/time.in.h (nanosleep): Use modern idiom.
+       * m4/nanosleep.m4 (gl_FUNC_NANOSLEEP): When the system does not have a
+       nanosleep function, set HAVE_NANOSLEEP to 0, instead of setting
+       REPLACE_NANOSLEEP to 1.
+       * m4/time_h.m4 (gl_HEADER_TIME_H_DEFAULTS): Initialize HAVE_NANOSLEEP.
+       * modules/time (Makefile.am): Substitute HAVE_NANOSLEEP.
+
 2010-04-03  Bruno Haible  <bruno@clisp.org>
 
        strptime: Fix C++ test error on mingw.

diff --git a/lib/nanosleep.c b/lib/nanosleep.c
index 58fc7881eceedd4be36c145d516827879ba58195..be15cd08b6c00d762a059b93a9f134b4554027a9 100644 (file)
--- a/lib/nanosleep.c
+++ b/lib/nanosleep.c
@@ -36,15 +36,15 @@
 
 #include <unistd.h>
 
-#undef nanosleep
 
 enum { BILLION = 1000 * 1000 * 1000 };
 
 #if HAVE_BUG_BIG_NANOSLEEP
 
 int
-rpl_nanosleep (const struct timespec *requested_delay,
-               struct timespec *remaining_delay)
+nanosleep (const struct timespec *requested_delay,
+           struct timespec *remaining_delay)
+#undef nanosleep
 {
   /* nanosleep mishandles large sleeps due to internal overflow
      problems.  The worst known case of this is cygwin 1.5.x, which
@@ -128,8 +128,8 @@ my_usleep (const struct timespec *ts_delay)
    *REMAINING_DELAY part isn't implemented yet.  */
 
 int
-rpl_nanosleep (const struct timespec *requested_delay,
-               struct timespec *remaining_delay)
+nanosleep (const struct timespec *requested_delay,
+           struct timespec *remaining_delay)
 {
   static bool initialized;
 

diff --git a/lib/time.in.h b/lib/time.in.h
index 437cf8618d21b79042656e99edf0dcc9ace62ee8..98314442c3d9740e32362ad0d1189bc167e8a2c8 100644 (file)
--- a/lib/time.in.h
+++ b/lib/time.in.h
@@ -87,6 +87,11 @@ _GL_FUNCDECL_RPL (nanosleep, int,
 _GL_CXXALIAS_RPL (nanosleep, int,
                   (struct timespec const *__rqtp, struct timespec *__rmtp));
 #  else
+#   if ! @HAVE_NANOSLEEP@
+_GL_FUNCDECL_SYS (nanosleep, int,
+                  (struct timespec const *__rqtp, struct timespec *__rmtp)
+                  _GL_ARG_NONNULL ((1)));
+#   endif
 _GL_CXXALIAS_SYS (nanosleep, int,
                   (struct timespec const *__rqtp, struct timespec *__rmtp));
 #  endif

diff --git a/m4/nanosleep.m4 b/m4/nanosleep.m4
index a633321a8f7ce1f76fc82b6bb4674e3fd25e0e3b..e336f35d99752aea6bc4829204656372f946fd16 100644 (file)
--- a/m4/nanosleep.m4
+++ b/m4/nanosleep.m4
@@ -1,4 +1,4 @@
-# serial 30
+# serial 31
 
 dnl From Jim Meyering.
 dnl Check for the nanosleep function.
@@ -29,93 +29,99 @@ AC_DEFUN([gl_FUNC_NANOSLEEP],
  AC_SEARCH_LIBS([nanosleep], [rt posix4],
                 [test "$ac_cv_search_nanosleep" = "none required" ||
                  LIB_NANOSLEEP=$ac_cv_search_nanosleep])
+ if test "x$ac_cv_search_nanosleep" != xno; then
+   dnl The system has a nanosleep function.
 
- AC_REQUIRE([gl_MULTIARCH])
- if test $APPLE_UNIVERSAL_BUILD = 1; then
-   # A universal build on Apple MacOS X platforms.
-   # The test result would be 'no (mishandles large arguments)' in 64-bit mode
-   # but 'yes' in 32-bit mode. But we need a configuration result that is
-   # valid in both modes.
-   gl_cv_func_nanosleep='no (mishandles large arguments)'
- fi
-
- AC_CACHE_CHECK([for working nanosleep],
-  [gl_cv_func_nanosleep],
-  [
-   AC_RUN_IFELSE(
-     [AC_LANG_SOURCE([[
-        #include <errno.h>
-        #include <limits.h>
-        #include <signal.h>
-        #if HAVE_SYS_TIME_H
-         #include <sys/time.h>
-        #endif
-        #include <time.h>
-        #include <unistd.h>
-        #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
-        #define TYPE_MAXIMUM(t) \
-          ((t) (! TYPE_SIGNED (t) \
-                ? (t) -1 \
-                : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
+   AC_REQUIRE([gl_MULTIARCH])
+   if test $APPLE_UNIVERSAL_BUILD = 1; then
+     # A universal build on Apple MacOS X platforms.
+     # The test result would be 'no (mishandles large arguments)' in 64-bit
+     # mode but 'yes' in 32-bit mode. But we need a configuration result that
+     # is valid in both modes.
+     gl_cv_func_nanosleep='no (mishandles large arguments)'
+   fi
 
-        static void
-        check_for_SIGALRM (int sig)
-        {
-          if (sig != SIGALRM)
-            _exit (1);
-        }
+   AC_CACHE_CHECK([for working nanosleep],
+    [gl_cv_func_nanosleep],
+    [
+     AC_RUN_IFELSE(
+       [AC_LANG_SOURCE([[
+          #include <errno.h>
+          #include <limits.h>
+          #include <signal.h>
+          #if HAVE_SYS_TIME_H
+           #include <sys/time.h>
+          #endif
+          #include <time.h>
+          #include <unistd.h>
+          #define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
+          #define TYPE_MAXIMUM(t) \
+            ((t) (! TYPE_SIGNED (t) \
+                  ? (t) -1 \
+                  : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
 
-        int
-        main ()
-        {
-          static struct timespec ts_sleep;
-          static struct timespec ts_remaining;
-          static struct sigaction act;
-          if (! nanosleep)
-            return 1;
-          act.sa_handler = check_for_SIGALRM;
-          sigemptyset (&act.sa_mask);
-          sigaction (SIGALRM, &act, NULL);
-          ts_sleep.tv_sec = 0;
-          ts_sleep.tv_nsec = 1;
-          alarm (1);
-          if (nanosleep (&ts_sleep, NULL) != 0)
-            return 1;
-          ts_sleep.tv_sec = TYPE_MAXIMUM (time_t);
-          ts_sleep.tv_nsec = 999999999;
-          alarm (1);
-          if (nanosleep (&ts_sleep, &ts_remaining) == -1 && errno == EINTR
-              && TYPE_MAXIMUM (time_t) - 10 < ts_remaining.tv_sec)
-            return 0;
-          return 119;
-        }]])],
-     [gl_cv_func_nanosleep=yes],
-     [case $? in dnl (
-      119) gl_cv_func_nanosleep='no (mishandles large arguments)';; dnl (
-      *)   gl_cv_func_nanosleep=no;;
-      esac],
-     [gl_cv_func_nanosleep=cross-compiling])
-  ])
-  if test "$gl_cv_func_nanosleep" = yes; then
-    REPLACE_NANOSLEEP=0
-  else
-    REPLACE_NANOSLEEP=1
-    if test "$gl_cv_func_nanosleep" = 'no (mishandles large arguments)'; then
-      AC_DEFINE([HAVE_BUG_BIG_NANOSLEEP], [1],
-        [Define to 1 if nanosleep mishandles large arguments.])
-    else
-      for ac_lib in $LIBSOCKET; do
-        case " $LIB_NANOSLEEP " in
-        *" $ac_lib "*) ;;
-        *) LIB_NANOSLEEP="$LIB_NANOSLEEP $ac_lib";;
-        esac
-      done
-    fi
-    AC_LIBOBJ([nanosleep])
-    gl_PREREQ_NANOSLEEP
-  fi
+          static void
+          check_for_SIGALRM (int sig)
+          {
+            if (sig != SIGALRM)
+              _exit (1);
+          }
 
+          int
+          main ()
+          {
+            static struct timespec ts_sleep;
+            static struct timespec ts_remaining;
+            static struct sigaction act;
+            if (! nanosleep)
+              return 1;
+            act.sa_handler = check_for_SIGALRM;
+            sigemptyset (&act.sa_mask);
+            sigaction (SIGALRM, &act, NULL);
+            ts_sleep.tv_sec = 0;
+            ts_sleep.tv_nsec = 1;
+            alarm (1);
+            if (nanosleep (&ts_sleep, NULL) != 0)
+              return 1;
+            ts_sleep.tv_sec = TYPE_MAXIMUM (time_t);
+            ts_sleep.tv_nsec = 999999999;
+            alarm (1);
+            if (nanosleep (&ts_sleep, &ts_remaining) == -1 && errno == EINTR
+                && TYPE_MAXIMUM (time_t) - 10 < ts_remaining.tv_sec)
+              return 0;
+            return 119;
+          }]])],
+       [gl_cv_func_nanosleep=yes],
+       [case $? in dnl (
+        119) gl_cv_func_nanosleep='no (mishandles large arguments)';; dnl (
+        *)   gl_cv_func_nanosleep=no;;
+        esac],
+       [gl_cv_func_nanosleep=cross-compiling])
+    ])
+   if test "$gl_cv_func_nanosleep" = yes; then
+     REPLACE_NANOSLEEP=0
+   else
+     REPLACE_NANOSLEEP=1
+     if test "$gl_cv_func_nanosleep" = 'no (mishandles large arguments)'; then
+       AC_DEFINE([HAVE_BUG_BIG_NANOSLEEP], [1],
+         [Define to 1 if nanosleep mishandles large arguments.])
+     else
+       for ac_lib in $LIBSOCKET; do
+         case " $LIB_NANOSLEEP " in
+         *" $ac_lib "*) ;;
+         *) LIB_NANOSLEEP="$LIB_NANOSLEEP $ac_lib";;
+         esac
+       done
+     fi
+   fi
+ else
+   HAVE_NANOSLEEP=0
+ fi
  LIBS=$nanosleep_save_libs
+ if test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1; then
+   AC_LIBOBJ([nanosleep])
+   gl_PREREQ_NANOSLEEP
+ fi
 ])
 
 # Prerequisites of lib/nanosleep.c.

diff --git a/m4/time_h.m4 b/m4/time_h.m4
index 7d9984ed37423949f50d2eb3b081a1aea76881d4..b88ba94da1cc7b578cc45464035c1a237a62e73b 100644 (file)
--- a/m4/time_h.m4
+++ b/m4/time_h.m4
@@ -79,6 +79,7 @@ AC_DEFUN([gl_HEADER_TIME_H_DEFAULTS],
   GNULIB_TIME_R=0;                       AC_SUBST([GNULIB_TIME_R])
   dnl Assume proper GNU behavior unless another module says otherwise.
   HAVE_LOCALTIME_R=1;                    AC_SUBST([HAVE_LOCALTIME_R])
+  HAVE_NANOSLEEP=1;                      AC_SUBST([HAVE_NANOSLEEP])
   HAVE_STRPTIME=1;                       AC_SUBST([HAVE_STRPTIME])
   HAVE_TIMEGM=1;                         AC_SUBST([HAVE_TIMEGM])
   dnl If another module says to replace or to not replace, do that.

diff --git a/modules/time b/modules/time
index aee2628a29c3bd76650844101d680ebde020c5ce..52336ed020b06b7d47becb5badf25a706c44bb83 100644 (file)
--- a/modules/time
+++ b/modules/time
@@ -33,6 +33,7 @@ time.h: time.in.h $(CXXDEFS_H) $(ARG_NONNULL_H) $(WARN_ON_USE_H)
              -e 's|@''GNULIB_TIMEGM''@|$(GNULIB_TIMEGM)|g' \
              -e 's|@''GNULIB_TIME_R''@|$(GNULIB_TIME_R)|g' \
              -e 's|@''HAVE_LOCALTIME_R''@|$(HAVE_LOCALTIME_R)|g' \
+             -e 's|@''HAVE_NANOSLEEP''@|$(HAVE_NANOSLEEP)|g' \
              -e 's|@''HAVE_STRPTIME''@|$(HAVE_STRPTIME)|g' \
              -e 's|@''HAVE_TIMEGM''@|$(HAVE_TIMEGM)|g' \
              -e 's|@''REPLACE_LOCALTIME_R''@|$(REPLACE_LOCALTIME_R)|g' \