25124: work with --(disable|enable)-largefile instead of --(disable|enable)-lfs, since the latter is no longer functional.

5 files changed, 33 insertions, 41 deletions

diff --git a/ChangeLog b/ChangeLog
index da2e655d4..d257ac967 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2008-06-01  Clint Adams  <clint@zsh.org>
+
+	* 25124: INSTALL, MACHINES, configure.ac, Src/zsh.h: work with
+	--(disable|enable)-largefile instead of --(disable|enable)-lfs,
+	since the latter is no longer functional.
+
 2008-05-31  Clint Adams  <clint@zsh.org>
 
 	* 25122: aczsh.m4, configure.ac: use AC_SYS_LARGEFILE for better
diff --git a/INSTALL b/INSTALL
index 1791adcf2..bfef4df61 100644
--- a/INSTALL
+++ b/INSTALL
@@ -469,21 +469,18 @@ Support for large files and integers
 ------------------------------------
 
 Some 32-bit systems allow special compilation modes to get around the 2GB
-file size barrier.  This is enabled by default; use --disable-lfs to turn
+file size barrier.  This is enabled by default; use --disable-largefile to turn
 it off.  Not all systems recognize the test used by zsh (via the getconf
 command), so flags may need to be set by hand.  On HP-UX 10.20, zsh has
 been successfully compiled with large file support by configuring with
   CC="cc -Ae" CPPFLAGS="-D_LARGEFILE_SOURCE -D_FILE64" configure \
-  --enable-lfs ...
-You can also specify --enable-lfs together with a value, which will be
-interpreted as the name of a 64-bit integer type, for example
---enable-lfs="long long" (although this type is checked for anyway).
+  --enable-largefile ...
 
-Furthermore, use of --enable-lfs will also enable 64-bit arithmetic for
+Furthermore, use of --enable-largefile will also enable 64-bit arithmetic for
 shell parameters, and anywhere they are used such as in mathematical
 formulae.  This depends only on the shell finding a suitable 64-bit integer
 type; it does not require that support for large files is actually
-enabled.  Hence --enable-lfs is useful on many 32-bit systems
+enabled.  Hence --enable-largefile is useful on many 32-bit systems
 with a suitable compiler such as gcc.
 
 Also note that if `configure' finds out that either of the types off_t or
@@ -577,6 +574,6 @@ site-fndir=directory # the directory where site-specific functions can go
                      # [DATADIR/zsh/site-functions]
 function-subdirs     # if functions will be installed into subdirectories [no]
 dynamic              # allow dynamically loaded binary modules [yes]
-lfs                  # allow configure check for large files [yes]
+largefile            # allow configure check for large files [yes]
 locale               # allow use of locale library [yes]
 
diff --git a/MACHINES b/MACHINES
index ccb71db1e..81d26b888 100644
--- a/MACHINES
+++ b/MACHINES
@@ -225,7 +225,7 @@ Sun: Solaris 2.x, 8, 9, ...
 	to /usr/ucblib in your LD_LIBRARY_PATH.  You can easily do this
 	by just unsetting LD_LIBRARY_PATH before building zsh.
 
-	Problems were once reported using --enable-lfs (the default) to
+	Problems were once reported using --enable-largefile (the default) to
 	enable large file system and integer support on Solaris 2 with gcc
 	before 2.95.2.  Recent versions of gcc appear to be unproblematic.
 
diff --git a/Src/zsh.h b/Src/zsh.h
index 5618174a8..bbe526fc8 100644
--- a/Src/zsh.h
+++ b/Src/zsh.h
@@ -33,7 +33,8 @@
 /*
  * Our longest integer type:  will be a 64 bit either if long already is,
  * or if we found some alternative such as long long.
- * Currently we only define this to be longer than a long if --enable-lfs
+ * Currently we only define this to be longer than a long if
+ * --enable-largefile
  * was given.  That enables internal use of 64-bit types even if
  * no actual large file support is present.
  */
diff --git a/configure.ac b/configure.ac
index 932d99de5..c4b424389 100644
--- a/configure.ac
+++ b/configure.ac
@@ -210,12 +210,6 @@ AC_SUBST(zprofile)dnl
 AC_SUBST(zlogin)dnl
 AC_SUBST(zlogout)dnl
 
-dnl Do you want large file support, if available?
-ifdef([lfs],[undefine([lfs])])dnl
-AC_ARG_ENABLE(lfs,
-AC_HELP_STRING([--disable-lfs], [turn off support for large files]),
-[lfs="$enableval"], [lfs=yes])
-
 dnl Do you want dynamically loaded binary modules.
 ifdef([dynamic],[undefine([dynamic])])dnl
 AC_ARG_ENABLE(dynamic,
@@ -367,16 +361,14 @@ test -z "${LDFLAGS+set}" && LDFLAGS= auto_ldflags=1
 AC_PROG_CC
 
 dnl Check for large file support.
-dnl This needs to be done early to get the stuff into the flags.
-if test x$lfs != xno; then
+
 dnl Gross hack for ReliantUNIX - GCC does not understand getconf options
 dnl For now just disable LFS in this case
 dnl Any takers?
-  if test "$host" = mips-sni-sysv4 && test -n "$GCC"; then
-    : 
-  else
-    AC_SYS_LARGEFILE
-  fi
+if test "$host" = mips-sni-sysv4 && test -n "$GCC"; then
+  : 
+else
+  AC_SYS_LARGEFILE
 fi
 
 dnl if the user hasn't specified CFLAGS, then
@@ -913,26 +905,22 @@ main() { return sizeof(ino_t) < 8; }
     AC_DEFINE(INO_T_IS_64_BIT)
   fi
 
-  if test x$lfs != xno -o x$zsh_cv_off_t_is_64_bit = xyes \
+  if test x$enable_largefile != xno -o x$zsh_cv_off_t_is_64_bit = xyes \
   -o $zsh_cv_ino_t_is_64_bit = yes; then
     AC_CACHE_CHECK(if compiler has a 64 bit type, zsh_cv_64_bit_type,
-    [if test x$lfs != xyes && test x$lfs != xno; then
-      zsh_64_BIT_TYPE(${lfs}, zsh_cv_64_bit_type, force)
-     else
-       zsh_64_BIT_TYPE(long long, zsh_cv_64_bit_type)
-       if test "$zsh_cv_64_bit_type" = no; then
-         zsh_64_BIT_TYPE(quad_t, zsh_cv_64_bit_type)
-       fi
-       if test "$zsh_cv_64_bit_type" = no; then
-         zsh_64_BIT_TYPE(__int64_t, zsh_cv_64_bit_type)
-       fi
-       dnl As a last resort, if we know off_t has 64 bits, use that as
-       dnl the 64-bit integer type.  I don't dare try ino_t since there's
-       dnl probably nothing to stop that being unsigned.
-       if test "$zsh_cv_64_bit_type" = no &&
-          test "$zsh_cv_off_t_is_64_bit" = yes; then
-         zsh_64_BIT_TYPE(off_t, zsh_cv_64_bit_type)
-       fi
+    [zsh_64_BIT_TYPE(long long, zsh_cv_64_bit_type)
+     if test "$zsh_cv_64_bit_type" = no; then
+       zsh_64_BIT_TYPE(quad_t, zsh_cv_64_bit_type)
+     fi
+     if test "$zsh_cv_64_bit_type" = no; then
+       zsh_64_BIT_TYPE(__int64_t, zsh_cv_64_bit_type)
+     fi
+     dnl As a last resort, if we know off_t has 64 bits, use that as
+     dnl the 64-bit integer type.  I don't dare try ino_t since there's
+     dnl probably nothing to stop that being unsigned.
+     if test "$zsh_cv_64_bit_type" = no &&
+        test "$zsh_cv_off_t_is_64_bit" = yes; then
+       zsh_64_BIT_TYPE(off_t, zsh_cv_64_bit_type)
      fi])
     if test "$zsh_cv_64_bit_type" != no; then
       AC_DEFINE_UNQUOTED(ZSH_64_BIT_TYPE, $zsh_cv_64_bit_type)