[bpt/emacs.git] / aclocal.m4

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).

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(AC_SYS_LARGEFILE_TEST_INCLUDES
$5
        ,
	[$6], 
	,
	[AC_TRY_COMPILE([#define $1 $2]
AC_SYS_LARGEFILE_TEST_INCLUDES
$5
	   ,
	   [$6],
	   [$3=$2])])])
   if test "[$]$3" != no; then
     AC_DEFINE_UNQUOTED([$1], [$]$3, [$4])
   fi])

AC_DEFUN(AC_SYS_LARGEFILE,
  [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_MACRO_VALUE(_LARGEFILE_SOURCE, 1,
       ac_cv_sys_largefile_source,
       [Define to make ftello visible on some hosts (e.g. HP-UX 10.20).],
       [#include <stdio.h>], [return !ftello;])
     AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1,
       ac_cv_sys_large_files,
       [Define for large files, on AIX-style hosts.])
     AC_SYS_LARGEFILE_MACRO_VALUE(_XOPEN_SOURCE, 500,
       ac_cv_sys_xopen_source,
       [Define to make ftello visible on some hosts (e.g. glibc 2.1.3).],
       [#include <stdio.h>], [return !ftello;])
   fi
  ])

) dnl ifelse
Commit	Line	Data
8e82f0c2	1	dnl The following are from prerelease autoconf 2.14a. When 2.14 is
4487f86d	2	dnl released, we should be able to zap them and just use AC_PREREQ(2.14).
8e82f0c2	3
6a465756	4	ifelse(_AC_VERSION_COMPARE(AC_ACVERSION, [2.14]), -1,
8e82f0c2 DL	5
	6	# AC_PROG_CC_STDC
	7	# ---------------
	8	# If the C compiler in not in ANSI C mode by default, try to add an
	9	# option to output variable @code{CC} to make it so. This macro tries
	10	# various options that select ANSI C on some system or another. It
	11	# considers the compiler to be in ANSI C mode if it handles function
	12	# prototypes correctly.
	13	AC_DEFUN(AC_PROG_CC_STDC,
	14	[AC_REQUIRE([AC_PROG_CC])dnl
	15	AC_BEFORE([$0], [AC_C_INLINE])dnl
	16	AC_BEFORE([$0], [AC_C_CONST])dnl
	17	dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require
	18	dnl a magic option to avoid problems with ANSI preprocessor commands
	19	dnl like #elif.
	20	dnl FIXME: can't do this because then AC_AIX won't work due to a
	21	dnl circular dependency.
	22	dnl AC_BEFORE([$0], [AC_PROG_CPP])
	23	AC_MSG_CHECKING(for ${CC-cc} option to accept ANSI C)
	24	AC_CACHE_VAL(ac_cv_prog_cc_stdc,
	25	[ac_cv_prog_cc_stdc=no
	26	ac_save_CC="$CC"
	27	# Don't try gcc -ansi; that turns off useful extensions and
	28	# breaks some systems' header files.
	29	# AIX -qlanglvl=ansi
	30	# Ultrix and OSF/1 -std1
	31	# HP-UX 10.20 and later -Ae
	32	# HP-UX older versions -Aa -D_HPUX_SOURCE
	33	# SVR4 -Xc -D__EXTENSIONS__
	34	for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
	35	do
	36	CC="$ac_save_CC $ac_arg"
	37	AC_TRY_COMPILE(
	38	[#include <stdarg.h>
	39	#include <stdio.h>
	40	#include <sys/types.h>
	41	#include <sys/stat.h>
	42	/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
	43	struct buf { int x; };
	44	FILE * (rcsopen) (struct buf , struct stat *, int);
	45	static char *e (p, i)
	46	char **p;
	47	int i;
	48	{
	49	return p[i];
	50	}
	51	static char f (char (g) (char , int), char *p, ...)
	52	{
	53	char *s;
	54	va_list v;
	55	va_start (v,p);
	56	s = g (p, va_arg (v,int));
	57	va_end (v);
	58	return s;
	59	}
	60	int test (int i, double x);
	61	struct s1 {int (*f) (int a);};
	62	struct s2 {int (*f) (double a);};
	63	int pairnames (int, char *, FILE ()(struct buf , struct stat *, int), int, int);
	64	int argc;
	65	char **argv;],
	66	[return f (e, argv, 0) != argv[0] \|\| f (e, argv, 1) != argv[1];],
	67	[ac_cv_prog_cc_stdc="$ac_arg"; break])
	68	done
69	CC="$ac_save_CC"
70	])
71	case "x$ac_cv_prog_cc_stdc" in
72	x\|xno)
73	AC_MSG_RESULT([none needed]) ;;
74	*)
75	AC_MSG_RESULT($ac_cv_prog_cc_stdc)
76	CC="$CC $ac_cv_prog_cc_stdc" ;;
77	esac
78	])# AC_PROG_CC_STDC
79
4487f86d DL	80	# AC_FUNC_MKTIME
	81	# --------------
	82	AC_DEFUN(AC_FUNC_MKTIME,
	83	[AC_REQUIRE([AC_HEADER_TIME])dnl
	84	AC_CHECK_HEADERS(sys/time.h unistd.h)
	85	AC_CHECK_FUNCS(alarm)
	86	AC_CACHE_CHECK([for working mktime], ac_cv_func_working_mktime,
	87	[AC_TRY_RUN(
	88	[/* Test program from Paul Eggert (eggert@twinsun.com)
	89	and Tony Leneis (tony@plaza.ds.adp.com). */
	90	#if TIME_WITH_SYS_TIME
	91	# include <sys/time.h>
	92	# include <time.h>
	93	#else
	94	# if HAVE_SYS_TIME_H
	95	# include <sys/time.h>
	96	# else
	97	# include <time.h>
	98	# endif
	99	#endif
	100
	101	#if HAVE_UNISTD_H
	102	# include <unistd.h>
	103	#endif
	104
	105	#if !HAVE_ALARM
	106	# define alarm(X) /* empty */
	107	#endif
	108
	109	/* Work around redefinition to rpl_putenv by other config tests. */
	110	#undef putenv
	111
	112	static time_t time_t_max;
	113
	114	/* Values we'll use to set the TZ environment variable. */
	115	static const char *const tz_strings[] = {
	116	(const char *) 0, "TZ=GMT0", "TZ=JST-9",
	117	"TZ=EST+3EDT+2,M10.1.0/00:00:00,M2.3.0/00:00:00"
	118	};
	119	#define N_STRINGS (sizeof (tz_strings) / sizeof (tz_strings[0]))
	120
	121	/* Fail if mktime fails to convert a date in the spring-forward gap.
	122	Based on a problem report from Andreas Jaeger. */
	123	static void
	124	spring_forward_gap ()
	125	{
	126	/* glibc (up to about 1998-10-07) failed this test) */
	127	struct tm tm;
	128
	129	/* Use the portable POSIX.1 specification "TZ=PST8PDT,M4.1.0,M10.5.0"
	130	instead of "TZ=America/Vancouver" in order to detect the bug even
	131	on systems that don't support the Olson extension, or don't have the
	132	full zoneinfo tables installed. */
	133	putenv ("TZ=PST8PDT,M4.1.0,M10.5.0");
	134
	135	tm.tm_year = 98;
	136	tm.tm_mon = 3;
	137	tm.tm_mday = 5;
	138	tm.tm_hour = 2;
	139	tm.tm_min = 0;
	140	tm.tm_sec = 0;
	141	tm.tm_isdst = -1;
	142	if (mktime (&tm) == (time_t)-1)
	143	exit (1);
144	}
145
146	static void
147	mktime_test (now)
148	time_t now;
149	{
150	struct tm *lt;
151	if ((lt = localtime (&now)) && mktime (lt) != now)
152	exit (1);
153	now = time_t_max - now;
154	if ((lt = localtime (&now)) && mktime (lt) != now)
155	exit (1);
156	}
157
158	static void
159	irix_6_4_bug ()
160	{
161	/* Based on code from Ariel Faigon. */
162	struct tm tm;
163	tm.tm_year = 96;
164	tm.tm_mon = 3;
165	tm.tm_mday = 0;
166	tm.tm_hour = 0;
167	tm.tm_min = 0;
168	tm.tm_sec = 0;
169	tm.tm_isdst = -1;
170	mktime (&tm);
171	if (tm.tm_mon != 2 \|\| tm.tm_mday != 31)
172	exit (1);
173	}
174
175	static void
176	bigtime_test (j)
177	int j;
178	{
179	struct tm tm;
180	time_t now;
181	tm.tm_year = tm.tm_mon = tm.tm_mday = tm.tm_hour = tm.tm_min = tm.tm_sec = j;
182	now = mktime (&tm);
183	if (now != (time_t) -1)
184	{
185	struct tm *lt = localtime (&now);
186	if (! (lt
187	&& lt->tm_year == tm.tm_year
188	&& lt->tm_mon == tm.tm_mon
189	&& lt->tm_mday == tm.tm_mday
190	&& lt->tm_hour == tm.tm_hour
191	&& lt->tm_min == tm.tm_min
192	&& lt->tm_sec == tm.tm_sec
193	&& lt->tm_yday == tm.tm_yday
194	&& lt->tm_wday == tm.tm_wday
195	&& ((lt->tm_isdst < 0 ? -1 : 0 < lt->tm_isdst)
196	== (tm.tm_isdst < 0 ? -1 : 0 < tm.tm_isdst))))
197	exit (1);
198	}
199	}
200
201	int
202	main ()
203	{
204	time_t t, delta;
205	int i, j;
206
207	/* This test makes some buggy mktime implementations loop.
208	Give up after 60 seconds; a mktime slower than that
209	isn't worth using anyway. */
210	alarm (60);
211
212	for (time_t_max = 1; 0 < time_t_max; time_t_max *= 2)
213	continue;
214	time_t_max--;
215	delta = time_t_max / 997; /* a suitable prime number */
216	for (i = 0; i < N_STRINGS; i++)
217	{
218	if (tz_strings[i])
219	putenv (tz_strings[i]);
220
221	for (t = 0; t <= time_t_max - delta; t += delta)
222	mktime_test (t);
223	mktime_test ((time_t) 60 * 60);
224	mktime_test ((time_t) 60 * 60 * 24);
225
226	for (j = 1; 0 < j; j *= 2)
227	bigtime_test (j);
228	bigtime_test (j - 1);
229	}
230	irix_6_4_bug ();
231	spring_forward_gap ();
232	exit (0);
233	}],
234	ac_cv_func_working_mktime=yes, ac_cv_func_working_mktime=no,
235	ac_cv_func_working_mktime=no)])
236	if test $ac_cv_func_working_mktime = no; then
237	LIBOBJS="$LIBOBJS mktime.${ac_objext}"
238	fi
0b8f263e	239	AC_SUBST(LIBOBJS)dnl
4487f86d DL	240	])# AC_FUNC_MKTIME
4487f86d DL	241
8e82f0c2 DL	242	# AC_C_VOLATILE
	243	# -------------
	244	# Note that, unlike const, #defining volatile to be the empty string can
	245	# actually turn a correct program into an incorrect one, since removing
	246	# uses of volatile actually grants the compiler permission to perform
	247	# optimizations that could break the user's code. So, do not #define
	248	# volatile away unless it is really necessary to allow the user's code
	249	# to compile cleanly. Benign compiler failures should be tolerated.
	250	AC_DEFUN(AC_C_VOLATILE,
	251	[AC_REQUIRE([AC_PROG_CC_STDC])dnl
	252	AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
	253	[AC_TRY_COMPILE(,[
	254	volatile int x;
	255	int * volatile y;],
	256	ac_cv_c_volatile=yes, ac_cv_c_volatile=no)])
	257	if test $ac_cv_c_volatile = no; then
	258	AC_DEFINE(volatile,,
	259	[Define to empty if the keyword `volatile' does not work.
	260	Warning: valid code using `volatile' can become incorrect
	261	without. Disable with care.])
	262	fi
	263	])
	264
	265	# AC_C_PROTOTYPES
	266	# ---------------
	267	# Check if the C compiler supports prototypes, included if it needs
	268	# options.
	269	AC_DEFUN(AC_C_PROTOTYPES,
	270	[AC_REQUIRE([AC_PROG_CC_STDC])dnl
	271	AC_REQUIRE([AC_PROG_CPP])dnl
	272	AC_MSG_CHECKING([for function prototypes])
	273	if test "$ac_cv_prog_cc_stdc" != no; then
	274	AC_MSG_RESULT(yes)
	275	AC_DEFINE(PROTOTYPES, 1,
	276	[Define if the compiler supports function prototypes.])
	277	else
	278	AC_MSG_RESULT(no)
	279	fi
	280	])# AC_C_PROTOTYPES
7101aecf	281
6a465756 DL	282	dnl The following is a bit different from the prerelease autoconf at
6a465756 DL	283	dnl this time since that requires extra definitions.
edcc1067	284
7101aecf DL	285	dnl By default, many hosts won't let programs access large files;
	286	dnl one must use special compiler options to get large-file access to work.
	287	dnl For more details about this brain damage please see:
	288	dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
	289
	290	dnl Written by Paul Eggert <eggert@twinsun.com>.
	291
	292	dnl Internal subroutine of AC_SYS_LARGEFILE.
	293	dnl AC_SYS_LARGEFILE_TEST_INCLUDES
	294	AC_DEFUN(AC_SYS_LARGEFILE_TEST_INCLUDES,
	295	[[#include <sys/types.h>
	296	int a[(off_t) 9223372036854775807 == 9223372036854775807 ? 1 : -1];
	297	]])
	298
	299	dnl Internal subroutine of AC_SYS_LARGEFILE.
	300	dnl AC_SYS_LARGEFILE_MACRO_VALUE(C-MACRO, VALUE, CACHE-VAR, COMMENT, INCLUDES, FUNCTION-BODY)
	301	AC_DEFUN(AC_SYS_LARGEFILE_MACRO_VALUE,
	302	[AC_CACHE_CHECK([for $1 value needed for large files], $3,
	303	[$3=no
	304	AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES
	305	$5
	306	,
	307	[$6],
	308	,
	309	[AC_TRY_COMPILE([#define $1 $2]
	310	AC_SYS_LARGEFILE_TEST_INCLUDES
	311	$5
	312	,
	313	[$6],
	314	[$3=$2])])])
	315	if test "[$]$3" != no; then
	316	AC_DEFINE_UNQUOTED([$1], [$]$3, [$4])
	317	fi])
	318
	319	AC_DEFUN(AC_SYS_LARGEFILE,
	320	[AC_ARG_ENABLE(largefile,
	321	[ --disable-largefile omit support for large files])
	322	if test "$enable_largefile" != no; then
	323
	324	AC_CACHE_CHECK([for special C compiler options needed for large files],
	325	ac_cv_sys_largefile_CC,
	326	[ac_cv_sys_largefile_CC=no
	327	if test "$GCC" != yes; then
	328	# IRIX 6.2 and later do not support large files by default,
	329	# so use the C compiler's -n32 option if that helps.
	330	AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, , ,
	331	[ac_save_CC="$CC"
	332	CC="$CC -n32"
	333	AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, ,
	334	ac_cv_sys_largefile_CC=' -n32')
	335	CC="$ac_save_CC"])
	336	fi])
	337	if test "$ac_cv_sys_largefile_CC" != no; then
	338	CC="$CC$ac_cv_sys_largefile_CC"
	339	fi
	340
	341	AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64,
	342	ac_cv_sys_file_offset_bits,
	343	[Number of bits in a file offset, on hosts where this is settable.])
	344	AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1,
	345	ac_cv_sys_largefile_source,
	346	[Define to make ftello visible on some hosts (e.g. HP-UX 10.20).],
	347	[#include <stdio.h>], [return !ftello;])
	348	AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1,
349	ac_cv_sys_large_files,
350	[Define for large files, on AIX-style hosts.])
351	AC_SYS_LARGEFILE_MACRO_VALUE(_XOPEN_SOURCE, 500,
352	ac_cv_sys_xopen_source,
353	[Define to make ftello visible on some hosts (e.g. glibc 2.1.3).],
354	[#include <stdio.h>], [return !ftello;])
355	fi
356	])
6a465756 DL	357
6a465756 DL	358	) dnl ifelse