Sync with the latest Gnulib code (d4ec02b3cc)refs/pull/2037/head

1 files changed, 110 insertions, 119 deletions

diff --git a/gl/m4/largefile.m4 b/gl/m4/largefile.m4
index 7fb81b8..2f82408 100644
--- a/gl/m4/largefile.m4
+++ b/gl/m4/largefile.m4
@@ -1,16 +1,18 @@
+# largefile.m4
+# serial 1
+dnl Copyright 1992-1996, 1998-2024 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.
+
 # Enable large files on systems where this is not the default.
 # Enable support for files on Linux file systems with 64-bit inode numbers.
 
-# Copyright 1992-1996, 1998-2023 Free Software Foundation, Inc.
-# This file is free software; the Free Software Foundation
-# gives unlimited permission to copy and/or distribute it,
-# with or without modifications, as long as this notice is preserved.
-
 # The following macro works around a problem in Autoconf's AC_FUNC_FSEEKO:
 # It does not set _LARGEFILE_SOURCE=1 on HP-UX/ia64 32-bit, although this
 # setting of _LARGEFILE_SOURCE is needed so that <stdio.h> declares fseeko
 # and ftello in C++ mode as well.
-# Fixed in Autoconf 2.72, which has AC_SYS_YEAR2038.
+# This problem occurs in Autoconf 2.71 and earlier, which lack AC_SYS_YEAR2038.
 AC_DEFUN([gl_SET_LARGEFILE_SOURCE],
  m4_ifndef([AC_SYS_YEAR2038], [[
   AC_REQUIRE([AC_CANONICAL_HOST])
@@ -24,29 +26,20 @@ AC_DEFUN([gl_SET_LARGEFILE_SOURCE],
  ]])
 )
 
-# Work around a problem in autoconf <= 2.69:
-# AC_SYS_LARGEFILE does not configure for large inodes on Mac OS X 10.5,
-# or configures them incorrectly in some cases.
-m4_version_prereq([2.70], [], [
-
-# _AC_SYS_LARGEFILE_TEST_INCLUDES
-# -------------------------------
-m4_define([_AC_SYS_LARGEFILE_TEST_INCLUDES],
-[#include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
-    since some C++ compilers masquerading as C compilers
-    incorrectly reject 9223372036854775807.  */
-#define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[[(LARGE_OFF_T % 2147483629 == 721
-                       && LARGE_OFF_T % 2147483647 == 1)
-                      ? 1 : -1]];[]dnl
-])
-])# m4_version_prereq 2.70
+dnl Remove AC_SYS_YEAR2038_RECOMMENDED if unpatched Autoconf 2.72 or earlier.
+dnl Autoconf 2.72 still uses -n32, which is not a C preprocessor option,
+dnl and which was useful only on IRIX which is no longer supported.
+dnl This should be fixed in Autoconf 2.73.
+m4_ifdef([AC_SYS_YEAR2038_RECOMMENDED],
+  [m4_bmatch(m4_ifdef([_AC_SYS_LARGEFILE_OPTIONS],
+               [m4_defn([_AC_SYS_LARGEFILE_OPTIONS])],
+               ["-n32"]),
+     ["-n32"],
+       [m4_undefine([AC_SYS_YEAR2038_RECOMMENDED])])])
 
-# Support AC_SYS_YEAR2038, even if Autoconf 2.71 or earlier.
-# This code is taken from Autoconf master.
-m4_ifndef([AC_SYS_YEAR2038], [
+m4_ifndef([AC_SYS_YEAR2038_RECOMMENDED], [
+# Fix up AC_SYS_YEAR2038_RECOMMENDED and related macros, even if
+# unpatched Autoconf 2.72 or earlier.  This code is taken from Autoconf master.
 
 # _AC_SYS_YEAR2038_TEST_CODE
 # --------------------------
@@ -78,8 +71,8 @@ m4_define([_AC_SYS_YEAR2038_OPTIONS], m4_normalize(
                                       dnl 32-bit MinGW (misconfiguration)
 ))
 
-# _AC_SYS_YEAR2038_PROBE([IF-NOT-DETECTED])
-# -----------------------------------------
+# _AC_SYS_YEAR2038_PROBE
+# ----------------------
 # Subroutine of AC_SYS_YEAR2038.  Probe for time_t that can represent
 # time points more than 2**31 - 1 seconds after the epoch (dates after
 # 2038-01-18, see above) and set the cache variable ac_cv_sys_year2038_opts
@@ -92,13 +85,10 @@ m4_define([_AC_SYS_YEAR2038_OPTIONS], m4_normalize(
 # AC_TRY_RUN.  Note also that some systems only support large time_t
 # together with large off_t.
 #
-# If support is not detected, the behavior depends on which of the
-# top-level AC_SYS_YEAR2038 macros was used (see below).
-#
 # If you change this macro you may also need to change
 # _AC_SYS_YEAR2038_OPTIONS.
 AC_DEFUN([_AC_SYS_YEAR2038_PROBE],
-[AC_CACHE_CHECK([for $CC option to enable timestamps after Jan 2038],
+[AC_CACHE_CHECK([for $CPPFLAGS option for timestamps after 2038],
   [ac_cv_sys_year2038_opts],
   [ac_save_CPPFLAGS="$CPPFLAGS"
   ac_opt_found=no
@@ -117,40 +107,20 @@ ac_have_year2038=yes
 AS_CASE([$ac_cv_sys_year2038_opts],
   ["none needed"], [],
   ["support not detected"],
-    [ac_have_year2038=no
-     AS_CASE([$enable_year2038],
-      [yes],
-        [# If we're not cross compiling and 'touch' works with a large
-        # timestamp, then we can presume the system supports wider time_t
-        # *somehow* and we just weren't able to detect it.  One common
-        # case that we deliberately *don't* probe for is a system that
-        # supports both 32- and 64-bit ABIs but only the 64-bit ABI offers
-        # wide time_t.  (It would be inappropriate for us to override an
-        # intentional use of -m32.)  Error out, demanding use of
-        # --disable-year2038 if this is intentional.
-        AS_IF([test $cross_compiling = no],
-          [AS_IF([TZ=UTC0 touch -t 210602070628.15 conftest.time 2>/dev/null],
-            [AS_CASE([`TZ=UTC0 LC_ALL=C ls -l conftest.time 2>/dev/null`],
-              [*'Feb  7  2106'* | *'Feb  7 17:10'*],
-              [AC_MSG_FAILURE(m4_text_wrap(
-      [this system appears to support timestamps after January 2038,
-       but no mechanism for enabling wide 'time_t' was detected.
-       Did you mean to build a 64-bit binary? (e.g. 'CC="${CC} -m64"'.)
-       To proceed with 32-bit time_t, configure with '--disable-year2038'.],
-      [], [], [55]))])])])])],
+    [ac_have_year2038=no],
 
   ["-D_TIME_BITS=64"],
     [AC_DEFINE([_TIME_BITS], [64],
       [Number of bits in time_t, on hosts where this is settable.])],
 
-  ["-D__MINGW_USE_VC2005_COMPAT=1"],
+  ["-D__MINGW_USE_VC2005_COMPAT"],
     [AC_DEFINE([__MINGW_USE_VC2005_COMPAT], [1],
       [Define to 1 on platforms where this makes time_t a 64-bit type.])],
 
   ["-U_USE_32_BIT_TIME_T"*],
     [AC_MSG_FAILURE(m4_text_wrap(
       [the 'time_t' type is currently forced to be 32-bit.
-       It will stop working after January 2038.
+       It will stop working after mid-January 2038.
        Remove _USE_32BIT_TIME_T from the compiler flags.],
       [], [], [55]))],
 
@@ -160,12 +130,11 @@ AS_CASE([$ac_cv_sys_year2038_opts],
 
 # _AC_SYS_YEAR2038_ENABLE
 # -----------------------
-# Subroutine of AC_SYS_YEAR2038 and _AC_SYS_YEAR2038_OPT_IN.
 # Depending on which of the YEAR2038 macros was used, add either an
-# --enable-year2038, or a --disable-year2038, or no option at all to
-# the configure script.  Note that this is expanded very late and
+# --enable-year2038 or a --disable-year2038 to
+# the configure script.  This is expanded very late and
 # therefore there cannot be any code in the AC_ARG_ENABLE.  The
-# default value for enable_year2038 is emitted unconditionally
+# default value for 'enable_year2038' is emitted unconditionally
 # because the generated code always looks at this variable.
 m4_define([_AC_SYS_YEAR2038_ENABLE],
 [m4_divert_text([DEFAULTS],
@@ -175,50 +144,70 @@ m4_define([_AC_SYS_YEAR2038_ENABLE],
 [AC_ARG_ENABLE([year2038],
   m4_provide_if([AC_SYS_YEAR2038],
     [AS_HELP_STRING([--disable-year2038],
-      [do not support timestamps after 2038])],
+      [don't support timestamps after 2038])],
     [AS_HELP_STRING([--enable-year2038],
       [support timestamps after 2038])]))])
 
-# _AC_SYS_YEAR2038_OPT_IN
-# -----------------------
-# If the --enable-year2038 option is given to configure, attempt to
-# detect and activate support for large time_t on 32-bit systems.
-# This macro is automatically invoked by AC_SYS_LARGEFILE when large
-# *file* support is detected.  It does not AC_REQUIRE AC_SYS_LARGEFILE
-# to avoid a dependency loop, and is therefore unsafe to expose as a
-# documented macro.
-AC_DEFUN([_AC_SYS_YEAR2038_OPT_IN],
-[m4_provide_if([_AC_SYS_YEAR2038_PROBE], [], [dnl
-  AS_IF([test "$enable_year2038" != no], [_AC_SYS_YEAR2038_PROBE])
-  AC_CONFIG_COMMANDS_PRE([_AC_SYS_YEAR2038_ENABLE])
-])])
-
 # AC_SYS_YEAR2038
 # ---------------
 # Attempt to detect and activate support for large time_t.
 # On systems where time_t is not always 64 bits, this probe can be
 # skipped by passing the --disable-year2038 option to configure.
 AC_DEFUN([AC_SYS_YEAR2038],
-[AC_REQUIRE([AC_SYS_LARGEFILE])]dnl
-[m4_provide_if([_AC_SYS_YEAR2038_PROBE], [], [dnl
-  AS_IF([test "$enable_year2038" != no], [_AC_SYS_YEAR2038_PROBE])
-  AC_CONFIG_COMMANDS_PRE([_AC_SYS_YEAR2038_ENABLE])
-])])
+[AC_REQUIRE([AC_SYS_LARGEFILE])dnl
+AS_IF([test "$enable_year2038,$ac_have_year2038,$cross_compiling" = yes,no,no],
+ [# If we're not cross compiling and 'touch' works with a large
+  # timestamp, then we can presume the system supports wider time_t
+  # *somehow* and we just weren't able to detect it.  One common
+  # case that we deliberately *don't* probe for is a system that
+  # supports both 32- and 64-bit ABIs but only the 64-bit ABI offers
+  # wide time_t.  (It would be inappropriate for us to override an
+  # intentional use of -m32.)  Error out, demanding use of
+  # --disable-year2038 if this is intentional.
+  AS_IF([TZ=UTC0 touch -t 210602070628.15 conftest.time 2>/dev/null],
+    [AS_CASE([`TZ=UTC0 LC_ALL=C ls -l conftest.time 2>/dev/null`],
+       [*'Feb  7  2106'* | *'Feb  7 17:10'*],
+       [AC_MSG_FAILURE(m4_text_wrap(
+          [this system appears to support timestamps after mid-January 2038,
+           but no mechanism for enabling wide 'time_t' was detected.
+           Did you mean to build a 64-bit binary? (E.g., 'CC="${CC} -m64"'.)
+           To proceed with 32-bit time_t, configure with '--disable-year2038'.],
+          [], [], [55]))])])])])
+
+# AC_SYS_YEAR2038_RECOMMENDED
+# ---------------------------
+# Same as AC_SYS_YEAR2038, but recommend support for large time_t.
+# If we cannot find any way to make time_t capable of representing
+# values larger than 2**31 - 1, error out unless --disable-year2038 is given.
+AC_DEFUN([AC_SYS_YEAR2038_RECOMMENDED],
+[AC_REQUIRE([AC_SYS_YEAR2038])dnl
+AS_IF([test "$enable_year2038,$ac_have_year2038" = yes,no],
+   [AC_MSG_FAILURE(m4_text_wrap(
+      [could not enable timestamps after mid-January 2038.
+       This package recommends support for these later timestamps.
+       However, to proceed with signed 32-bit time_t even though it
+       will fail then, configure with '--disable-year2038'.],
+      [], [], [55]))])])
 
 # _AC_SYS_LARGEFILE_TEST_CODE
 # ---------------------------
 # C code used to probe for large file support.
 m4_define([_AC_SYS_LARGEFILE_TEST_CODE],
 [@%:@include <sys/types.h>
- /* Check that off_t can represent 2**63 - 1 correctly.
-    We can't simply define LARGE_OFF_T to be 9223372036854775807,
+@%:@ifndef FTYPE
+@%:@ define FTYPE off_t
+@%:@endif
+ /* Check that FTYPE can represent 2**63 - 1 correctly.
+    We can't simply define LARGE_FTYPE to be 9223372036854775807,
     since some C++ compilers masquerading as C compilers
     incorrectly reject 9223372036854775807.  */
-@%:@define LARGE_OFF_T (((off_t) 1 << 31 << 31) - 1 + ((off_t) 1 << 31 << 31))
-  int off_t_is_large[[(LARGE_OFF_T % 2147483629 == 721
-                       && LARGE_OFF_T % 2147483647 == 1)
+@%:@define LARGE_FTYPE (((FTYPE) 1 << 31 << 31) - 1 + ((FTYPE) 1 << 31 << 31))
+  int FTYPE_is_large[[(LARGE_FTYPE % 2147483629 == 721
+                       && LARGE_FTYPE % 2147483647 == 1)
                       ? 1 : -1]];[]dnl
 ])
+# Defined by Autoconf 2.71 and circa 2022 Gnulib unwisely depended on it.
+m4_define([_AC_SYS_LARGEFILE_TEST_INCLUDES], [_AC_SYS_LARGEFILE_TEST_CODE])
 
 # _AC_SYS_LARGEFILE_OPTIONS
 # -------------------------
@@ -228,8 +217,7 @@ m4_define([_AC_SYS_LARGEFILE_TEST_CODE],
 m4_define([_AC_SYS_LARGEFILE_OPTIONS], m4_normalize(
     ["none needed"]                   dnl Most current systems
     ["-D_FILE_OFFSET_BITS=64"]        dnl X/Open LFS spec
-    ["-D_LARGE_FILES=1"]              dnl AIX (which versions?)
-    ["-n32"]                          dnl Irix 6.2 w/ SGI compiler
+    ["-D_LARGE_FILES=1"]              dnl 32-bit AIX 4.2.1+, 32-bit z/OS
 ))
 
 # _AC_SYS_LARGEFILE_PROBE
@@ -246,24 +234,43 @@ m4_define([_AC_SYS_LARGEFILE_OPTIONS], m4_normalize(
 # If you change this macro you may also need to change
 # _AC_SYS_LARGEFILE_OPTIONS.
 AC_DEFUN([_AC_SYS_LARGEFILE_PROBE],
-[AC_CACHE_CHECK([for $CC option to enable large file support],
+[AC_CACHE_CHECK([for $CPPFLAGS option for large files],
   [ac_cv_sys_largefile_opts],
-  [ac_save_CC="$CC"
+  [ac_save_CPPFLAGS=$CPPFLAGS
   ac_opt_found=no
   for ac_opt in _AC_SYS_LARGEFILE_OPTIONS; do
     AS_IF([test x"$ac_opt" != x"none needed"],
-      [CC="$ac_save_CC $ac_opt"])
+      [CPPFLAGS="$ac_save_CPPFLAGS $ac_opt"])
     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([_AC_SYS_LARGEFILE_TEST_CODE])],
-      [ac_cv_sys_largefile_opts="$ac_opt"
+     [AS_IF([test x"$ac_opt" = x"none needed"],
+        [# GNU/Linux s390x and alpha need _FILE_OFFSET_BITS=64 for wide ino_t.
+         CPPFLAGS="$CPPFLAGS -DFTYPE=ino_t"
+         AC_COMPILE_IFELSE([], [],
+           [CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64"
+            AC_COMPILE_IFELSE([], [ac_opt='-D_FILE_OFFSET_BITS=64'])])])
+      ac_cv_sys_largefile_opts=$ac_opt
       ac_opt_found=yes])
     test $ac_opt_found = no || break
   done
-  CC="$ac_save_CC"
+  CPPFLAGS=$ac_save_CPPFLAGS
+  dnl Gnulib implements large file support for native Windows, based on the
+  dnl variables WINDOWS_64_BIT_OFF_T, WINDOWS_64_BIT_ST_SIZE.
+  m4_ifdef([gl_LARGEFILE], [
+    AC_REQUIRE([AC_CANONICAL_HOST])
+    if test $ac_opt_found != yes; then
+      AS_CASE([$host_os],
+        [mingw* | windows*],
+          [ac_cv_sys_largefile_opts="supported through gnulib"
+           ac_opt_found=yes]
+      )
+    fi
+  ])
   test $ac_opt_found = yes || ac_cv_sys_largefile_opts="support not detected"])
 
 ac_have_largefile=yes
 AS_CASE([$ac_cv_sys_largefile_opts],
   ["none needed"], [],
+  ["supported through gnulib"], [],
   ["support not detected"],
     [ac_have_largefile=no],
 
@@ -275,27 +282,12 @@ AS_CASE([$ac_cv_sys_largefile_opts],
     [AC_DEFINE([_LARGE_FILES], [1],
       [Define to 1 on platforms where this makes off_t a 64-bit type.])],
 
-  ["-n32"],
-    [CC="$CC -n32"],
-
   [AC_MSG_ERROR(
     [internal error: bad value for \$ac_cv_sys_largefile_opts])])
 
-_AC_SYS_YEAR2038_OPT_IN
-])
-
-# _AC_SYS_LARGEFILE_ENABLE
-# ------------------------
-# Subroutine of AC_SYS_LARGEFILE.  Note that this
-# is expanded very late and therefore there cannot be any code in the
-# AC_ARG_ENABLE.  The default value for enable_largefile is emitted
-# unconditionally because the generated shell code always looks at
-# this variable.
-m4_define([_AC_SYS_LARGEFILE_ENABLE],
-[m4_divert_text([DEFAULTS],
-  enable_largefile=yes)]dnl
-[AC_ARG_ENABLE([largefile],
-  [AS_HELP_STRING([--disable-largefile], [omit support for large files])])])
+AS_IF([test "$enable_year2038" != no],
+  [_AC_SYS_YEAR2038_PROBE])
+AC_CONFIG_COMMANDS_PRE([_AC_SYS_YEAR2038_ENABLE])])
 
 # AC_SYS_LARGEFILE
 # ----------------
@@ -306,14 +298,13 @@ m4_define([_AC_SYS_LARGEFILE_ENABLE],
 # Additionally, on Linux file systems with 64-bit inodes a file that happens
 # to have a 64-bit inode number cannot be accessed by 32-bit applications on
 # Linux x86/x86_64.  This can occur with file systems such as XFS and NFS.
-# This macro allows configuration to continue if the system doesn't support
-# large files.
 AC_DEFUN([AC_SYS_LARGEFILE],
-[m4_provide_if([_AC_SYS_LARGEFILE_PROBE], [], [dnl
-  AS_IF([test "$enable_largefile" != no], [_AC_SYS_LARGEFILE_PROBE])
-  AC_CONFIG_COMMANDS_PRE([_AC_SYS_LARGEFILE_ENABLE])
-])])
-])# m4_ifndef AC_SYS_YEAR2038
+[AC_ARG_ENABLE([largefile],
+   [AS_HELP_STRING([--disable-largefile],
+      [omit support for large files])])dnl
+AS_IF([test "$enable_largefile,$enable_year2038" != no,no],
+  [_AC_SYS_LARGEFILE_PROBE])])
+])# m4_ifndef AC_SYS_YEAR2038_RECOMMENDED
 
 # Enable large files on systems where this is implemented by Gnulib, not by the
 # system headers.
@@ -323,7 +314,7 @@ AC_DEFUN([gl_LARGEFILE],
 [
   AC_REQUIRE([AC_CANONICAL_HOST])
   case "$host_os" in
-    mingw*)
+    mingw* | windows*)
       dnl Native Windows.
       dnl mingw64 defines off_t to a 64-bit type already, if
       dnl _FILE_OFFSET_BITS=64, which is ensured by AC_SYS_LARGEFILE.