mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-14 09:39:42 +00:00
535 lines
16 KiB
Plaintext
535 lines
16 KiB
Plaintext
dnl The following are from prerelease autoconf 2.14a. When 2.14 is
|
|
dnl released, we should be able to zap them and just use AC_PREREQ(2.14).
|
|
|
|
% Copyright (C) 2000, 2001 Free Software Foundation, Inc.
|
|
%
|
|
% This file is part of GNU Emacs.
|
|
%
|
|
% GNU Emacs is free software; you can redistribute it and/or modify
|
|
% it under the terms of the GNU General Public License as published by
|
|
% the Free Software Foundation; either version 2, or (at your option)
|
|
% any later version.
|
|
%
|
|
% GNU Emacs is distributed in the hope that it will be useful,
|
|
% but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
% GNU General Public License for more details.
|
|
%
|
|
% You should have received a copy of the GNU General Public License
|
|
% along with GNU Emacs; see the file COPYING. If not, write to the
|
|
% Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
% Boston, MA 02111-1307, USA.
|
|
|
|
ifelse(_AC_VERSION_COMPARE(AC_ACVERSION, [2.14]), -1,
|
|
|
|
# AC_PROG_CC_STDC
|
|
# ---------------
|
|
# If the C compiler in not in ANSI C mode by default, try to add an
|
|
# option to output variable @code{CC} to make it so. This macro tries
|
|
# various options that select ANSI C on some system or another. It
|
|
# considers the compiler to be in ANSI C mode if it handles function
|
|
# prototypes correctly.
|
|
AC_DEFUN(AC_PROG_CC_STDC,
|
|
[AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_BEFORE([$0], [AC_C_INLINE])dnl
|
|
AC_BEFORE([$0], [AC_C_CONST])dnl
|
|
dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require
|
|
dnl a magic option to avoid problems with ANSI preprocessor commands
|
|
dnl like #elif.
|
|
dnl FIXME: can't do this because then AC_AIX won't work due to a
|
|
dnl circular dependency.
|
|
dnl AC_BEFORE([$0], [AC_PROG_CPP])
|
|
AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C)
|
|
AC_CACHE_VAL(ac_cv_prog_cc_stdc,
|
|
[ac_cv_prog_cc_stdc=no
|
|
ac_save_CC="$CC"
|
|
# Don't try gcc -ansi; that turns off useful extensions and
|
|
# breaks some systems' header files.
|
|
# AIX -qlanglvl=ansi
|
|
# Ultrix and OSF/1 -std1
|
|
# HP-UX 10.20 and later -Ae
|
|
# HP-UX older versions -Aa -D_HPUX_SOURCE
|
|
# SVR4 -Xc -D__EXTENSIONS__
|
|
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
|
|
do
|
|
CC="$ac_save_CC $ac_arg"
|
|
AC_TRY_COMPILE(
|
|
[#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
|
|
struct buf { int x; };
|
|
FILE * (*rcsopen) (struct buf *, struct stat *, int);
|
|
static char *e (p, i)
|
|
char **p;
|
|
int i;
|
|
{
|
|
return p[i];
|
|
}
|
|
static char *f (char * (*g) (char **, int), char **p, ...)
|
|
{
|
|
char *s;
|
|
va_list v;
|
|
va_start (v,p);
|
|
s = g (p, va_arg (v,int));
|
|
va_end (v);
|
|
return s;
|
|
}
|
|
int test (int i, double x);
|
|
struct s1 {int (*f) (int a);};
|
|
struct s2 {int (*f) (double a);};
|
|
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
|
|
int argc;
|
|
char **argv;],
|
|
[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];],
|
|
[ac_cv_prog_cc_stdc="$ac_arg"; break])
|
|
done
|
|
CC="$ac_save_CC"
|
|
])
|
|
case "x$ac_cv_prog_cc_stdc" in
|
|
x|xno)
|
|
AC_MSG_RESULT([none needed]) ;;
|
|
*)
|
|
AC_MSG_RESULT($ac_cv_prog_cc_stdc)
|
|
CC="$CC $ac_cv_prog_cc_stdc" ;;
|
|
esac
|
|
])# AC_PROG_CC_STDC
|
|
|
|
# AC_FUNC_MKTIME
|
|
# --------------
|
|
AC_DEFUN(AC_FUNC_MKTIME,
|
|
[AC_REQUIRE([AC_HEADER_TIME])dnl
|
|
AC_CHECK_HEADERS(sys/time.h unistd.h)
|
|
AC_CHECK_FUNCS(alarm)
|
|
AC_CACHE_CHECK([for working mktime], ac_cv_func_working_mktime,
|
|
[AC_TRY_RUN(
|
|
[/* Test program from Paul Eggert (eggert@twinsun.com)
|
|
and Tony Leneis (tony@plaza.ds.adp.com). */
|
|
#if TIME_WITH_SYS_TIME
|
|
# include <sys/time.h>
|
|
# include <time.h>
|
|
#else
|
|
# if HAVE_SYS_TIME_H
|
|
# include <sys/time.h>
|
|
# else
|
|
# include <time.h>
|
|
# endif
|
|
#endif
|
|
|
|
#if HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
|
|
#if !HAVE_ALARM
|
|
# define alarm(X) /* empty */
|
|
#endif
|
|
|
|
/* Work around redefinition to rpl_putenv by other config tests. */
|
|
#undef putenv
|
|
|
|
static time_t time_t_max;
|
|
|
|
/* Values we'll use to set the TZ environment variable. */
|
|
static const char *const tz_strings[] = {
|
|
(const char *) 0, "TZ=GMT0", "TZ=JST-9",
|
|
"TZ=EST+3EDT+2,M10.1.0/00:00:00,M2.3.0/00:00:00"
|
|
};
|
|
#define N_STRINGS (sizeof (tz_strings) / sizeof (tz_strings[0]))
|
|
|
|
/* Fail if mktime fails to convert a date in the spring-forward gap.
|
|
Based on a problem report from Andreas Jaeger. */
|
|
static void
|
|
spring_forward_gap ()
|
|
{
|
|
/* glibc (up to about 1998-10-07) failed this test) */
|
|
struct tm tm;
|
|
|
|
/* Use the portable POSIX.1 specification "TZ=PST8PDT,M4.1.0,M10.5.0"
|
|
instead of "TZ=America/Vancouver" in order to detect the bug even
|
|
on systems that don't support the Olson extension, or don't have the
|
|
full zoneinfo tables installed. */
|
|
putenv ("TZ=PST8PDT,M4.1.0,M10.5.0");
|
|
|
|
tm.tm_year = 98;
|
|
tm.tm_mon = 3;
|
|
tm.tm_mday = 5;
|
|
tm.tm_hour = 2;
|
|
tm.tm_min = 0;
|
|
tm.tm_sec = 0;
|
|
tm.tm_isdst = -1;
|
|
if (mktime (&tm) == (time_t)-1)
|
|
exit (1);
|
|
}
|
|
|
|
static void
|
|
mktime_test (now)
|
|
time_t now;
|
|
{
|
|
struct tm *lt;
|
|
if ((lt = localtime (&now)) && mktime (lt) != now)
|
|
exit (1);
|
|
now = time_t_max - now;
|
|
if ((lt = localtime (&now)) && mktime (lt) != now)
|
|
exit (1);
|
|
}
|
|
|
|
static void
|
|
irix_6_4_bug ()
|
|
{
|
|
/* Based on code from Ariel Faigon. */
|
|
struct tm tm;
|
|
tm.tm_year = 96;
|
|
tm.tm_mon = 3;
|
|
tm.tm_mday = 0;
|
|
tm.tm_hour = 0;
|
|
tm.tm_min = 0;
|
|
tm.tm_sec = 0;
|
|
tm.tm_isdst = -1;
|
|
mktime (&tm);
|
|
if (tm.tm_mon != 2 || tm.tm_mday != 31)
|
|
exit (1);
|
|
}
|
|
|
|
static void
|
|
bigtime_test (j)
|
|
int j;
|
|
{
|
|
struct tm tm;
|
|
time_t now;
|
|
tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = j;
|
|
now = mktime (&tm);
|
|
if (now != (time_t) -1)
|
|
{
|
|
struct tm *lt = localtime (&now);
|
|
if (! (lt
|
|
&& lt->tm_year == tm.tm_year
|
|
&& lt->tm_mon == tm.tm_mon
|
|
&& lt->tm_mday == tm.tm_mday
|
|
&& lt->tm_hour == tm.tm_hour
|
|
&& lt->tm_min == tm.tm_min
|
|
&& lt->tm_sec == tm.tm_sec
|
|
&& lt->tm_yday == tm.tm_yday
|
|
&& lt->tm_wday == tm.tm_wday
|
|
&& ((lt->tm_isdst < 0 ? -1 : 0 < lt->tm_isdst)
|
|
== (tm.tm_isdst < 0 ? -1 : 0 < tm.tm_isdst))))
|
|
exit (1);
|
|
}
|
|
}
|
|
|
|
int
|
|
main ()
|
|
{
|
|
time_t t, delta;
|
|
int i, j;
|
|
|
|
/* This test makes some buggy mktime implementations loop.
|
|
Give up after 60 seconds; a mktime slower than that
|
|
isn't worth using anyway. */
|
|
alarm (60);
|
|
|
|
for (time_t_max = 1; 0 < time_t_max; time_t_max *= 2)
|
|
continue;
|
|
time_t_max--;
|
|
delta = time_t_max / 997; /* a suitable prime number */
|
|
for (i = 0; i < N_STRINGS; i++)
|
|
{
|
|
if (tz_strings[i])
|
|
putenv (tz_strings[i]);
|
|
|
|
for (t = 0; t <= time_t_max - delta; t += delta)
|
|
mktime_test (t);
|
|
mktime_test ((time_t) 60 * 60);
|
|
mktime_test ((time_t) 60 * 60 * 24);
|
|
|
|
for (j = 1; 0 < j; j *= 2)
|
|
bigtime_test (j);
|
|
bigtime_test (j - 1);
|
|
}
|
|
irix_6_4_bug ();
|
|
spring_forward_gap ();
|
|
exit (0);
|
|
}],
|
|
ac_cv_func_working_mktime=yes, ac_cv_func_working_mktime=no,
|
|
ac_cv_func_working_mktime=no)])
|
|
if test $ac_cv_func_working_mktime = no; then
|
|
LIBOBJS="$LIBOBJS mktime.${ac_objext}"
|
|
fi
|
|
AC_SUBST(LIBOBJS)dnl
|
|
])# AC_FUNC_MKTIME
|
|
|
|
# AC_C_VOLATILE
|
|
# -------------
|
|
# Note that, unlike const, #defining volatile to be the empty string can
|
|
# actually turn a correct program into an incorrect one, since removing
|
|
# uses of volatile actually grants the compiler permission to perform
|
|
# optimizations that could break the user's code. So, do not #define
|
|
# volatile away unless it is really necessary to allow the user's code
|
|
# to compile cleanly. Benign compiler failures should be tolerated.
|
|
AC_DEFUN(AC_C_VOLATILE,
|
|
[AC_REQUIRE([AC_PROG_CC_STDC])dnl
|
|
AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
|
|
[AC_TRY_COMPILE(,[
|
|
volatile int x;
|
|
int * volatile y;],
|
|
ac_cv_c_volatile=yes, ac_cv_c_volatile=no)])
|
|
if test $ac_cv_c_volatile = no; then
|
|
AC_DEFINE(volatile,,
|
|
[Define to empty if the keyword `volatile' does not work.
|
|
Warning: valid code using `volatile' can become incorrect
|
|
without. Disable with care.])
|
|
fi
|
|
])
|
|
|
|
# AC_C_PROTOTYPES
|
|
# ---------------
|
|
# Check if the C compiler supports prototypes, included if it needs
|
|
# options.
|
|
AC_DEFUN(AC_C_PROTOTYPES,
|
|
[AC_REQUIRE([AC_PROG_CC_STDC])dnl
|
|
AC_REQUIRE([AC_PROG_CPP])dnl
|
|
AC_MSG_CHECKING([for function prototypes])
|
|
if test "$ac_cv_prog_cc_stdc" != no; then
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(PROTOTYPES, 1,
|
|
[Define if the compiler supports function prototypes.])
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
])# AC_C_PROTOTYPES
|
|
|
|
dnl The following is a bit different from the prerelease autoconf at
|
|
dnl this time since that requires extra definitions.
|
|
|
|
dnl By default, many hosts won't let programs access large files;
|
|
dnl one must use special compiler options to get large-file access to work.
|
|
dnl For more details about this brain damage please see:
|
|
dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
|
|
|
|
dnl Written by Paul Eggert <eggert@twinsun.com>.
|
|
|
|
dnl Internal subroutine of AC_SYS_LARGEFILE.
|
|
dnl AC_SYS_LARGEFILE_TEST_INCLUDES
|
|
AC_DEFUN(AC_SYS_LARGEFILE_TEST_INCLUDES,
|
|
[[#include <sys/types.h>
|
|
int a[(off_t) 9223372036854775807 == 9223372036854775807 ? 1 : -1];
|
|
]])
|
|
|
|
dnl Internal subroutine of AC_SYS_LARGEFILE.
|
|
dnl AC_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR, COMMENT, INCLUDES, FUNCTION-BODY)
|
|
AC_DEFUN(AC_SYS_LARGEFILE_MACRO_VALUE,
|
|
[AC_CACHE_CHECK([for $1 value needed for large files], $3,
|
|
[$3=no
|
|
AC_TRY_COMPILE([$5],
|
|
[$6],
|
|
,
|
|
[AC_TRY_COMPILE([#define $1 $2]
|
|
[$5]
|
|
,
|
|
[$6],
|
|
[$3=$2])])])
|
|
if test "[$]$3" != no; then
|
|
AC_DEFINE_UNQUOTED([$1], [$]$3, [$4])
|
|
fi])
|
|
|
|
AC_DEFUN(AC_SYS_LARGEFILE,
|
|
[AC_REQUIRE([AC_PROG_CC])
|
|
AC_ARG_ENABLE(largefile,
|
|
[ --disable-largefile omit support for large files])
|
|
if test "$enable_largefile" != no; then
|
|
|
|
AC_CACHE_CHECK([for special C compiler options needed for large files],
|
|
ac_cv_sys_largefile_CC,
|
|
[ac_cv_sys_largefile_CC=no
|
|
if test "$GCC" != yes; then
|
|
# IRIX 6.2 and later do not support large files by default,
|
|
# so use the C compiler's -n32 option if that helps.
|
|
AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, , ,
|
|
[ac_save_CC="$CC"
|
|
CC="$CC -n32"
|
|
AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, ,
|
|
ac_cv_sys_largefile_CC=' -n32')
|
|
CC="$ac_save_CC"])
|
|
fi])
|
|
if test "$ac_cv_sys_largefile_CC" != no; then
|
|
CC="$CC$ac_cv_sys_largefile_CC"
|
|
fi
|
|
|
|
AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64,
|
|
ac_cv_sys_file_offset_bits,
|
|
[Number of bits in a file offset, on hosts where this is settable.],
|
|
AC_SYS_LARGEFILE_TEST_INCLUDES)
|
|
AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1,
|
|
ac_cv_sys_large_files,
|
|
[Define for large files, on AIX-style hosts.]
|
|
AC_SYS_LARGEFILE_TEST_INCLUDES)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_FUNC_FSEEKO,
|
|
[AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1,
|
|
ac_cv_sys_largefile_source,
|
|
[Define to make fseeko visible on some hosts (e.g. glibc 2.2).],
|
|
[#include <stdio.h>], [return !fseeko;])
|
|
# We used to try defining _XOPEN_SOURCE=500 too, to work around a bug
|
|
# in glibc 2.1.3, but that breaks too many other things.
|
|
# If you want fseeko and ftello with glibc, upgrade to a fixed glibc.
|
|
|
|
AC_CACHE_CHECK([for fseeko], ac_cv_func_fseeko,
|
|
[ac_cv_func_fseeko=no
|
|
AC_TRY_LINK([#include <stdio.h>],
|
|
[return fseeko && fseeko (stdin, 0, 0);],
|
|
[ac_cv_func_fseeko=yes])])
|
|
if test $ac_cv_func_fseeko != no; then
|
|
AC_DEFINE(HAVE_FSEEKO, 1,
|
|
[Define if fseeko (and presumably ftello) exists and is declared.])
|
|
fi])
|
|
|
|
undefine([AC_FUNC_MMAP])dnl
|
|
dnl The autoconf 2.13 version loses on OSF, at least,
|
|
dnl by messing up the declaration of malloc.
|
|
AC_DEFUN([AC_FUNC_MMAP],
|
|
[AC_CHECK_HEADERS(stdlib.h unistd.h sys/stat.h)
|
|
AC_CHECK_FUNCS(getpagesize)
|
|
AC_CACHE_CHECK(for working mmap, ac_cv_func_mmap_fixed_mapped,
|
|
[AC_TRY_RUN(
|
|
[/* Thanks to Mike Haertel and Jim Avera for this test.
|
|
Here is a matrix of mmap possibilities:
|
|
mmap private not fixed
|
|
mmap private fixed at somewhere currently unmapped
|
|
mmap private fixed at somewhere already mapped
|
|
mmap shared not fixed
|
|
mmap shared fixed at somewhere currently unmapped
|
|
mmap shared fixed at somewhere already mapped
|
|
For private mappings, we should verify that changes cannot be read()
|
|
back from the file, nor mmap's back from the file at a different
|
|
address. (There have been systems where private was not correctly
|
|
implemented like the infamous i386 svr4.0, and systems where the
|
|
VM page cache was not coherent with the file system buffer cache
|
|
like early versions of FreeBSD and possibly contemporary NetBSD.)
|
|
For shared mappings, we should conversely verify that changes get
|
|
propogated back to all the places they're supposed to be.
|
|
|
|
Grep wants private fixed already mapped.
|
|
The main things grep needs to know about mmap are:
|
|
* does it exist and is it safe to write into the mmap'd area
|
|
* how to use it (BSD variants) */
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#include <sys/mman.h>
|
|
|
|
#if STDC_HEADERS || HAVE_STDLIB_H
|
|
# include <stdlib.h>
|
|
#else
|
|
char *malloc ();
|
|
#endif
|
|
#if HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#if HAVE_SYS_STAT_H
|
|
# include <sys/stat.h>
|
|
#endif
|
|
|
|
/* This mess was copied from the GNU getpagesize.h. */
|
|
#if !HAVE_GETPAGESIZE
|
|
/* Assume that all systems that can run configure have sys/param.h. */
|
|
# if !HAVE_SYS_PARAM_H
|
|
# define HAVE_SYS_PARAM_H 1
|
|
# endif
|
|
|
|
# ifdef _SC_PAGESIZE
|
|
# define getpagesize() sysconf(_SC_PAGESIZE)
|
|
# else /* no _SC_PAGESIZE */
|
|
# if HAVE_SYS_PARAM_H
|
|
# include <sys/param.h>
|
|
# ifdef EXEC_PAGESIZE
|
|
# define getpagesize() EXEC_PAGESIZE
|
|
# else /* no EXEC_PAGESIZE */
|
|
# ifdef NBPG
|
|
# define getpagesize() NBPG * CLSIZE
|
|
# ifndef CLSIZE
|
|
# define CLSIZE 1
|
|
# endif /* no CLSIZE */
|
|
# else /* no NBPG */
|
|
# ifdef NBPC
|
|
# define getpagesize() NBPC
|
|
# else /* no NBPC */
|
|
# ifdef PAGESIZE
|
|
# define getpagesize() PAGESIZE
|
|
# endif /* PAGESIZE */
|
|
# endif /* no NBPC */
|
|
# endif /* no NBPG */
|
|
# endif /* no EXEC_PAGESIZE */
|
|
# else /* no HAVE_SYS_PARAM_H */
|
|
# define getpagesize() 8192 /* punt totally */
|
|
# endif /* no HAVE_SYS_PARAM_H */
|
|
# endif /* no _SC_PAGESIZE */
|
|
|
|
#endif /* no HAVE_GETPAGESIZE */
|
|
|
|
int
|
|
main ()
|
|
{
|
|
char *data, *data2, *data3;
|
|
int i, pagesize;
|
|
int fd;
|
|
|
|
pagesize = getpagesize ();
|
|
|
|
/* First, make a file with some known garbage in it. */
|
|
data = (char *) malloc (pagesize);
|
|
if (!data)
|
|
exit (1);
|
|
for (i = 0; i < pagesize; ++i)
|
|
*(data + i) = rand ();
|
|
umask (0);
|
|
fd = creat ("conftestmmap", 0600);
|
|
if (fd < 0)
|
|
exit (1);
|
|
if (write (fd, data, pagesize) != pagesize)
|
|
exit (1);
|
|
close (fd);
|
|
|
|
/* Next, try to mmap the file at a fixed address which already has
|
|
something else allocated at it. If we can, also make sure that
|
|
we see the same garbage. */
|
|
fd = open ("conftestmmap", O_RDWR);
|
|
if (fd < 0)
|
|
exit (1);
|
|
data2 = (char *) malloc (2 * pagesize);
|
|
if (!data2)
|
|
exit (1);
|
|
data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
|
|
if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
|
|
MAP_PRIVATE | MAP_FIXED, fd, 0L))
|
|
exit (1);
|
|
for (i = 0; i < pagesize; ++i)
|
|
if (*(data + i) != *(data2 + i))
|
|
exit (1);
|
|
|
|
/* Finally, make sure that changes to the mapped area do not
|
|
percolate back to the file as seen by read(). (This is a bug on
|
|
some variants of i386 svr4.0.) */
|
|
for (i = 0; i < pagesize; ++i)
|
|
*(data2 + i) = *(data2 + i) + 1;
|
|
data3 = (char *) malloc (pagesize);
|
|
if (!data3)
|
|
exit (1);
|
|
if (read (fd, data3, pagesize) != pagesize)
|
|
exit (1);
|
|
for (i = 0; i < pagesize; ++i)
|
|
if (*(data + i) != *(data3 + i))
|
|
exit (1);
|
|
close (fd);
|
|
unlink ("conftestmmap");
|
|
exit (0);
|
|
}], ac_cv_func_mmap_fixed_mapped=yes, ac_cv_func_mmap_fixed_mapped=no,
|
|
ac_cv_func_mmap_fixed_mapped=no)])
|
|
if test $ac_cv_func_mmap_fixed_mapped = yes; then
|
|
AC_DEFINE(HAVE_MMAP, 1,
|
|
[Define if you have a working `mmap' system call.])
|
|
fi
|
|
])# AC_FUNC_MMAP
|
|
|
|
) dnl ifelse
|