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

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

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 ...
+  --enable-largefile ...
-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).
 
-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]
 

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.
 

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.
  */

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
+if test "$host" = mips-sni-sysv4 && test -n "$GCC"; then
-    : 
+  : 
-  else
+else
-    AC_SYS_LARGEFILE
+  AC_SYS_LARGEFILE
-  fi
 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(long long, zsh_cv_64_bit_type)
-      zsh_64_BIT_TYPE(${lfs}, zsh_cv_64_bit_type, force)
+     if test "$zsh_cv_64_bit_type" = no; then
-     else
+       zsh_64_BIT_TYPE(quad_t, zsh_cv_64_bit_type)
-       zsh_64_BIT_TYPE(long long, zsh_cv_64_bit_type)
+     fi
-       if test "$zsh_cv_64_bit_type" = no; then
+     if test "$zsh_cv_64_bit_type" = no; then
-         zsh_64_BIT_TYPE(quad_t, zsh_cv_64_bit_type)
+       zsh_64_BIT_TYPE(__int64_t, zsh_cv_64_bit_type)
-       fi
+     fi
-       if test "$zsh_cv_64_bit_type" = no; then
+     dnl As a last resort, if we know off_t has 64 bits, use that as
-         zsh_64_BIT_TYPE(__int64_t, zsh_cv_64_bit_type)
+     dnl the 64-bit integer type.  I don't dare try ino_t since there's
-       fi
+     dnl probably nothing to stop that being unsigned.
-       dnl As a last resort, if we know off_t has 64 bits, use that as
+     if test "$zsh_cv_64_bit_type" = no &&
-       dnl the 64-bit integer type.  I don't dare try ino_t since there's
+        test "$zsh_cv_off_t_is_64_bit" = yes; then
-       dnl probably nothing to stop that being unsigned.
+       zsh_64_BIT_TYPE(off_t, zsh_cv_64_bit_type)
-       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
      fi])
     if test "$zsh_cv_64_bit_type" != no; then
       AC_DEFINE_UNQUOTED(ZSH_64_BIT_TYPE, $zsh_cv_64_bit_type)