nanosleep on mingw

[Bruno Haible]

Similarly, on mingw with warn-on-use.h modified to work like if g++ >= 4.3
were present, I'm seeing this error:

  ../gllib/time.h:359: error: `nanosleep' was not declared in this scope

It would also be an error on the other platforms lacking nanosleep,
with g++ 4.3.

Again, to fix this, one needs to distinguish the case where the function
is missing and the case where the function is being replaced (overridden).

Jim, here is a proposed patch. It fixes the error. The big change to
m4/nanosleep.m4 is mostly an indentation change. OK to commit?


2010-04-03  Bruno Haible  <address@hidden>

        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.

--- lib/nanosleep.c.orig        Sat Apr  3 17:46:42 2010
+++ lib/nanosleep.c     Sat Apr  3 17:20:06 2010
@@ -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 @@
    *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;
 
--- lib/time.in.h.orig  Sat Apr  3 17:46:42 2010
+++ lib/time.in.h       Sat Apr  3 17:24:27 2010
@@ -87,6 +87,11 @@
 _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
--- m4/nanosleep.m4.orig        Sat Apr  3 17:46:42 2010
+++ m4/nanosleep.m4     Sat Apr  3 17:35:42 2010
@@ -1,4 +1,4 @@
-# serial 30
+# serial 31
 
 dnl From Jim Meyering.
 dnl Check for the nanosleep function.
@@ -29,93 +29,99 @@
  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)'
+   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))))
+
+          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
-
- 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))))
-
-        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
-    AC_LIBOBJ([nanosleep])
-    gl_PREREQ_NANOSLEEP
-  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.
--- m4/time_h.m4.orig   Sat Apr  3 17:46:42 2010
+++ m4/time_h.m4        Sat Apr  3 17:22:53 2010
@@ -77,6 +77,8 @@
   GNULIB_STRPTIME=0;                     AC_SUBST([GNULIB_STRPTIME])
   GNULIB_TIMEGM=0;                       AC_SUBST([GNULIB_TIMEGM])
   GNULIB_TIME_R=0;                       AC_SUBST([GNULIB_TIME_R])
+  dnl Assume proper GNU behavior unless another module says otherwise.
+  HAVE_NANOSLEEP=1;                      AC_SUBST([HAVE_NANOSLEEP])
   dnl If another module says to replace or to not replace, do that.
   dnl Otherwise, replace only if someone compiles with -DGNULIB_PORTCHECK;
   dnl this lets maintainers check for portability.
--- modules/time.orig   Sat Apr  3 17:46:42 2010
+++ modules/time        Sat Apr  3 17:23:11 2010
@@ -32,6 +32,7 @@
              -e 's|@''GNULIB_STRPTIME''@|$(GNULIB_STRPTIME)|g' \
              -e 's|@''GNULIB_TIMEGM''@|$(GNULIB_TIMEGM)|g' \
              -e 's|@''GNULIB_TIME_R''@|$(GNULIB_TIME_R)|g' \
+             -e 's|@''HAVE_NANOSLEEP''@|$(HAVE_NANOSLEEP)|g' \
              -e 's|@''REPLACE_LOCALTIME_R''@|$(REPLACE_LOCALTIME_R)|g' \
              -e 's|@''REPLACE_MKTIME''@|$(REPLACE_MKTIME)|g' \
              -e 's|@''REPLACE_NANOSLEEP''@|$(REPLACE_NANOSLEEP)|g' \