aclocal.m4

   1 dnl The following are from prerelease autoconf 2.14a.  When 2.14 is
   2 dnl released, we should be able to zap them and just use AC_PREREQ(2.14).
   3
   4 ifelse(_AC_VERSION_COMPARE(AC_ACVERSION, [2.14]), -1,
   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
  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
 239 AC_SUBST(LIBOBJS)dnl
 240 ])# AC_FUNC_MKTIME
 241
 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
 281
 282 dnl The following is a bit different from the prerelease autoconf at
 283 dnl this time since that requires extra definitions.
 284
 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([$5],
 305         [$6],
 306         ,
 307         [AC_TRY_COMPILE([#define $1 $2]
 308 [$5]
 309            ,
 310            [$6],
 311            [$3=$2])])])
 312    if test "[$]$3" != no; then
 313      AC_DEFINE_UNQUOTED([$1], [$]$3, [$4])
 314    fi])
 315
 316 AC_DEFUN(AC_SYS_LARGEFILE,
 317   [AC_REQUIRE([AC_PROG_CC])
 318    AC_ARG_ENABLE(largefile,
 319      [  --disable-largefile     omit support for large files])
 320    if test "$enable_largefile" != no; then
 321
 322      AC_CACHE_CHECK([for special C compiler options needed for large files],
 323        ac_cv_sys_largefile_CC,
 324        [ac_cv_sys_largefile_CC=no
 325         if test "$GCC" != yes; then
 326           # IRIX 6.2 and later do not support large files by default,
 327           # so use the C compiler's -n32 option if that helps.
 328           AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, , ,
 329             [ac_save_CC="$CC"
 330              CC="$CC -n32"
 331              AC_TRY_COMPILE(AC_SYS_LARGEFILE_TEST_INCLUDES, ,
 332                ac_cv_sys_largefile_CC=' -n32')
 333              CC="$ac_save_CC"])
 334         fi])
 335      if test "$ac_cv_sys_largefile_CC" != no; then
 336        CC="$CC$ac_cv_sys_largefile_CC"
 337      fi
 338
 339      AC_SYS_LARGEFILE_MACRO_VALUE(_FILE_OFFSET_BITS, 64,
 340        ac_cv_sys_file_offset_bits,
 341        [Number of bits in a file offset, on hosts where this is settable.],
 342        AC_SYS_LARGEFILE_TEST_INCLUDES)
 343      AC_SYS_LARGEFILE_MACRO_VALUE(_LARGE_FILES, 1,
 344        ac_cv_sys_large_files,
 345        [Define for large files, on AIX-style hosts.]
 346        AC_SYS_LARGEFILE_TEST_INCLUDES)
 347    fi
 348   ])
 349
 350 AC_DEFUN(AC_FUNC_FSEEKO,
 351   [AC_SYS_LARGEFILE_MACRO_VALUE(_LARGEFILE_SOURCE, 1,
 352      ac_cv_sys_largefile_source,
 353      [Define to make fseeko visible on some hosts (e.g. glibc 2.2).],
 354      [#include <stdio.h>], [return !fseeko;])
 355    # We used to try defining _XOPEN_SOURCE=500 too, to work around a bug
 356    # in glibc 2.1.3, but that breaks too many other things.
 357    # If you want fseeko and ftello with glibc, upgrade to a fixed glibc.
 358
 359    AC_CACHE_CHECK([for fseeko], ac_cv_func_fseeko,
 360      [ac_cv_func_fseeko=no
 361       AC_TRY_LINK([#include <stdio.h>],
 362         [return fseeko && fseeko (stdin, 0, 0);],
 363         [ac_cv_func_fseeko=yes])])
 364    if test $ac_cv_func_fseeko != no; then
 365      AC_DEFINE(HAVE_FSEEKO, 1,
 366        [Define if fseeko (and presumably ftello) exists and is declared.])
 367    fi])
 368
 369 undefine([AC_FUNC_MMAP])dnl
 370 dnl The autoconf 2.13 version loses on OSF, at least,
 371 dnl by messing up the declaration of malloc.
 372 AC_DEFUN([AC_FUNC_MMAP],
 373 [AC_CHECK_HEADERS(stdlib.h unistd.h sys/stat.h)
 374 AC_CHECK_FUNCS(getpagesize)
 375 AC_CACHE_CHECK(for working mmap, ac_cv_func_mmap_fixed_mapped,
 376 [AC_TRY_RUN(
 377 [/* Thanks to Mike Haertel and Jim Avera for this test.
 378    Here is a matrix of mmap possibilities:
 379         mmap private not fixed
 380         mmap private fixed at somewhere currently unmapped
 381         mmap private fixed at somewhere already mapped
 382         mmap shared not fixed
 383         mmap shared fixed at somewhere currently unmapped
 384         mmap shared fixed at somewhere already mapped
 385    For private mappings, we should verify that changes cannot be read()
 386    back from the file, nor mmap's back from the file at a different
 387    address.  (There have been systems where private was not correctly
 388    implemented like the infamous i386 svr4.0, and systems where the
 389    VM page cache was not coherent with the file system buffer cache
 390    like early versions of FreeBSD and possibly contemporary NetBSD.)
 391    For shared mappings, we should conversely verify that changes get
 392    propogated back to all the places they're supposed to be.
 393
 394    Grep wants private fixed already mapped.
 395    The main things grep needs to know about mmap are:
 396    * does it exist and is it safe to write into the mmap'd area
 397    * how to use it (BSD variants)  */
 398 #include <sys/types.h>
 399 #include <fcntl.h>
 400 #include <sys/mman.h>
 401
 402 #if STDC_HEADERS || HAVE_STDLIB_H
 403 # include <stdlib.h>
 404 #else
 405 char *malloc ();
 406 #endif
 407 #if HAVE_UNISTD_H
 408 # include <unistd.h>
 409 #endif
 410 #if HAVE_SYS_STAT_H
 411 # include <sys/stat.h>
 412 #endif
 413
 414 /* This mess was copied from the GNU getpagesize.h.  */
 415 #if !HAVE_GETPAGESIZE
 416 /* Assume that all systems that can run configure have sys/param.h.  */
 417 # if !HAVE_SYS_PARAM_H
 418 #  define HAVE_SYS_PARAM_H 1
 419 # endif
 420
 421 # ifdef _SC_PAGESIZE
 422 #  define getpagesize() sysconf(_SC_PAGESIZE)
 423 # else /* no _SC_PAGESIZE */
 424 #  if HAVE_SYS_PARAM_H
 425 #   include <sys/param.h>
 426 #   ifdef EXEC_PAGESIZE
 427 #    define getpagesize() EXEC_PAGESIZE
 428 #   else /* no EXEC_PAGESIZE */
 429 #    ifdef NBPG
 430 #     define getpagesize() NBPG * CLSIZE
 431 #     ifndef CLSIZE
 432 #      define CLSIZE 1
 433 #     endif /* no CLSIZE */
 434 #    else /* no NBPG */
 435 #     ifdef NBPC
 436 #      define getpagesize() NBPC
 437 #     else /* no NBPC */
 438 #      ifdef PAGESIZE
 439 #       define getpagesize() PAGESIZE
 440 #      endif /* PAGESIZE */
 441 #     endif /* no NBPC */
 442 #    endif /* no NBPG */
 443 #   endif /* no EXEC_PAGESIZE */
 444 #  else /* no HAVE_SYS_PARAM_H */
 445 #   define getpagesize() 8192   /* punt totally */
 446 #  endif /* no HAVE_SYS_PARAM_H */
 447 # endif /* no _SC_PAGESIZE */
 448
 449 #endif /* no HAVE_GETPAGESIZE */
 450
 451 int
 452 main ()
 453 {
 454   char *data, *data2, *data3;
 455   int i, pagesize;
 456   int fd;
 457
 458   pagesize = getpagesize ();
 459
 460   /* First, make a file with some known garbage in it. */
 461   data = (char *) malloc (pagesize);
 462   if (!data)
 463     exit (1);
 464   for (i = 0; i < pagesize; ++i)
 465     *(data + i) = rand ();
 466   umask (0);
 467   fd = creat ("conftestmmap", 0600);
 468   if (fd < 0)
 469     exit (1);
 470   if (write (fd, data, pagesize) != pagesize)
 471     exit (1);
 472   close (fd);
 473
 474   /* Next, try to mmap the file at a fixed address which already has
 475      something else allocated at it.  If we can, also make sure that
 476      we see the same garbage.  */
 477   fd = open ("conftestmmap", O_RDWR);
 478   if (fd < 0)
 479     exit (1);
 480   data2 = (char *) malloc (2 * pagesize);
 481   if (!data2)
 482     exit (1);
 483   data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
 484   if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE,
 485                      MAP_PRIVATE | MAP_FIXED, fd, 0L))
 486     exit (1);
 487   for (i = 0; i < pagesize; ++i)
 488     if (*(data + i) != *(data2 + i))
 489       exit (1);
 490
 491   /* Finally, make sure that changes to the mapped area do not
 492      percolate back to the file as seen by read().  (This is a bug on
 493      some variants of i386 svr4.0.)  */
 494   for (i = 0; i < pagesize; ++i)
 495     *(data2 + i) = *(data2 + i) + 1;
 496   data3 = (char *) malloc (pagesize);
 497   if (!data3)
 498     exit (1);
 499   if (read (fd, data3, pagesize) != pagesize)
 500     exit (1);
 501   for (i = 0; i < pagesize; ++i)
 502     if (*(data + i) != *(data3 + i))
 503       exit (1);
 504   close (fd);
 505   unlink ("conftestmmap");
 506   exit (0);
 507 }], ac_cv_func_mmap_fixed_mapped=yes, ac_cv_func_mmap_fixed_mapped=no,
 508 ac_cv_func_mmap_fixed_mapped=no)])
 509 if test $ac_cv_func_mmap_fixed_mapped = yes; then
 510   AC_DEFINE(HAVE_MMAP, 1,
 511             [Define if you have a working `mmap' system call.])
 512 fi
 513 ])# AC_FUNC_MMAP
 514
 515 ) dnl ifelse