autoconf/acspecific.m4

   1 dnl Macros that test for specific features.
   2 dnl This file is part of Autoconf.
   3 dnl Copyright (C) 1992, 93, 94, 95, 96, 1998 Free Software Foundation, Inc.
   4 dnl
   5 dnl This program is free software; you can redistribute it and/or modify
   6 dnl it under the terms of the GNU General Public License as published by
   7 dnl the Free Software Foundation; either version 2, or (at your option)
   8 dnl any later version.
   9 dnl
  10 dnl This program is distributed in the hope that it will be useful,
  11 dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 dnl GNU General Public License for more details.
  14 dnl
  15 dnl You should have received a copy of the GNU General Public License
  16 dnl along with this program; if not, write to the Free Software
  17 dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18 dnl 02111-1307, USA.
  19 dnl
  20 dnl As a special exception, the Free Software Foundation gives unlimited
  21 dnl permission to copy, distribute and modify the configure scripts that
  22 dnl are the output of Autoconf.  You need not follow the terms of the GNU
  23 dnl General Public License when using or distributing such scripts, even
  24 dnl though portions of the text of Autoconf appear in them.  The GNU
  25 dnl General Public License (GPL) does govern all other use of the material
  26 dnl that constitutes the Autoconf program.
  27 dnl
  28 dnl Certain portions of the Autoconf source text are designed to be copied
  29 dnl (in certain cases, depending on the input) into the output of
  30 dnl Autoconf.  We call these the "data" portions.  The rest of the Autoconf
  31 dnl source text consists of comments plus executable code that decides which
  32 dnl of the data portions to output in any given case.  We call these
  33 dnl comments and executable code the "non-data" portions.  Autoconf never
  34 dnl copies any of the non-data portions into its output.
  35 dnl
  36 dnl This special exception to the GPL applies to versions of Autoconf
  37 dnl released by the Free Software Foundation.  When you make and
  38 dnl distribute a modified version of Autoconf, you may extend this special
  39 dnl exception to the GPL to apply to your modified version as well, *unless*
  40 dnl your modified version has the potential to copy into its output some
  41 dnl of the text that was the non-data portion of the version that you started
  42 dnl with.  (In other words, unless your change moves or copies text from
  43 dnl the non-data portions to the data portions.)  If your modification has
  44 dnl such potential, you must delete any notice of this special exception
  45 dnl to the GPL from your modified version.
  46 dnl
  47 dnl Written by David MacKenzie, with help from
  48 dnl Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
  49 dnl Roland McGrath, Noah Friedman, david d zuhn, and many others.
  50 dnl
  51 dnl Changed by Bruno Haible, 18 January 1999
  52
  53
  54 dnl ### Checks for programs
  55
  56
  57 dnl Check whether to use -n, \c, or newline-tab to separate
  58 dnl checking messages from result messages.
  59 dnl Idea borrowed from dist 3.0.
  60 dnl Internal use only.
  61 AC_DEFUN(AC_PROG_ECHO_N,
  62 [if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
  63   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
  64   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
  65     ac_n= ac_c='
  66 ' ac_t='        ' ac_tt=
  67   else
  68     ac_n=-n ac_c= ac_t= ac_tt='
  69          '
  70   fi
  71 else
  72   ac_n= ac_c='\c' ac_t= ac_tt='
  73          '
  74 fi
  75 ])
  76
  77 AC_DEFUN(AC_PROG_CC,
  78 [AC_BEFORE([$0], [AC_PROG_CPP])dnl
  79 AC_CHECK_PROG(CC, gcc, gcc)
  80 if test -z "$CC"; then
  81   AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
  82   if test -z "$CC"; then
  83     case "`uname -s`" in
  84     *win32* | *WIN32*)
  85       AC_CHECK_PROG(CC, cl, cl) ;;
  86     esac
  87   fi
  88   test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
  89 fi
  90
  91 AC_PROG_CC_WORKS
  92 AC_PROG_CC_GNU
  93
  94 if test $ac_cv_prog_gcc = yes; then
  95   GCC=yes
  96 else
  97   GCC=
  98 fi
  99
 100 dnl Check whether -g works, even if CFLAGS is set, in case the package
 101 dnl plays around with CFLAGS (such as to build both debugging and
 102 dnl normal versions of a library), tasteless as that idea is.
 103 ac_test_CFLAGS="${CFLAGS+set}"
 104 ac_save_CFLAGS="$CFLAGS"
 105 CFLAGS=
 106 dnl AC_PROG_CC_G
 107 if test "$ac_test_CFLAGS" = set; then
 108   CFLAGS="$ac_save_CFLAGS"
 109 dnl # This doesn't work on Linux (libc-4.5.26): Because of differences between
 110 dnl # the shared and the static libraries there are less symbols available
 111 dnl # without -g than with -g. It is therefore better to run the configuration
 112 dnl # without -g and to add -g afterwards than the contrary. So don't add
 113 dnl # -g to the CFLAGS now.
 114 dnl elif test $ac_cv_prog_cc_g = yes; then
 115 dnl   if test "$GCC" = yes; then
 116 dnl     CFLAGS="-g -O2"
 117 dnl   else
 118 dnl     CFLAGS="-g"
 119 dnl   fi
 120 else
 121   if test "$GCC" = yes; then
 122 dnl     CFLAGS="-O"
 123     # Add "-O" to both the CC and CPP commands, to eliminate possible confusion
 124     # that results from __OPTIMIZE__ being defined for CC but not CPP.
 125 changequote(, )dnl
 126     if echo "$CC " | grep ' -O[1-9 ]' > /dev/null 2>&1; then
 127 changequote([, ])dnl
 128       : # already optimizing
 129     else
 130       CC="$CC -O"
 131       ac_cv_prog_CC="$CC"
 132     fi
 133   else
 134     CFLAGS=
 135   fi
 136 fi
 137 ])
 138
 139 AC_DEFUN(AC_PROG_CXX,
 140 [AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
 141 AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++ cl, gcc)
 142
 143 AC_PROG_CXX_WORKS
 144 AC_PROG_CXX_GNU
 145
 146 if test $ac_cv_prog_gxx = yes; then
 147   GXX=yes
 148 else
 149   GXX=
 150 fi
 151
 152 dnl Check whether -g works, even if CXXFLAGS is set, in case the package
 153 dnl plays around with CXXFLAGS (such as to build both debugging and
 154 dnl normal versions of a library), tasteless as that idea is.
 155 ac_test_CXXFLAGS="${CXXFLAGS+set}"
 156 ac_save_CXXFLAGS="$CXXFLAGS"
 157 CXXFLAGS=
 158 dnl AC_PROG_CXX_G
 159 if test "$ac_test_CXXFLAGS" = set; then
 160   CXXFLAGS="$ac_save_CXXFLAGS"
 161 dnl # This doesn't work on Linux (libc-4.5.26): Because of differences between
 162 dnl # the shared and the static libraries there are less symbols available
 163 dnl # without -g than with -g. It is therefore better to run the configuration
 164 dnl # without -g and to add -g afterwards than the contrary. So don't add
 165 dnl # -g to the CFLAGS now.
 166 dnl elif test $ac_cv_prog_cxx_g = yes; then
 167 dnl   if test "$GXX" = yes; then
 168 dnl     CXXFLAGS="-g -O2"
 169 dnl   else
 170 dnl     CXXFLAGS="-g"
 171 dnl   fi
 172 else
 173   if test "$GXX" = yes; then
 174 dnl     CXXFLAGS="-O"
 175     # Add "-O" to both the CXX and CXXCPP commands, to eliminate possible confu-
 176     # sion that results from __OPTIMIZE__ being defined for CXX but not CXXCPP.
 177 changequote(, )dnl
 178     if echo "$CXX " | grep ' -O[1-9 ]' > /dev/null; then
 179 changequote([, ])dnl
 180       : # already optimizing
 181     else
 182       CXX="$CXX -O"
 183       ac_cv_prog_CXX="$CXX"
 184     fi
 185   else
 186     CXXFLAGS=
 187   fi
 188 fi
 189 ])
 190
 191 dnl Determine a Fortran 77 compiler to use.  If `F77' is not already set
 192 dnl in the environment, check for `g77', `f77' and `f2c', in that order.
 193 dnl Set the output variable `F77' to the name of the compiler found.
 194 dnl
 195 dnl If using `g77' (the GNU Fortran 77 compiler), then `AC_PROG_F77'
 196 dnl will set the shell variable `G77' to `yes', and empty otherwise.  If
 197 dnl the output variable `FFLAGS' was not already set in the environment,
 198 dnl then set it to `-g -02' for `g77' (or `-O2' where `g77' does not
 199 dnl accept `-g').  Otherwise, set `FFLAGS' to `-g' for all other Fortran
 200 dnl 77 compilers.
 201 dnl
 202 dnl AC_PROG_F77()
 203 AC_DEFUN(AC_PROG_F77,
 204 [AC_BEFORE([$0], [AC_PROG_CPP])dnl
 205 if test -z "$F77"; then
 206   AC_CHECK_PROGS(F77, g77 f77 f2c)
 207     test -z "$F77" && AC_MSG_ERROR([no acceptable Fortran 77 compiler found in \$PATH])
 208 fi
 209
 210 AC_PROG_F77_WORKS
 211 AC_PROG_F77_GNU
 212
 213 if test $ac_cv_prog_g77 = yes; then
 214   G77=yes
 215 dnl Check whether -g works, even if FFLAGS is set, in case the package
 216 dnl plays around with FFLAGS (such as to build both debugging and
 217 dnl normal versions of a library), tasteless as that idea is.
 218   ac_test_FFLAGS="${FFLAGS+set}"
 219   ac_save_FFLAGS="$FFLAGS"
 220   FFLAGS=
 221   AC_PROG_F77_G
 222   if test "$ac_test_FFLAGS" = set; then
 223     FFLAGS="$ac_save_FFLAGS"
 224   elif test $ac_cv_prog_f77_g = yes; then
 225     FFLAGS="-g -O2"
 226   else
 227     FFLAGS="-O2"
 228   fi
 229 else
 230   G77=
 231   test "${FFLAGS+set}" = set || FFLAGS="-g"
 232 fi
 233 ])
 234
 235 AC_DEFUN(AC_PROG_CC_WORKS,
 236 [AC_MSG_CHECKING([whether the C compiler ($CC $CFLAGS $LDFLAGS) works])
 237 AC_LANG_SAVE
 238 AC_LANG_C
 239 AC_TRY_COMPILER([int main(){return(0);}], ac_cv_prog_cc_works, ac_cv_prog_cc_cross)
 240 AC_LANG_RESTORE
 241 AC_MSG_RESULT($ac_cv_prog_cc_works)
 242 if test $ac_cv_prog_cc_works = no; then
 243   AC_MSG_ERROR([installation or configuration problem: C compiler cannot create executables.])
 244 fi
 245 AC_MSG_CHECKING([whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler])
 246 AC_MSG_RESULT($ac_cv_prog_cc_cross)
 247 cross_compiling=$ac_cv_prog_cc_cross
 248 ])
 249
 250 AC_DEFUN(AC_PROG_CXX_WORKS,
 251 [AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works])
 252 AC_LANG_SAVE
 253 AC_LANG_CPLUSPLUS
 254 AC_TRY_COMPILER([int main(){return(0);}], ac_cv_prog_cxx_works, ac_cv_prog_cxx_cross)
 255 AC_LANG_RESTORE
 256 AC_MSG_RESULT($ac_cv_prog_cxx_works)
 257 if test $ac_cv_prog_cxx_works = no; then
 258   AC_MSG_ERROR([installation or configuration problem: C++ compiler cannot create executables.])
 259 fi
 260 AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler])
 261 AC_MSG_RESULT($ac_cv_prog_cxx_cross)
 262 cross_compiling=$ac_cv_prog_cxx_cross
 263 ])
 264
 265 dnl Test whether the Fortran 77 compiler can compile and link a trivial
 266 dnl Fortran program.  Also, test whether the Fortran 77 compiler is a
 267 dnl cross-compiler (which may realistically be the case if the Fortran
 268 dnl compiler is `g77').
 269 dnl
 270 dnl AC_PROG_F77_WORKS()
 271 AC_DEFUN(AC_PROG_F77_WORKS,
 272 [AC_MSG_CHECKING([whether the Fortran 77 compiler ($F77 $FFLAGS $LDFLAGS) works])
 273 AC_LANG_SAVE
 274 AC_LANG_FORTRAN77
 275 AC_TRY_COMPILER(dnl
 276 [      program conftest
 277       end
 278 ], ac_cv_prog_f77_works, ac_cv_prog_f77_cross)
 279 AC_LANG_RESTORE
 280 AC_MSG_RESULT($ac_cv_prog_f77_works)
 281 if test $ac_cv_prog_f77_works = no; then
 282   AC_MSG_ERROR([installation or configuration problem: Fortran 77 compiler cannot create executables.])
 283 fi
 284 AC_MSG_CHECKING([whether the Fortran 77 compiler ($F77 $FFLAGS $LDFLAGS) is a cross-compiler])
 285 AC_MSG_RESULT($ac_cv_prog_f77_cross)
 286 cross_compiling=$ac_cv_prog_f77_cross
 287 ])
 288
 289 AC_DEFUN(AC_PROG_CC_GNU,
 290 [AC_CACHE_CHECK(whether we are using GNU C, ac_cv_prog_gcc,
 291 [dnl The semicolon is to pacify NeXT's syntax-checking cpp.
 292 cat > conftest.c <<EOF
 293 #ifdef __GNUC__
 294   yes;
 295 #endif
 296 EOF
 297 if AC_TRY_COMMAND(${CC-cc} -E conftest.c) | egrep yes >/dev/null 2>&1; then
 298   ac_cv_prog_gcc=yes
 299 else
 300   ac_cv_prog_gcc=no
 301 fi])])
 302
 303 AC_DEFUN(AC_PROG_CXX_GNU,
 304 [AC_CACHE_CHECK(whether we are using GNU C++, ac_cv_prog_gxx,
 305 [dnl The semicolon is to pacify NeXT's syntax-checking cpp.
 306 cat > conftest.C <<EOF
 307 #ifdef __GNUC__
 308   yes;
 309 #endif
 310 EOF
 311 if AC_TRY_COMMAND(${CXX-g++} -E conftest.C) | egrep yes >/dev/null 2>&1; then
 312   ac_cv_prog_gxx=yes
 313 else
 314   ac_cv_prog_gxx=no
 315 fi])])
 316
 317 dnl Test whether for Fortran 77 compiler is `g77' (the GNU Fortran 77
 318 dnl Compiler).  This test depends on whether the Fortran 77 compiler can
 319 dnl do CPP pre-processing.
 320 dnl
 321 dnl AC_PROG_F77_GNU()
 322 AC_DEFUN(AC_PROG_F77_GNU,
 323 [AC_CACHE_CHECK(whether we are using GNU Fortran 77, ac_cv_prog_g77,
 324 [cat > conftest.fpp <<EOF
 325 #ifdef __GNUC__
 326   yes
 327 #endif
 328 EOF
 329 if AC_TRY_COMMAND($F77 -E conftest.fpp) | egrep yes >/dev/null 2>&1; then
 330   ac_cv_prog_g77=yes
 331 else
 332   ac_cv_prog_g77=no
 333 fi])])
 334
 335 AC_DEFUN(AC_PROG_CC_G,
 336 [AC_CACHE_CHECK(whether ${CC-cc} accepts -g, ac_cv_prog_cc_g,
 337 [echo 'void f(){}' > conftest.c
 338 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
 339   ac_cv_prog_cc_g=yes
 340 else
 341   ac_cv_prog_cc_g=no
 342 fi
 343 rm -f conftest*
 344 ])])
 345
 346 AC_DEFUN(AC_PROG_CXX_G,
 347 [AC_CACHE_CHECK(whether ${CXX-g++} accepts -g, ac_cv_prog_cxx_g,
 348 [echo 'void f(){}' > conftest.cc
 349 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
 350   ac_cv_prog_cxx_g=yes
 351 else
 352   ac_cv_prog_cxx_g=no
 353 fi
 354 rm -f conftest*
 355 ])])
 356
 357 dnl Test whether the Fortran 77 compiler can accept the `-g' option to
 358 dnl enable debugging.
 359 dnl
 360 dnl AC_PROG_F77_G()
 361 AC_DEFUN(AC_PROG_F77_G,
 362 [AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g,
 363 [cat > conftest.f << EOF
 364        program conftest
 365        end
 366 EOF
 367 if test -z "`$F77 -g -c conftest.f 2>&1`"; then
 368   ac_cv_prog_f77_g=yes
 369 else
 370   ac_cv_prog_f77_g=no
 371 fi
 372 rm -f conftest*
 373 ])])
 374
 375 AC_DEFUN(AC_PROG_GCC_TRADITIONAL,
 376 [AC_REQUIRE([AC_PROG_CC])dnl
 377 AC_REQUIRE([AC_PROG_CPP])dnl
 378 if test $ac_cv_prog_gcc = yes; then
 379   AC_CACHE_CHECK(whether -traditional is needed for ${CC-cc} on this system,
 380       ac_cv_prog_gcc_traditional,
 381 [  ac_pattern="Autoconf.*'x'"
 382   AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
 383 Autoconf TIOCGETP],
 384   ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
 385
 386   if test $ac_cv_prog_gcc_traditional = no; then
 387     AC_EGREP_CPP($ac_pattern, [#include <termio.h>
 388 Autoconf TCGETA],
 389     ac_cv_prog_gcc_traditional=yes)
 390   fi
 391   if test $ac_cv_prog_gcc_traditional = no; then
 392     # On some USL SVR4 systems, gcc's fixinc.svr4 modifies <signal.h> and
 393     # <sys/signal.h> in such a way that "#include <signal.h>" results in a
 394     # syntax error because of `sigset_t' if gcc is called with __STDC__=1
 395     # but __STRICT_ANSI__ undefined. Remedy: use -traditional.
 396     ac_prog='
 397 #include <sys/types.h>
 398 #include <signal.h>
 399 #ifdef __cplusplus
 400 extern "C" void exit(int);
 401 #endif
 402 int main() { exit(0); }'
 403     echo "$ac_prog" > conftest.c
 404     if eval $ac_link; then
 405       :
 406     else
 407       ac_prog='
 408 #undef __STDC__
 409 #include <sys/types.h>
 410 #include <signal.h>
 411 #ifdef __cplusplus
 412 extern "C" void exit(int);
 413 #endif
 414 int main() { exit(0); }'
 415       echo "$ac_prog" > conftest.c
 416       if eval $ac_link; then
 417         ac_cv_prog_gcc_traditional=yes
 418       fi
 419     fi
 420     rm -f conftest*
 421   fi])
 422   if test $ac_cv_prog_gcc_traditional = yes; then
 423     CC="$CC -traditional"
 424   fi
 425 fi
 426 ])
 427
 428 AC_DEFUN(AC_PROG_CC_C_O,
 429 [if test "x$CC" != xcc; then
 430   AC_MSG_CHECKING(whether $CC and cc understand -c and -o together)
 431 else
 432   AC_MSG_CHECKING(whether cc understands -c and -o together)
 433 fi
 434 set dummy $CC; ac_cc="`echo [$]2 |
 435 changequote(, )dnl
 436                        sed -e 's/[^a-zA-Z0-9_]/_/g' -e 's/^[0-9]/_/'`"
 437 changequote([, ])dnl
 438 AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
 439 [echo 'foo(){}' > conftest.c
 440 # Make sure it works both with $CC and with simple cc.
 441 # We do the test twice because some compilers refuse to overwrite an
 442 # existing .o file with -o, though they will create one.
 443 ac_try='${CC-cc} -c conftest.c -o conftest.o 1>&AC_FD_CC'
 444 if AC_TRY_EVAL(ac_try) &&
 445    test -f conftest.o && AC_TRY_EVAL(ac_try);
 446 then
 447   eval ac_cv_prog_cc_${ac_cc}_c_o=yes
 448   if test "x$CC" != xcc; then
 449     # Test first that cc exists at all.
 450     if AC_TRY_COMMAND(cc -c conftest.c 1>&AC_FD_CC); then
 451       ac_try='cc -c conftest.c -o conftest.o 1>&AC_FD_CC'
 452       if AC_TRY_EVAL(ac_try) &&
 453          test -f conftest.o && AC_TRY_EVAL(ac_try);
 454       then
 455         # cc works too.
 456         :
 457       else
 458         # cc exists but doesn't like -o.
 459         eval ac_cv_prog_cc_${ac_cc}_c_o=no
 460       fi
 461     fi
 462   fi
 463 else
 464   eval ac_cv_prog_cc_${ac_cc}_c_o=no
 465 fi
 466 rm -f conftest*
 467 ])dnl
 468 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = yes"; then
 469   AC_MSG_RESULT(yes)
 470 else
 471   AC_MSG_RESULT(no)
 472   AC_DEFINE(NO_MINUS_C_MINUS_O)
 473 fi
 474 ])
 475
 476 dnl Test if the Fortran 77 compiler accepts the options `-c' and `-o'
 477 dnl simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not.
 478 dnl
 479 dnl The usefulness of this macro is questionable, as I can't really see
 480 dnl why anyone would use it.  The only reason I include it is for
 481 dnl completeness, since a similar test exists for the C compiler.
 482 dnl
 483 dnl AC_PROG_F77_C_O
 484 AC_DEFUN(AC_PROG_F77_C_O,
 485 [AC_BEFORE([$0], [AC_PROG_F77])dnl
 486 AC_MSG_CHECKING(whether $F77 understand -c and -o together)
 487 set dummy $F77; ac_f77="`echo [$]2 |
 488 changequote(, )dnl
 489 sed -e 's/[^a-zA-Z0-9_]/_/g' -e 's/^[0-9]/_/'`"
 490 changequote([, ])dnl
 491 AC_CACHE_VAL(ac_cv_prog_f77_${ac_f77}_c_o,
 492 [cat > conftest.f << EOF
 493        program conftest
 494        end
 495 EOF
 496 # We do the `AC_TRY_EVAL' test twice because some compilers refuse to
 497 # overwrite an existing `.o' file with `-o', although they will create
 498 # one.
 499 ac_try='$F77 $FFLAGS -c conftest.f -o conftest.o 1>&AC_FD_CC'
 500 if AC_TRY_EVAL(ac_try) && test -f conftest.o && AC_TRY_EVAL(ac_try); then
 501   eval ac_cv_prog_f77_${ac_f77}_c_o=yes
 502 else
 503   eval ac_cv_prog_f77_${ac_f77}_c_o=no
 504 fi
 505 rm -f conftest*
 506 ])dnl
 507 if eval "test \"`echo '$ac_cv_prog_f77_'${ac_f77}_c_o`\" = yes"; then
 508   AC_MSG_RESULT(yes)
 509 else
 510   AC_MSG_RESULT(no)
 511   AC_DEFINE(F77_NO_MINUS_C_MINUS_O)
 512 fi
 513 ])
 514
 515 dnl Define SET_MAKE to set ${MAKE} if make doesn't.
 516 AC_DEFUN(AC_PROG_MAKE_SET,
 517 [AC_MSG_CHECKING([whether ${MAKE-make} sets \$(MAKE)])
 518 set dummy ${MAKE-make}; ac_make=`echo "[$]2" | sed 'y%./+-%__p_%'`
 519 AC_CACHE_VAL(ac_cv_prog_make_${ac_make}_set,
 520 [cat > conftestmake <<\EOF
 521 all:
 522         @echo 'ac_maketemp="${MAKE}"'
 523 EOF
 524 changequote(, )dnl
 525 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 526 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 527 changequote([, ])dnl
 528 if test -n "$ac_maketemp"; then
 529   eval ac_cv_prog_make_${ac_make}_set=yes
 530 else
 531   eval ac_cv_prog_make_${ac_make}_set=no
 532 fi
 533 rm -f conftestmake])dnl
 534 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 535   AC_MSG_RESULT(yes)
 536   SET_MAKE=
 537 else
 538   AC_MSG_RESULT(no)
 539   SET_MAKE="MAKE=${MAKE-make}"
 540 fi
 541 AC_SUBST([SET_MAKE])dnl
 542 ])
 543
 544 AC_DEFUN(AC_PROG_RANLIB,
 545 [AC_CHECK_PROG(RANLIB, ranlib, ranlib, :)])
 546
 547 dnl Check for mawk first since it's generally faster.
 548 AC_DEFUN(AC_PROG_AWK,
 549 [AC_CHECK_PROGS(AWK, mawk gawk nawk awk, )])
 550
 551 AC_DEFUN(AC_PROG_YACC,
 552 [AC_CHECK_PROGS(YACC, 'bison -y' byacc, yacc)])
 553
 554 AC_DEFUN(AC_PROG_CPP,
 555 [AC_MSG_CHECKING(how to run the C preprocessor)
 556 # On Suns, sometimes $CPP names a directory.
 557 if test -n "$CPP" && test -d "$CPP"; then
 558   CPP=
 559 fi
 560 if test -z "$CPP"; then
 561 AC_CACHE_VAL(ac_cv_prog_CPP,
 562 [  # This must be in double quotes, not single quotes, because CPP may get
 563   # substituted into the Makefile and "${CC-cc}" will confuse make.
 564   CPP="${CC-cc} -E"
 565   if test -n "$GCC"; then
 566 dnl This is already part of AC_PROG_CC.
 567 dnl # Use the same optimization flags than for CC, because some things may
 568 dnl # depend upon __OPTIMIZE__.
 569 dnl CPP="$CPP -O"
 570     # Suppress warning messages.
 571 dnl # When using gcc -traditional on machines that have <sys/cdefs.h>,
 572 dnl # the "-Dconst=" from AC_C_CONST and the "#define const __const" from
 573 dnl # <sys/cdefs.h> generate a warning. Unless suppressed, this warning
 574 dnl # causes later tests using AC_TRY_CPP to fail.
 575     CPP="$CPP -w"
 576   fi
 577   # On the NeXT, cc -E runs the code through the compiler's parser,
 578   # not just through cpp. On NeXTstep 3.1 the same holds for /lib/cpp; use
 579   # "cc -E -traditional-cpp" instead.
 580 dnl Use a header file that comes with gcc, so configuring glibc
 581 dnl with a fresh cross-compiler works.
 582   AC_TRY_CPP([#include <assert.h>
 583 Syntax Error], ac_have_cpp=1)
 584   if test -z "$ac_have_cpp"; then
 585     CPP="${CC-cc} -E -traditional-cpp"
 586     AC_TRY_CPP([#include <assert.h>
 587 Syntax Error], ac_have_cpp=1)
 588     if test -n "$ac_have_cpp"; then
 589       CC="${CC-cc} -traditional-cpp"
 590     else
 591       CPP="${CC-cc} -nologo -E"
 592       AC_TRY_CPP([#include <assert.h>
 593 Syntax Error], ac_have_cpp=1)
 594       if test -n "$ac_have_cpp"; then
 595         CC="${CC-cc} -nologo"
 596       else
 597         CPP=/lib/cpp
 598       fi
 599     fi
 600   fi
 601   ac_cv_prog_CC="$CC"
 602   ac_cv_prog_CPP="$CPP"])dnl
 603   CPP="$ac_cv_prog_CPP"
 604 else
 605   ac_cv_prog_CPP="$CPP"
 606 fi
 607 AC_MSG_RESULT($CPP)
 608 AC_SUBST(CPP)dnl
 609 ])
 610
 611 AC_DEFUN(AC_PROG_CXXCPP,
 612 [AC_MSG_CHECKING(how to run the C++ preprocessor)
 613 if test -z "$CXXCPP"; then
 614 AC_CACHE_VAL(ac_cv_prog_CXXCPP,
 615 [AC_LANG_SAVE[]dnl
 616 AC_LANG_CPLUSPLUS[]dnl
 617   CXXCPP="${CXX-g++} -E"
 618   AC_TRY_CPP([#include <stdlib.h>], , CXXCPP=/lib/cpp)
 619   ac_cv_prog_CXXCPP="$CXXCPP"
 620 AC_LANG_RESTORE[]dnl
 621 fi])dnl
 622 CXXCPP="$ac_cv_prog_CXXCPP"
 623 AC_MSG_RESULT($CXXCPP)
 624 AC_SUBST(CXXCPP)dnl
 625 ])
 626
 627 dnl Require finding the C or C++ preprocessor, whichever is the
 628 dnl current language.
 629 AC_DEFUN(AC_REQUIRE_CPP,
 630 [ifelse(AC_LANG, C, [AC_REQUIRE([AC_PROG_CPP])], [AC_REQUIRE([AC_PROG_CXXCPP])])])
 631
 632 AC_DEFUN(AC_PROG_LEX,
 633 [AC_CHECK_PROG(LEX, flex, flex, lex)
 634 if test -z "$LEXLIB"
 635 then
 636   case "$LEX" in
 637   flex*) ac_lib=fl ;;
 638   *) ac_lib=l ;;
 639   esac
 640   AC_CHECK_LIB($ac_lib, yywrap, LEXLIB="-l$ac_lib")
 641 fi
 642 AC_SUBST(LEXLIB)])
 643
 644 dnl Check if lex declares yytext as a char * by default, not a char[].
 645 undefine([AC_DECL_YYTEXT])
 646 AC_DEFUN(AC_DECL_YYTEXT,
 647 [AC_REQUIRE_CPP()dnl
 648 AC_REQUIRE([AC_PROG_LEX])dnl
 649 AC_CACHE_CHECK(lex output file root, ac_cv_prog_lex_root,
 650 [# The minimal lex program is just a single line: %%.  But some broken lexes
 651 # (Solaris, I think it was) want two %% lines, so accommodate them.
 652 echo '%%
 653 %%' | $LEX
 654 if test -f lex.yy.c; then
 655   ac_cv_prog_lex_root=lex.yy
 656 elif test -f lexyy.c; then
 657   ac_cv_prog_lex_root=lexyy
 658 else
 659   AC_MSG_ERROR(cannot find output from $LEX; giving up)
 660 fi])
 661 LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
 662 AC_SUBST(LEX_OUTPUT_ROOT)dnl
 663
 664 AC_CACHE_CHECK(whether yytext is a pointer, ac_cv_prog_lex_yytext_pointer,
 665 [# POSIX says lex can declare yytext either as a pointer or an array; the
 666 # default is implementation-dependent. Figure out which it is, since
 667 # not all implementations provide the %pointer and %array declarations.
 668 ac_cv_prog_lex_yytext_pointer=no
 669 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
 670 ac_save_LIBS="$LIBS"
 671 LIBS="$LIBS $LEXLIB"
 672 AC_TRY_LINK(`cat $LEX_OUTPUT_ROOT.c`, , ac_cv_prog_lex_yytext_pointer=yes)
 673 LIBS="$ac_save_LIBS"
 674 rm -f "${LEX_OUTPUT_ROOT}.c"
 675 ])
 676 if test $ac_cv_prog_lex_yytext_pointer = yes; then
 677   AC_DEFINE(YYTEXT_POINTER)
 678 fi
 679 ])
 680
 681 AC_DEFUN(AC_PROG_INSTALL,
 682 [AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
 683 # Find a good install program.  We prefer a C program (faster),
 684 # so one script is as good as another.  But avoid the broken or
 685 # incompatible versions:
 686 # SysV /etc/install, /usr/sbin/install
 687 # SunOS /usr/etc/install
 688 # IRIX /sbin/install
 689 # AIX /bin/install
 690 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 691 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 692 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 693 # ./install, which can be erroneously created by make from ./install.sh.
 694 AC_MSG_CHECKING(for a BSD compatible install)
 695 if test -z "$INSTALL"; then
 696 AC_CACHE_VAL(ac_cv_path_install,
 697 [  IFS="${IFS=  }"; ac_save_IFS="$IFS"; IFS=":"
 698   for ac_dir in $PATH; do
 699     # Account for people who put trailing slashes in PATH elements.
 700     case "$ac_dir/" in
 701     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 702     *)
 703       # OSF1 and SCO ODT 3.0 have their own names for install.
 704       # Don't use installbsd from OSF since it installs stuff as root
 705       # by default.
 706       for ac_prog in ginstall scoinst install; do
 707         if test -f $ac_dir/$ac_prog; then
 708           if test $ac_prog = install &&
 709             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 710             # AIX install.  It has an incompatible calling convention.
 711             :
 712           else
 713             if test $ac_prog = installbsd &&
 714               grep src/bos $ac_dir/$ac_prog >/dev/null 2>&1; then
 715               # AIX installbsd doesn't work without option "-g".
 716               :
 717             else
 718               ac_cv_path_install="$ac_dir/$ac_prog -c"
 719               break 2
 720             fi
 721           fi
 722         fi
 723       done
 724       ;;
 725     esac
 726   done
 727   IFS="$ac_save_IFS"
 728 ])dnl
 729   if test "${ac_cv_path_install+set}" = set; then
 730     INSTALL="$ac_cv_path_install"
 731   else
 732     # As a last resort, use the slow shell script.  We don't cache a
 733     # path for INSTALL within a source directory, because that will
 734     # break other packages using the cache if that directory is
 735     # removed, or if the path is relative.
 736     INSTALL="$ac_install_sh"
 737   fi
 738 fi
 739 dnl We do special magic for INSTALL instead of AC_SUBST, to get
 740 dnl relative paths right.
 741 AC_MSG_RESULT($INSTALL)
 742
 743 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 744 # It thinks the first close brace ends the variable substitution.
 745 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 746 AC_SUBST(INSTALL_PROGRAM)dnl
 747
 748 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 749 AC_SUBST(INSTALL_SCRIPT)dnl
 750
 751 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 752 AC_SUBST(INSTALL_DATA)dnl
 753 ])
 754
 755 AC_DEFUN(AC_PROG_LN_S,
 756 [AC_MSG_CHECKING(whether ln -s works)
 757 AC_CACHE_VAL(ac_cv_prog_LN_S,
 758 [rm -f conftestdata
 759 if ln -s X conftestdata 2>/dev/null
 760 then
 761   rm -f conftestdata
 762   ac_cv_prog_LN_S="ln -s"
 763 else
 764   ac_cv_prog_LN_S=ln
 765 fi])dnl
 766 LN_S="$ac_cv_prog_LN_S"
 767 if test "$ac_cv_prog_LN_S" = "ln -s"; then
 768   AC_MSG_RESULT(yes)
 769 else
 770   AC_MSG_RESULT(no)
 771 fi
 772 AC_SUBST(LN_S)dnl
 773 ])
 774
 775 define(AC_RSH,
 776 [errprint(__file__:__line__: [$0] has been removed; replace it with equivalent code
 777 )m4exit(4)])
 778
 779
 780 dnl ### Checks for header files
 781
 782
 783 AC_DEFUN(AC_HEADER_STDC,
 784 [AC_REQUIRE_CPP()dnl
 785 AC_CACHE_CHECK(for ANSI C header files, ac_cv_header_stdc,
 786 [AC_TRY_CPP([#include <stdlib.h>
 787 #include <stdarg.h>
 788 #include <string.h>
 789 #include <float.h>], ac_cv_header_stdc=yes, ac_cv_header_stdc=no)
 790
 791 if test $ac_cv_header_stdc = yes; then
 792   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 793 AC_EGREP_HEADER(memchr, string.h, , ac_cv_header_stdc=no)
 794 fi
 795
 796 if test $ac_cv_header_stdc = yes; then
 797   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 798 AC_EGREP_HEADER(free, stdlib.h, , ac_cv_header_stdc=no)
 799 fi
 800
 801 if test $ac_cv_header_stdc = yes; then
 802   # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
 803 AC_TRY_RUN([#include <ctype.h>
 804 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
 805 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
 806 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
 807 int main () { int i; for (i = 0; i < 256; i++)
 808 if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
 809 exit (0); }
 810 ], , ac_cv_header_stdc=no, :)
 811 fi])
 812 if test $ac_cv_header_stdc = yes; then
 813   AC_DEFINE(STDC_HEADERS)
 814 fi
 815 ])
 816
 817 AC_DEFUN(AC_UNISTD_H,
 818 [AC_OBSOLETE([$0], [; instead use AC_CHECK_HEADERS(unistd.h)])dnl
 819 AC_CHECK_HEADER(unistd.h, AC_DEFINE(HAVE_UNISTD_H))])
 820
 821 AC_DEFUN(AC_USG,
 822 [AC_OBSOLETE([$0],
 823   [; instead use AC_CHECK_HEADERS(string.h) and HAVE_STRING_H])dnl
 824 AC_MSG_CHECKING([for BSD string and memory functions])
 825 AC_TRY_LINK([#include <strings.h>], [rindex(0, 0); bzero(0, 0);],
 826   [AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no); AC_DEFINE(USG)])])
 827
 828
 829 dnl If memchr and the like aren't declared in <string.h>, include <memory.h>.
 830 dnl To avoid problems, don't check for gcc2 built-ins.
 831 AC_DEFUN(AC_MEMORY_H,
 832 [AC_OBSOLETE([$0], [; instead use AC_CHECK_HEADERS(memory.h) and HAVE_MEMORY_H])dnl
 833 AC_MSG_CHECKING(whether string.h declares mem functions)
 834 AC_EGREP_HEADER(memchr, string.h, ac_found=yes, ac_found=no)
 835 AC_MSG_RESULT($ac_found)
 836 if test $ac_found = no; then
 837   AC_CHECK_HEADER(memory.h, [AC_DEFINE(NEED_MEMORY_H)])
 838 fi
 839 ])
 840
 841 AC_DEFUN(AC_HEADER_MAJOR,
 842 [AC_CACHE_CHECK(whether sys/types.h defines makedev,
 843   ac_cv_header_sys_types_h_makedev,
 844 [AC_TRY_LINK([#include <sys/types.h>], [return makedev(0, 0);],
 845   ac_cv_header_sys_types_h_makedev=yes, ac_cv_header_sys_types_h_makedev=no)
 846 ])
 847
 848 if test $ac_cv_header_sys_types_h_makedev = no; then
 849 AC_CHECK_HEADER(sys/mkdev.h, [AC_DEFINE(MAJOR_IN_MKDEV)])
 850
 851   if test $ac_cv_header_sys_mkdev_h = no; then
 852 AC_CHECK_HEADER(sys/sysmacros.h, [AC_DEFINE(MAJOR_IN_SYSMACROS)])
 853   fi
 854 fi
 855 ])
 856
 857 AC_DEFUN(AC_HEADER_DIRENT,
 858 [ac_header_dirent=no
 859 AC_CHECK_HEADERS_DIRENT(dirent.h sys/ndir.h sys/dir.h ndir.h,
 860   [ac_header_dirent=$ac_hdr; break])
 861 # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.
 862 if test $ac_header_dirent = dirent.h; then
 863 AC_CHECK_LIB(dir, opendir, LIBS="$LIBS -ldir")
 864 else
 865 AC_CHECK_LIB(x, opendir, LIBS="$LIBS -lx")
 866 fi
 867 ])
 868
 869 dnl Like AC_CHECK_HEADER, except also make sure that HEADER-FILE
 870 dnl defines the type `DIR'.  dirent.h on NextStep 3.2 doesn't.
 871 dnl AC_CHECK_HEADER_DIRENT(HEADER-FILE, ACTION-IF-FOUND)
 872 AC_DEFUN(AC_CHECK_HEADER_DIRENT,
 873 [ac_safe=`echo "$1" | sed 'y%./+-%__p_%'`
 874 AC_MSG_CHECKING([for $1 that defines DIR])
 875 AC_CACHE_VAL(ac_cv_header_dirent_$ac_safe,
 876 [AC_TRY_COMPILE([#include <sys/types.h>
 877 #include <$1>], [DIR *dirp = 0;],
 878   eval "ac_cv_header_dirent_$ac_safe=yes",
 879   eval "ac_cv_header_dirent_$ac_safe=no")])dnl
 880 if eval "test \"`echo '$ac_cv_header_dirent_'$ac_safe`\" = yes"; then
 881   AC_MSG_RESULT(yes)
 882   $2
 883 else
 884   AC_MSG_RESULT(no)
 885 fi
 886 ])
 887
 888 dnl Like AC_CHECK_HEADERS, except succeed only for a HEADER-FILE that
 889 dnl defines `DIR'.
 890 dnl AC_CHECK_HEADERS_DIRENT(HEADER-FILE... [, ACTION])
 891 define(AC_CHECK_HEADERS_DIRENT,
 892 [for ac_hdr in $1
 893 do
 894 AC_CHECK_HEADER_DIRENT($ac_hdr,
 895 [changequote(, )dnl
 896   ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
 897 changequote([, ])dnl
 898   AC_DEFINE_UNQUOTED($ac_tr_hdr) $2])dnl
 899 done])
 900
 901 AC_DEFUN(AC_DIR_HEADER,
 902 [AC_OBSOLETE([$0], [; instead use AC_HEADER_DIRENT])dnl
 903 ac_header_dirent=no
 904 for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do
 905   AC_CHECK_HEADER_DIRENT($ac_hdr, [ac_header_dirent=$ac_hdr; break])
 906 done
 907
 908 case "$ac_header_dirent" in
 909 dirent.h) AC_DEFINE(DIRENT) ;;
 910 sys/ndir.h) AC_DEFINE(SYSNDIR) ;;
 911 sys/dir.h) AC_DEFINE(SYSDIR) ;;
 912 ndir.h) AC_DEFINE(NDIR) ;;
 913 esac
 914
 915 AC_CACHE_CHECK(whether closedir returns void, ac_cv_func_closedir_void,
 916 [AC_TRY_RUN([#include <sys/types.h>
 917 #include <$ac_header_dirent>
 918 int closedir(); int main() { exit(closedir(opendir(".")) != 0); }],
 919   ac_cv_func_closedir_void=no, ac_cv_func_closedir_void=yes, ac_cv_func_closedir_void=yes)])
 920 if test $ac_cv_func_closedir_void = yes; then
 921   AC_DEFINE(VOID_CLOSEDIR)
 922 fi
 923 ])
 924
 925 AC_DEFUN(AC_HEADER_STAT,
 926 [AC_CACHE_CHECK(whether stat file-mode macros are broken,
 927   ac_cv_header_stat_broken,
 928 [AC_EGREP_CPP([You lose], [#include <sys/types.h>
 929 #include <sys/stat.h>
 930
 931 #if defined(S_ISBLK) && defined(S_IFDIR)
 932 # if S_ISBLK (S_IFDIR)
 933 You lose.
 934 # endif
 935 #endif
 936
 937 #if defined(S_ISBLK) && defined(S_IFCHR)
 938 # if S_ISBLK (S_IFCHR)
 939 You lose.
 940 # endif
 941 #endif
 942
 943 #if defined(S_ISLNK) && defined(S_IFREG)
 944 # if S_ISLNK (S_IFREG)
 945 You lose.
 946 # endif
 947 #endif
 948
 949 #if defined(S_ISSOCK) && defined(S_IFREG)
 950 # if S_ISSOCK (S_IFREG)
 951 You lose.
 952 # endif
 953 #endif
 954 ], ac_cv_header_stat_broken=yes, ac_cv_header_stat_broken=no)])
 955 if test $ac_cv_header_stat_broken = yes; then
 956   AC_DEFINE(STAT_MACROS_BROKEN)
 957 fi
 958 ])
 959
 960 AC_DEFUN(AC_DECL_SYS_SIGLIST,
 961 [AC_CACHE_CHECK([for sys_siglist declaration in signal.h or unistd.h],
 962   ac_cv_decl_sys_siglist,
 963 [AC_TRY_COMPILE([#include <sys/types.h>
 964 #include <signal.h>
 965 /* NetBSD declares sys_siglist in unistd.h.  */
 966 #ifdef HAVE_UNISTD_H
 967 #include <unistd.h>
 968 #endif], [char *msg = *(sys_siglist + 1);],
 969   ac_cv_decl_sys_siglist=yes, ac_cv_decl_sys_siglist=no)])
 970 if test $ac_cv_decl_sys_siglist = yes; then
 971   AC_DEFINE(SYS_SIGLIST_DECLARED)
 972 fi
 973 ])
 974
 975 AC_DEFUN(AC_HEADER_SYS_WAIT,
 976 [AC_CACHE_CHECK([for sys/wait.h that is POSIX.1 compatible],
 977   ac_cv_header_sys_wait_h,
 978 [AC_TRY_COMPILE([#include <sys/types.h>
 979 #include <sys/wait.h>
 980 #ifndef WEXITSTATUS
 981 #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
 982 #endif
 983 #ifndef WIFEXITED
 984 #define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
 985 #endif], [int s;
 986 wait (&s);
 987 s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;],
 988 ac_cv_header_sys_wait_h=yes, ac_cv_header_sys_wait_h=no)])
 989 if test $ac_cv_header_sys_wait_h = yes; then
 990   AC_DEFINE(HAVE_SYS_WAIT_H)
 991 fi
 992 ])
 993
 994
 995 dnl ### Checks for typedefs
 996
 997
 998 AC_DEFUN(AC_TYPE_GETGROUPS,
 999 [AC_REQUIRE([AC_TYPE_UID_T])dnl
1000 AC_CACHE_CHECK(type of array argument to getgroups, ac_cv_type_getgroups,
1001 [AC_TRY_RUN(
1002 changequote(<<, >>)dnl
1003 <<
1004 /* Thanks to Mike Rendell for this test.  */
1005 #include <sys/types.h>
1006 #define NGID 256
1007 #undef MAX
1008 #define MAX(x, y) ((x) > (y) ? (x) : (y))
1009 int main()
1010 {
1011   gid_t gidset[NGID];
1012   int i, n;
1013   union { gid_t gval; long lval; }  val;
1014
1015   val.lval = -1;
1016   for (i = 0; i < NGID; i++)
1017     gidset[i] = val.gval;
1018   n = getgroups (sizeof (gidset) / MAX (sizeof (int), sizeof (gid_t)) - 1,
1019                  gidset);
1020   /* Exit non-zero if getgroups seems to require an array of ints.  This
1021      happens when gid_t is short but getgroups modifies an array of ints.  */
1022   exit ((n > 0 && gidset[n] != val.gval) ? 1 : 0);
1023 }
1024 >>,
1025 changequote([, ])dnl
1026   ac_cv_type_getgroups=gid_t, ac_cv_type_getgroups=int,
1027   ac_cv_type_getgroups=cross)
1028 if test $ac_cv_type_getgroups = cross; then
1029   dnl When we can't run the test program (we are cross compiling), presume
1030   dnl that <unistd.h> has either an accurate prototype for getgroups or none.
1031   dnl Old systems without prototypes probably use int.
1032   AC_EGREP_HEADER([getgroups.*int.*gid_t], unistd.h,
1033                   ac_cv_type_getgroups=gid_t, ac_cv_type_getgroups=int)
1034 fi])
1035 AC_DEFINE_UNQUOTED(GETGROUPS_T, $ac_cv_type_getgroups)
1036 ])
1037
1038 AC_DEFUN(AC_TYPE_UID_T,
1039 [AC_CACHE_CHECK(for uid_t in sys/types.h, ac_cv_type_uid_t,
1040 [AC_EGREP_HEADER(uid_t, sys/types.h,
1041   ac_cv_type_uid_t=yes, ac_cv_type_uid_t=no)])
1042 if test $ac_cv_type_uid_t = no; then
1043   AC_DEFINE(uid_t, int)
1044   AC_DEFINE(gid_t, int)
1045 fi
1046 ])
1047
1048 AC_DEFUN(AC_TYPE_SIZE_T,
1049 [AC_CHECK_TYPE(size_t, unsigned)])
1050
1051 AC_DEFUN(AC_TYPE_PID_T,
1052 [AC_CHECK_TYPE(pid_t, int)])
1053
1054 AC_DEFUN(AC_TYPE_OFF_T,
1055 [AC_CHECK_TYPE(off_t, long)])
1056
1057 AC_DEFUN(AC_TYPE_MODE_T,
1058 [AC_CHECK_TYPE(mode_t, int)])
1059
1060 dnl Note that identifiers starting with SIG are reserved by ANSI C.
1061 AC_DEFUN(AC_TYPE_SIGNAL,
1062 [AC_CACHE_CHECK([return type of signal handlers], ac_cv_type_signal,
1063 [AC_TRY_COMPILE([#include <sys/types.h>
1064 #include <signal.h>
1065 #ifdef signal
1066 #undef signal
1067 #endif
1068 extern
1069 #ifdef __cplusplus
1070 "C" void (*signal (int, void (*)(int)))(int);
1071 #else
1072 void (*signal ()) ();
1073 #endif
1074 ],
1075 [int i;], ac_cv_type_signal=void, ac_cv_type_signal=int)])
1076 AC_DEFINE_UNQUOTED(RETSIGTYPE, $ac_cv_type_signal)
1077 ])
1078
1079
1080 dnl ### Checks for functions
1081
1082
1083 AC_DEFUN(AC_FUNC_CLOSEDIR_VOID,
1084 [AC_REQUIRE([AC_HEADER_DIRENT])dnl
1085 AC_CACHE_CHECK(whether closedir returns void, ac_cv_func_closedir_void,
1086 [AC_TRY_RUN([#include <sys/types.h>
1087 #include <$ac_header_dirent>
1088 int closedir(); int main() { exit(closedir(opendir(".")) != 0); }],
1089   ac_cv_func_closedir_void=no, ac_cv_func_closedir_void=yes, ac_cv_func_closedir_void=yes)])
1090 if test $ac_cv_func_closedir_void = yes; then
1091   AC_DEFINE(CLOSEDIR_VOID)
1092 fi
1093 ])
1094
1095 AC_DEFUN(AC_FUNC_FNMATCH,
1096 [AC_CACHE_CHECK(for working fnmatch, ac_cv_func_fnmatch_works,
1097 # Some versions of Solaris or SCO have a broken fnmatch function.
1098 # So we run a test program.  If we are cross-compiling, take no chance.
1099 # Thanks to John Oleynick and Franc,ois Pinard for this test.
1100 [AC_TRY_RUN([int main() { exit (fnmatch ("a*", "abc", 0) != 0); }],
1101 ac_cv_func_fnmatch_works=yes, ac_cv_func_fnmatch_works=no,
1102 ac_cv_func_fnmatch_works=no)])
1103 if test $ac_cv_func_fnmatch_works = yes; then
1104   AC_DEFINE(HAVE_FNMATCH)
1105 fi
1106 ])
1107
1108 AC_DEFUN(AC_FUNC_MMAP,
1109 [AC_CHECK_HEADERS(unistd.h)
1110 AC_CHECK_FUNCS(getpagesize)
1111 AC_CACHE_CHECK(for working mmap, ac_cv_func_mmap_fixed_mapped,
1112 [AC_TRY_RUN([
1113 /* Thanks to Mike Haertel and Jim Avera for this test.
1114    Here is a matrix of mmap possibilities:
1115         mmap private not fixed
1116         mmap private fixed at somewhere currently unmapped
1117         mmap private fixed at somewhere already mapped
1118         mmap shared not fixed
1119         mmap shared fixed at somewhere currently unmapped
1120         mmap shared fixed at somewhere already mapped
1121    For private mappings, we should verify that changes cannot be read()
1122    back from the file, nor mmap's back from the file at a different
1123    address.  (There have been systems where private was not correctly
1124    implemented like the infamous i386 svr4.0, and systems where the
1125    VM page cache was not coherent with the filesystem buffer cache
1126    like early versions of FreeBSD and possibly contemporary NetBSD.)
1127    For shared mappings, we should conversely verify that changes get
1128    propogated back to all the places they're supposed to be.
1129
1130    Grep wants private fixed already mapped.
1131    The main things grep needs to know about mmap are:
1132    * does it exist and is it safe to write into the mmap'd area
1133    * how to use it (BSD variants)  */
1134 #include <sys/types.h>
1135 #include <fcntl.h>
1136 #include <sys/mman.h>
1137
1138 /* This mess was copied from the GNU getpagesize.h.  */
1139 #ifndef HAVE_GETPAGESIZE
1140 # ifdef HAVE_UNISTD_H
1141 #  include <unistd.h>
1142 # endif
1143
1144 /* Assume that all systems that can run configure have sys/param.h.  */
1145 # ifndef HAVE_SYS_PARAM_H
1146 #  define HAVE_SYS_PARAM_H 1
1147 # endif
1148
1149 # ifdef _SC_PAGESIZE
1150 #  define getpagesize() sysconf(_SC_PAGESIZE)
1151 # else /* no _SC_PAGESIZE */
1152 #  ifdef HAVE_SYS_PARAM_H
1153 #   include <sys/param.h>
1154 #   ifdef EXEC_PAGESIZE
1155 #    define getpagesize() EXEC_PAGESIZE
1156 #   else /* no EXEC_PAGESIZE */
1157 #    ifdef NBPG
1158 #     define getpagesize() NBPG * CLSIZE
1159 #     ifndef CLSIZE
1160 #      define CLSIZE 1
1161 #     endif /* no CLSIZE */
1162 #    else /* no NBPG */
1163 #     ifdef NBPC
1164 #      define getpagesize() NBPC
1165 #     else /* no NBPC */
1166 #      ifdef PAGESIZE
1167 #       define getpagesize() PAGESIZE
1168 #      endif /* PAGESIZE */
1169 #     endif /* no NBPC */
1170 #    endif /* no NBPG */
1171 #   endif /* no EXEC_PAGESIZE */
1172 #  else /* no HAVE_SYS_PARAM_H */
1173 #   define getpagesize() 8192   /* punt totally */
1174 #  endif /* no HAVE_SYS_PARAM_H */
1175 # endif /* no _SC_PAGESIZE */
1176
1177 #endif /* no HAVE_GETPAGESIZE */
1178
1179 #ifdef __cplusplus
1180 extern "C" { void *malloc(unsigned); }
1181 #else
1182 char *malloc();
1183 #endif
1184
1185 int
1186 main()
1187 {
1188         char *data, *data2, *data3;
1189         int i, pagesize;
1190         int fd;
1191
1192         pagesize = getpagesize();
1193
1194         /*
1195          * First, make a file with some known garbage in it.
1196          */
1197         data = malloc(pagesize);
1198         if (!data)
1199                 exit(1);
1200         for (i = 0; i < pagesize; ++i)
1201                 *(data + i) = rand();
1202         umask(0);
1203         fd = creat("conftestmmap", 0600);
1204         if (fd < 0)
1205                 exit(1);
1206         if (write(fd, data, pagesize) != pagesize)
1207                 exit(1);
1208         close(fd);
1209
1210         /*
1211          * Next, try to mmap the file at a fixed address which
1212          * already has something else allocated at it.  If we can,
1213          * also make sure that we see the same garbage.
1214          */
1215         fd = open("conftestmmap", O_RDWR);
1216         if (fd < 0)
1217                 exit(1);
1218         data2 = malloc(2 * pagesize);
1219         if (!data2)
1220                 exit(1);
1221         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
1222         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
1223             MAP_PRIVATE | MAP_FIXED, fd, 0L))
1224                 exit(1);
1225         for (i = 0; i < pagesize; ++i)
1226                 if (*(data + i) != *(data2 + i))
1227                         exit(1);
1228
1229         /*
1230          * Finally, make sure that changes to the mapped area
1231          * do not percolate back to the file as seen by read().
1232          * (This is a bug on some variants of i386 svr4.0.)
1233          */
1234         for (i = 0; i < pagesize; ++i)
1235                 *(data2 + i) = *(data2 + i) + 1;
1236         data3 = malloc(pagesize);
1237         if (!data3)
1238                 exit(1);
1239         if (read(fd, data3, pagesize) != pagesize)
1240                 exit(1);
1241         for (i = 0; i < pagesize; ++i)
1242                 if (*(data + i) != *(data3 + i))
1243                         exit(1);
1244         close(fd);
1245         unlink("conftestmmap");
1246         exit(0);
1247 }
1248 ], ac_cv_func_mmap_fixed_mapped=yes, ac_cv_func_mmap_fixed_mapped=no,
1249 ac_cv_func_mmap_fixed_mapped=no)])
1250 if test $ac_cv_func_mmap_fixed_mapped = yes; then
1251   AC_DEFINE(HAVE_MMAP)
1252 fi
1253 ])
1254
1255 AC_DEFUN(AC_FUNC_GETPGRP,
1256 [AC_CACHE_CHECK(whether getpgrp takes no argument, ac_cv_func_getpgrp_void,
1257 [AC_TRY_RUN([
1258 /*
1259  * If this system has a BSD-style getpgrp(),
1260  * which takes a pid argument, exit unsuccessfully.
1261  *
1262  * Snarfed from Chet Ramey's bash pgrp.c test program
1263  */
1264 #include <stdio.h>
1265 #include <sys/types.h>
1266
1267 int     pid;
1268 int     pg1, pg2, pg3, pg4;
1269 int     ng, np, s, child;
1270
1271 int main()
1272 {
1273         pid = getpid();
1274         pg1 = getpgrp(0);
1275         pg2 = getpgrp();
1276         pg3 = getpgrp(pid);
1277         pg4 = getpgrp(1);
1278
1279         /*
1280          * If all of these values are the same, it's pretty sure that
1281          * we're on a system that ignores getpgrp's first argument.
1282          */
1283         if (pg2 == pg4 && pg1 == pg3 && pg2 == pg3)
1284                 exit(0);
1285
1286         child = fork();
1287         if (child < 0)
1288                 exit(1);
1289         else if (child == 0) {
1290                 np = getpid();
1291                 /*
1292                  * If this is Sys V, this will not work; pgrp will be
1293                  * set to np because setpgrp just changes a pgrp to be
1294                  * the same as the pid.
1295                  */
1296                 setpgrp(np, pg1);
1297                 ng = getpgrp(0);        /* Same result for Sys V and BSD */
1298                 if (ng == pg1) {
1299                         exit(1);
1300                 } else {
1301                         exit(0);
1302                 }
1303         } else {
1304                 wait(&s);
1305                 exit(s>>8);
1306         }
1307 }
1308 ], ac_cv_func_getpgrp_void=yes, ac_cv_func_getpgrp_void=no,
1309    AC_MSG_ERROR(cannot check getpgrp if cross compiling))
1310 ])
1311 if test $ac_cv_func_getpgrp_void = yes; then
1312   AC_DEFINE(GETPGRP_VOID)
1313 fi
1314 ])
1315
1316 AC_DEFUN(AC_FUNC_SETPGRP,
1317 [AC_CACHE_CHECK(whether setpgrp takes no argument, ac_cv_func_setpgrp_void,
1318 AC_TRY_RUN([
1319 #ifdef HAVE_UNISTD_H
1320 #include <unistd.h>
1321 #endif
1322
1323 /*
1324  * If this system has a BSD-style setpgrp, which takes arguments, exit
1325  * successfully.
1326  */
1327 int main()
1328 {
1329     if (setpgrp(1,1) == -1)
1330         exit(0);
1331     else
1332         exit(1);
1333 }
1334 ], ac_cv_func_setpgrp_void=no, ac_cv_func_setpgrp_void=yes,
1335    AC_MSG_ERROR(cannot check setpgrp if cross compiling))
1336 )
1337 if test $ac_cv_func_setpgrp_void = yes; then
1338   AC_DEFINE(SETPGRP_VOID)
1339 fi
1340 ])
1341
1342 AC_DEFUN(AC_FUNC_VPRINTF,
1343 [AC_CHECK_FUNC(vprintf, AC_DEFINE(HAVE_VPRINTF))
1344 if test "$ac_cv_func_vprintf" != yes; then
1345 AC_CHECK_FUNC(_doprnt, AC_DEFINE(HAVE_DOPRNT))
1346 fi
1347 ])
1348
1349 AC_DEFUN(AC_FUNC_VFORK,
1350 [AC_REQUIRE([AC_TYPE_PID_T])dnl
1351 AC_CHECK_HEADER(vfork.h, AC_DEFINE(HAVE_VFORK_H))
1352 AC_CACHE_CHECK(for working vfork, ac_cv_func_vfork_works,
1353 [AC_TRY_RUN([/* Thanks to Paul Eggert for this test.  */
1354 #include <stdio.h>
1355 #include <sys/types.h>
1356 #include <sys/stat.h>
1357 #ifdef HAVE_UNISTD_H
1358 #include <unistd.h>
1359 #endif
1360 #ifdef HAVE_VFORK_H
1361 #include <vfork.h>
1362 #endif
1363 /* On some sparc systems, changes by the child to local and incoming
1364    argument registers are propagated back to the parent.
1365    The compiler is told about this with #include <vfork.h>,
1366    but some compilers (e.g. gcc -O) don't grok <vfork.h>.
1367    Test for this by using a static variable whose address
1368    is put into a register that is clobbered by the vfork.  */
1369 static int
1370 #ifdef __cplusplus
1371 sparc_address_test (int arg)
1372 #else
1373 sparc_address_test (arg) int arg;
1374 #endif
1375 {
1376   static pid_t child;
1377   if (!child) {
1378     child = vfork ();
1379     if (child < 0) {
1380       perror ("vfork");
1381       _exit(2);
1382     }
1383     if (!child) {
1384       arg = getpid();
1385       write(-1, "", 0);
1386       _exit (arg);
1387     }
1388   }
1389 }
1390 int main() {
1391   pid_t parent = getpid ();
1392   pid_t child;
1393
1394   ((int (*)()) sparc_address_test) ();
1395
1396   child = vfork ();
1397
1398   if (child == 0) {
1399     /* Here is another test for sparc vfork register problems.
1400        This test uses lots of local variables, at least
1401        as many local variables as main has allocated so far
1402        including compiler temporaries.  4 locals are enough for
1403        gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe.
1404        A buggy compiler should reuse the register of parent
1405        for one of the local variables, since it will think that
1406        parent can't possibly be used any more in this routine.
1407        Assigning to the local variable will thus munge parent
1408        in the parent process.  */
1409     pid_t
1410       p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(),
1411       p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid();
1412     /* Convince the compiler that p..p7 are live; otherwise, it might
1413        use the same hardware register for all 8 local variables.  */
1414     if (p != p1 || p != p2 || p != p3 || p != p4
1415         || p != p5 || p != p6 || p != p7)
1416       _exit(1);
1417
1418     /* On some systems (e.g. IRIX 3.3),
1419        vfork doesn't separate parent from child file descriptors.
1420        If the child closes a descriptor before it execs or exits,
1421        this munges the parent's descriptor as well.
1422        Test for this by closing stdout in the child.  */
1423     _exit(close(fileno(stdout)) != 0);
1424   } else {
1425     int status;
1426     struct stat st;
1427
1428     while (wait(&status) != child)
1429       ;
1430     exit(
1431          /* Was there some problem with vforking?  */
1432          child < 0
1433
1434          /* Did the child fail?  (This shouldn't happen.)  */
1435          || status
1436
1437          /* Did the vfork/compiler bug occur?  */
1438          || parent != getpid()
1439
1440          /* Did the file descriptor bug occur?  */
1441          || fstat(fileno(stdout), &st) != 0
1442          );
1443   }
1444 }],
1445 ac_cv_func_vfork_works=yes, ac_cv_func_vfork_works=no, AC_CHECK_FUNC(vfork)
1446 ac_cv_func_vfork_works=$ac_cv_func_vfork)])
1447 if test $ac_cv_func_vfork_works = no; then
1448   AC_DEFINE(vfork, fork)
1449 fi
1450 ])
1451
1452 AC_DEFUN(AC_FUNC_WAIT3,
1453 [AC_CACHE_CHECK(for wait3 that fills in rusage, ac_cv_func_wait3_rusage,
1454 [AC_TRY_RUN([#include <sys/types.h>
1455 #include <sys/time.h>
1456 #include <sys/resource.h>
1457 #include <stdio.h>
1458 /* HP-UX has wait3 but does not fill in rusage at all.  */
1459 int main() {
1460   struct rusage r;
1461   int i;
1462   /* Use a field that we can force nonzero --
1463      voluntary context switches.
1464      For systems like NeXT and OSF/1 that don't set it,
1465      also use the system CPU time.  And page faults (I/O) for Linux.  */
1466   r.ru_nvcsw = 0;
1467   r.ru_stime.tv_sec = 0;
1468   r.ru_stime.tv_usec = 0;
1469   r.ru_majflt = r.ru_minflt = 0;
1470   switch (fork()) {
1471   case 0: /* Child.  */
1472     sleep(1); /* Give up the CPU.  */
1473     _exit(0);
1474   case -1: _exit(0); /* What can we do?  */
1475   default: /* Parent.  */
1476     wait3(&i, 0, &r);
1477     sleep(2); /* Avoid "text file busy" from rm on fast HP-UX machines.  */
1478     exit(r.ru_nvcsw == 0 && r.ru_majflt == 0 && r.ru_minflt == 0
1479          && r.ru_stime.tv_sec == 0 && r.ru_stime.tv_usec == 0);
1480   }
1481 }], ac_cv_func_wait3_rusage=yes, ac_cv_func_wait3_rusage=no,
1482 ac_cv_func_wait3_rusage=no)])
1483 if test $ac_cv_func_wait3_rusage = yes; then
1484   AC_DEFINE(HAVE_WAIT3)
1485 fi
1486 ])
1487
1488 AC_DEFUN(AC_FUNC_ALLOCA,
1489 [AC_REQUIRE_CPP()dnl Set CPP; we run AC_EGREP_CPP conditionally.
1490 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
1491 # for constant arguments.  Useless!
1492 AC_CACHE_CHECK([for working alloca.h], ac_cv_header_alloca_h,
1493 [AC_TRY_LINK([#include <alloca.h>], [char *p = alloca(2 * sizeof(int));],
1494   ac_cv_header_alloca_h=yes, ac_cv_header_alloca_h=no)])
1495 if test $ac_cv_header_alloca_h = yes; then
1496   AC_DEFINE(HAVE_ALLOCA_H)
1497 fi
1498
1499 AC_CACHE_CHECK([for alloca], ac_cv_func_alloca_works,
1500 [AC_TRY_LINK([
1501 #ifdef __GNUC__
1502 # define alloca __builtin_alloca
1503 #else
1504 # ifdef _MSC_VER
1505 #  include <malloc.h>
1506 #  define alloca _alloca
1507 # else
1508 #  if HAVE_ALLOCA_H
1509 #   include <alloca.h>
1510 #  else
1511 #   ifdef _AIX
1512  #pragma alloca
1513 #   else
1514 #    ifndef alloca /* predefined by HP cc +Olibcalls */
1515 char *alloca ();
1516 #    endif
1517 #   endif
1518 #  endif
1519 # endif
1520 #endif
1521 ], [char *p = (char *) alloca(1);],
1522   ac_cv_func_alloca_works=yes, ac_cv_func_alloca_works=no)])
1523 if test $ac_cv_func_alloca_works = yes; then
1524   AC_DEFINE(HAVE_ALLOCA)
1525 fi
1526
1527 if test $ac_cv_func_alloca_works = no; then
1528   # The SVR3 libPW and SVR4 libucb both contain incompatible functions
1529   # that cause trouble.  Some versions do not even contain alloca or
1530   # contain a buggy version.  If you still want to use their alloca,
1531   # use ar to extract alloca.o from them instead of compiling alloca.c.
1532   ALLOCA=alloca.${ac_objext}
1533   AC_DEFINE(C_ALLOCA)
1534
1535 AC_CACHE_CHECK(whether alloca needs Cray hooks, ac_cv_os_cray,
1536 [AC_EGREP_CPP(webecray,
1537 [#if defined(CRAY) && ! defined(CRAY2)
1538 webecray
1539 #else
1540 wenotbecray
1541 #endif
1542 ], ac_cv_os_cray=yes, ac_cv_os_cray=no)])
1543 if test $ac_cv_os_cray = yes; then
1544 for ac_func in _getb67 GETB67 getb67; do
1545   AC_CHECK_FUNC($ac_func, [AC_DEFINE_UNQUOTED(CRAY_STACKSEG_END, $ac_func)
1546   break])
1547 done
1548 fi
1549
1550 AC_CACHE_CHECK(stack direction for C alloca, ac_cv_c_stack_direction,
1551 [AC_TRY_RUN([find_stack_direction ()
1552 {
1553   static char *addr = 0;
1554   auto char dummy;
1555   if (addr == 0)
1556     {
1557       addr = &dummy;
1558       return find_stack_direction ();
1559     }
1560   else
1561     return (&dummy > addr) ? 1 : -1;
1562 }
1563 int main ()
1564 {
1565   exit (find_stack_direction() < 0);
1566 }], ac_cv_c_stack_direction=1, ac_cv_c_stack_direction=-1,
1567   ac_cv_c_stack_direction=0)])
1568 AC_DEFINE_UNQUOTED(STACK_DIRECTION, $ac_cv_c_stack_direction)
1569 fi
1570 AC_SUBST(ALLOCA)dnl
1571 ])
1572
1573 AC_DEFUN(AC_FUNC_GETLOADAVG,
1574 [ac_have_func=no # yes means we've found a way to get the load average.
1575
1576 # Some systems with -lutil have (and need) -lkvm as well, some do not.
1577 # On Solaris, -lkvm requires nlist from -lelf, so check that first
1578 # to get the right answer into the cache.
1579 AC_CHECK_LIB(elf, elf_begin, LIBS="-lelf $LIBS")
1580 AC_CHECK_LIB(kvm, kvm_open, LIBS="-lkvm $LIBS")
1581 # Check for the 4.4BSD definition of getloadavg.
1582 AC_CHECK_LIB(util, getloadavg,
1583   [LIBS="-lutil $LIBS" ac_have_func=yes ac_cv_func_getloadavg_setgid=yes])
1584
1585 if test $ac_have_func = no; then
1586   # There is a commonly available library for RS/6000 AIX.
1587   # Since it is not a standard part of AIX, it might be installed locally.
1588   ac_getloadavg_LIBS="$LIBS"; LIBS="-L/usr/local/lib $LIBS"
1589   AC_CHECK_LIB(getloadavg, getloadavg,
1590     LIBS="-lgetloadavg $LIBS", LIBS="$ac_getloadavg_LIBS")
1591 fi
1592
1593 # Make sure it is really in the library, if we think we found it.
1594 AC_REPLACE_FUNCS(getloadavg)
1595
1596 if test $ac_cv_func_getloadavg = yes; then
1597   AC_DEFINE(HAVE_GETLOADAVG)
1598   ac_have_func=yes
1599 else
1600   # Figure out what our getloadavg.c needs.
1601   ac_have_func=no
1602   AC_CHECK_HEADER(sys/dg_sys_info.h,
1603   [ac_have_func=yes; AC_DEFINE(DGUX)
1604   AC_CHECK_LIB(dgc, dg_sys_info)])
1605
1606   # We cannot check for <dwarf.h>, because Solaris 2 does not use dwarf (it
1607   # uses stabs), but it is still SVR4.  We cannot check for <elf.h> because
1608   # Irix 4.0.5F has the header but not the library.
1609   if test $ac_have_func = no && test $ac_cv_lib_elf_elf_begin = yes; then
1610     ac_have_func=yes; AC_DEFINE(SVR4)
1611   fi
1612
1613   if test $ac_have_func = no; then
1614     AC_CHECK_HEADER(inq_stats/cpustats.h,
1615     [ac_have_func=yes; AC_DEFINE(UMAX)
1616     AC_DEFINE(UMAX4_3)])
1617   fi
1618
1619   if test $ac_have_func = no; then
1620     AC_CHECK_HEADER(sys/cpustats.h,
1621     [ac_have_func=yes; AC_DEFINE(UMAX)])
1622   fi
1623
1624   if test $ac_have_func = no; then
1625     AC_CHECK_HEADERS(mach/mach.h)
1626   fi
1627
1628   AC_CHECK_HEADER(nlist.h,
1629   [AC_DEFINE(NLIST_STRUCT)
1630   AC_CACHE_CHECK([for n_un in struct nlist], ac_cv_struct_nlist_n_un,
1631   [AC_TRY_COMPILE([#include <nlist.h>],
1632   [struct nlist n; n.n_un.n_name = 0;],
1633   ac_cv_struct_nlist_n_un=yes, ac_cv_struct_nlist_n_un=no)])
1634   if test $ac_cv_struct_nlist_n_un = yes; then
1635     AC_DEFINE(NLIST_NAME_UNION)
1636   fi
1637   ])dnl
1638 fi # Do not have getloadavg in system libraries.
1639
1640 # Some definitions of getloadavg require that the program be installed setgid.
1641 dnl FIXME Don't hardwire the path of getloadavg.c in the top-level directory.
1642 AC_CACHE_CHECK(whether getloadavg requires setgid,
1643   ac_cv_func_getloadavg_setgid,
1644 [AC_EGREP_CPP([Yowza Am I SETGID yet],
1645 [#include "$srcdir/getloadavg.c"
1646 #ifdef LDAV_PRIVILEGED
1647 Yowza Am I SETGID yet
1648 #endif],
1649   ac_cv_func_getloadavg_setgid=yes, ac_cv_func_getloadavg_setgid=no)])
1650 if test $ac_cv_func_getloadavg_setgid = yes; then
1651   NEED_SETGID=true; AC_DEFINE(GETLOADAVG_PRIVILEGED)
1652 else
1653   NEED_SETGID=false
1654 fi
1655 AC_SUBST(NEED_SETGID)dnl
1656
1657 if test $ac_cv_func_getloadavg_setgid = yes; then
1658   AC_CACHE_CHECK(group of /dev/kmem, ac_cv_group_kmem,
1659 [changequote(, )dnl
1660   # On Solaris, /dev/kmem is a symlink.  Get info on the real file.
1661   ac_ls_output=`ls -lgL /dev/kmem 2>/dev/null`
1662   # If we got an error (system does not support symlinks), try without -L.
1663   test -z "$ac_ls_output" && ac_ls_output=`ls -lg /dev/kmem`
1664   ac_cv_group_kmem=`echo $ac_ls_output \
1665     | sed -ne 's/[      ][      ]*/ /g;
1666                s/^.[sSrwx-]* *[0-9]* *\([^0-9]*\)  *.*/\1/;
1667                / /s/.* //;p;'`
1668 changequote([, ])dnl
1669 ])
1670   KMEM_GROUP=$ac_cv_group_kmem
1671 fi
1672 AC_SUBST(KMEM_GROUP)dnl
1673 ])
1674
1675 AC_DEFUN(AC_FUNC_UTIME_NULL,
1676 [AC_CACHE_CHECK(whether utime accepts a null argument, ac_cv_func_utime_null,
1677 [rm -f conftestdata; > conftestdata
1678 # Sequent interprets utime(file, 0) to mean use start of epoch.  Wrong.
1679 AC_TRY_RUN([#include <sys/types.h>
1680 #include <sys/stat.h>
1681 int main() {
1682 struct stat s, t;
1683 exit(!(stat ("conftestdata", &s) == 0 && utime("conftestdata", (long *)0) == 0
1684 && stat("conftestdata", &t) == 0 && t.st_mtime >= s.st_mtime
1685 && t.st_mtime - s.st_mtime < 120));
1686 }], ac_cv_func_utime_null=yes, ac_cv_func_utime_null=no,
1687   ac_cv_func_utime_null=no)
1688 rm -f core])
1689 if test $ac_cv_func_utime_null = yes; then
1690   AC_DEFINE(HAVE_UTIME_NULL)
1691 fi
1692 ])
1693
1694 AC_DEFUN(AC_FUNC_STRCOLL,
1695 [AC_CACHE_CHECK(for working strcoll, ac_cv_func_strcoll_works,
1696 [AC_TRY_RUN([#include <string.h>
1697 int main ()
1698 {
1699   exit (strcoll ("abc", "def") >= 0 ||
1700         strcoll ("ABC", "DEF") >= 0 ||
1701         strcoll ("123", "456") >= 0);
1702 }], ac_cv_func_strcoll_works=yes, ac_cv_func_strcoll_works=no,
1703 ac_cv_func_strcoll_works=no)])
1704 if test $ac_cv_func_strcoll_works = yes; then
1705   AC_DEFINE(HAVE_STRCOLL)
1706 fi
1707 ])
1708
1709 AC_DEFUN(AC_FUNC_SETVBUF_REVERSED,
1710 [AC_CACHE_CHECK(whether setvbuf arguments are reversed,
1711   ac_cv_func_setvbuf_reversed,
1712 [AC_TRY_RUN([#include <stdio.h>
1713 /* If setvbuf has the reversed format, exit 0. */
1714 int main () {
1715   /* This call has the arguments reversed.
1716      A reversed system may check and see that the address of main
1717      is not _IOLBF, _IONBF, or _IOFBF, and return nonzero.  */
1718   if (setvbuf(stdout, _IOLBF, (char *) main, BUFSIZ) != 0)
1719     exit(1);
1720   putc('\r', stdout);
1721   exit(0);                      /* Non-reversed systems segv here.  */
1722 }], ac_cv_func_setvbuf_reversed=yes, ac_cv_func_setvbuf_reversed=no)
1723 rm -f core])
1724 if test $ac_cv_func_setvbuf_reversed = yes; then
1725   AC_DEFINE(SETVBUF_REVERSED)
1726 fi
1727 ])
1728
1729 AC_DEFUN(AC_FUNC_GETMNTENT,
1730 [# getmntent is in -lsun on Irix 4, -lseq on Dynix/PTX, -lgen on Unixware.
1731 AC_CHECK_LIB(sun, getmntent, LIBS="-lsun $LIBS",
1732   [AC_CHECK_LIB(seq, getmntent, LIBS="-lseq $LIBS",
1733     [AC_CHECK_LIB(gen, getmntent, LIBS="-lgen $LIBS")])])
1734 AC_CHECK_FUNC(getmntent, [AC_DEFINE(HAVE_GETMNTENT)])])
1735
1736 AC_DEFUN(AC_FUNC_STRFTIME,
1737 [AC_CHECK_FUNC(strftime, [AC_DEFINE(HAVE_STRFTIME)],
1738 [# strftime is in -lintl on SCO UNIX.
1739 AC_CHECK_LIB(intl, strftime,
1740 [AC_DEFINE(HAVE_STRFTIME)
1741 LIBS="-lintl $LIBS"])])])
1742
1743 AC_DEFUN(AC_FUNC_MEMCMP,
1744 [AC_CACHE_CHECK(for 8-bit clean memcmp, ac_cv_func_memcmp_clean,
1745 [AC_TRY_RUN([
1746 int main()
1747 {
1748   char c0 = 0x40, c1 = 0x80, c2 = 0x81;
1749   exit(memcmp(&c0, &c2, 1) < 0 && memcmp(&c1, &c2, 1) < 0 ? 0 : 1);
1750 }
1751 ], ac_cv_func_memcmp_clean=yes, ac_cv_func_memcmp_clean=no,
1752 ac_cv_func_memcmp_clean=no)])
1753 test $ac_cv_func_memcmp_clean = no && LIBOBJS="$LIBOBJS memcmp.${ac_objext}"
1754 AC_SUBST(LIBOBJS)dnl
1755 ])
1756
1757 AC_DEFUN(AC_FUNC_SELECT_ARGTYPES,
1758 [AC_MSG_CHECKING([types of arguments for select()])
1759  AC_CACHE_VAL(ac_cv_func_select_arg234,dnl
1760  [AC_CACHE_VAL(ac_cv_func_select_arg1,dnl
1761   [AC_CACHE_VAL(ac_cv_func_select_arg5,dnl
1762    [for ac_cv_func_select_arg234 in 'fd_set *' 'int *' 'void *'; do
1763      for ac_cv_func_select_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
1764       for ac_cv_func_select_arg5 in 'struct timeval *' 'const struct timeval *'; do
1765        AC_TRY_COMPILE(dnl
1766 [#ifdef HAVE_SYS_TYPES_H
1767 #include <sys/types.h>
1768 #endif
1769 #ifdef HAVE_SYS_TIME_H
1770 #include <sys/time.h>
1771 #endif
1772 #ifdef HAVE_SYS_SELECT_H
1773 #include <sys/select.h>
1774 #endif
1775 #ifdef HAVE_SYS_SOCKET_H
1776 #include <sys/socket.h>
1777 #endif
1778 extern select ($ac_cv_func_select_arg1,$ac_cv_func_select_arg234,$ac_cv_func_select_arg234,$ac_cv_func_select_arg234,$ac_cv_func_select_arg5);],,dnl
1779         [ac_not_found=no ; break 3],ac_not_found=yes)
1780       done
1781      done
1782     done
1783    ])dnl AC_CACHE_VAL
1784   ])dnl AC_CACHE_VAL
1785  ])dnl AC_CACHE_VAL
1786  if test "$ac_not_found" = yes; then
1787   ac_cv_func_select_arg1=int
1788   ac_cv_func_select_arg234='int *'
1789   ac_cv_func_select_arg5='struct timeval *'
1790  fi
1791  AC_MSG_RESULT([$ac_cv_func_select_arg1,$ac_cv_func_select_arg234,$ac_cv_func_select_arg5])
1792  AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG1,$ac_cv_func_select_arg1)
1793  AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG234,($ac_cv_func_select_arg234))
1794  AC_DEFINE_UNQUOTED(SELECT_TYPE_ARG5,($ac_cv_func_select_arg5))
1795 ])
1796
1797
1798 dnl ### Checks for structure members
1799
1800
1801 AC_DEFUN(AC_HEADER_TIME,
1802 [AC_CACHE_CHECK([whether time.h and sys/time.h may both be included],
1803   ac_cv_header_time,
1804 [AC_TRY_COMPILE([#include <sys/types.h>
1805 #include <sys/time.h>
1806 #include <time.h>],
1807 [struct tm *tp;], ac_cv_header_time=yes, ac_cv_header_time=no)])
1808 if test $ac_cv_header_time = yes; then
1809   AC_DEFINE(TIME_WITH_SYS_TIME)
1810 fi
1811 ])
1812
1813 AC_DEFUN(AC_STRUCT_TM,
1814 [AC_CACHE_CHECK([whether struct tm is in sys/time.h or time.h],
1815   ac_cv_struct_tm,
1816 [AC_TRY_COMPILE([#include <sys/types.h>
1817 #include <time.h>],
1818 [struct tm *tp; tp->tm_sec;],
1819   ac_cv_struct_tm=time.h, ac_cv_struct_tm=sys/time.h)])
1820 if test $ac_cv_struct_tm = sys/time.h; then
1821   AC_DEFINE(TM_IN_SYS_TIME)
1822 fi
1823 ])
1824
1825 AC_DEFUN(AC_STRUCT_TIMEZONE,
1826 [AC_REQUIRE([AC_STRUCT_TM])dnl
1827 AC_CACHE_CHECK([for tm_zone in struct tm], ac_cv_struct_tm_zone,
1828 [AC_TRY_COMPILE([#include <sys/types.h>
1829 #include <$ac_cv_struct_tm>], [struct tm tm; tm.tm_zone;],
1830   ac_cv_struct_tm_zone=yes, ac_cv_struct_tm_zone=no)])
1831 if test "$ac_cv_struct_tm_zone" = yes; then
1832   AC_DEFINE(HAVE_TM_ZONE)
1833 else
1834   AC_CACHE_CHECK(for tzname, ac_cv_var_tzname,
1835 [AC_TRY_LINK(
1836 changequote(<<, >>)dnl
1837 <<#include <time.h>
1838 #ifndef tzname /* For SGI.  */
1839 extern char *tzname[]; /* RS6000 and others reject char **tzname.  */
1840 #endif>>,
1841 changequote([, ])dnl
1842 [atoi(*tzname);], ac_cv_var_tzname=yes, ac_cv_var_tzname=no)])
1843   if test $ac_cv_var_tzname = yes; then
1844     AC_DEFINE(HAVE_TZNAME)
1845   fi
1846 fi
1847 ])
1848
1849 AC_DEFUN(AC_STRUCT_ST_BLOCKS,
1850 [AC_CACHE_CHECK([for st_blocks in struct stat], ac_cv_struct_st_blocks,
1851 [AC_TRY_COMPILE([#include <sys/types.h>
1852 #include <sys/stat.h>], [struct stat s; s.st_blocks;],
1853 ac_cv_struct_st_blocks=yes, ac_cv_struct_st_blocks=no)])
1854 if test $ac_cv_struct_st_blocks = yes; then
1855   AC_DEFINE(HAVE_ST_BLOCKS)
1856 else
1857   LIBOBJS="$LIBOBJS fileblocks.${ac_objext}"
1858 fi
1859 AC_SUBST(LIBOBJS)dnl
1860 ])
1861
1862 AC_DEFUN(AC_STRUCT_ST_BLKSIZE,
1863 [AC_CACHE_CHECK([for st_blksize in struct stat], ac_cv_struct_st_blksize,
1864 [AC_TRY_COMPILE([#include <sys/types.h>
1865 #include <sys/stat.h>], [struct stat s; s.st_blksize;],
1866 ac_cv_struct_st_blksize=yes, ac_cv_struct_st_blksize=no)])
1867 if test $ac_cv_struct_st_blksize = yes; then
1868   AC_DEFINE(HAVE_ST_BLKSIZE)
1869 fi
1870 ])
1871
1872 AC_DEFUN(AC_STRUCT_ST_RDEV,
1873 [AC_CACHE_CHECK([for st_rdev in struct stat], ac_cv_struct_st_rdev,
1874 [AC_TRY_COMPILE([#include <sys/types.h>
1875 #include <sys/stat.h>], [struct stat s; s.st_rdev;],
1876 ac_cv_struct_st_rdev=yes, ac_cv_struct_st_rdev=no)])
1877 if test $ac_cv_struct_st_rdev = yes; then
1878   AC_DEFINE(HAVE_ST_RDEV)
1879 fi
1880 ])
1881
1882
1883 dnl ### Checks for compiler characteristics
1884
1885
1886 AC_DEFUN(AC_C_CROSS,
1887 [AC_OBSOLETE([$0], [; it has been merged into AC_PROG_CC])])
1888
1889 AC_DEFUN(AC_C_CHAR_UNSIGNED,
1890 [AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
1891 [if test "$GCC" = yes; then
1892   # GCC predefines this symbol on systems where it applies.
1893 AC_EGREP_CPP(yes,
1894 [#ifdef __CHAR_UNSIGNED__
1895   yes
1896 #endif
1897 ], ac_cv_c_char_unsigned=yes, ac_cv_c_char_unsigned=no)
1898 else
1899 AC_TRY_RUN(
1900 [/* volatile prevents gcc2 from optimizing the test away on sparcs.  */
1901 #if !defined(__STDC__) || __STDC__ != 1
1902 #define volatile
1903 #endif
1904 int main() {
1905   volatile char c = 255; exit(c < 0);
1906 }], ac_cv_c_char_unsigned=yes, ac_cv_c_char_unsigned=no)
1907 fi])
1908 if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
1909   AC_DEFINE(__CHAR_UNSIGNED__)
1910 fi
1911 ])
1912
1913 AC_DEFUN(AC_C_LONG_DOUBLE,
1914 [AC_CACHE_CHECK(for long double, ac_cv_c_long_double,
1915 [if test "$GCC" = yes; then
1916   ac_cv_c_long_double=yes
1917 else
1918 AC_TRY_RUN([int main() {
1919 /* The Stardent Vistra knows sizeof(long double), but does not support it.  */
1920 long double foo = 0.0;
1921 /* On Ultrix 4.3 cc, long double is 4 and double is 8.  */
1922 exit(sizeof(long double) < sizeof(double)); }],
1923 ac_cv_c_long_double=yes, ac_cv_c_long_double=no)
1924 fi])
1925 if test $ac_cv_c_long_double = yes; then
1926   AC_DEFINE(HAVE_LONG_DOUBLE)
1927 fi
1928 ])
1929
1930 AC_DEFUN(AC_INT_16_BITS,
1931 [AC_OBSOLETE([$0], [; instead use AC_CHECK_SIZEOF(int)])dnl
1932 AC_MSG_CHECKING(whether int is 16 bits)
1933 AC_TRY_RUN([int main() { exit(sizeof(int) != 2); }],
1934  [AC_MSG_RESULT(yes)
1935  AC_DEFINE(INT_16_BITS)], AC_MSG_RESULT(no))
1936 ])
1937
1938 AC_DEFUN(AC_LONG_64_BITS,
1939 [AC_OBSOLETE([$0], [; instead use AC_CHECK_SIZEOF(long)])dnl
1940 AC_MSG_CHECKING(whether long int is 64 bits)
1941 AC_TRY_RUN([int main() { exit(sizeof(long int) != 8); }],
1942  [AC_MSG_RESULT(yes)
1943  AC_DEFINE(LONG_64_BITS)], AC_MSG_RESULT(no))
1944 ])
1945
1946 AC_DEFUN(AC_C_BIGENDIAN,
1947 [AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
1948 [ac_cv_c_bigendian=unknown
1949 # See if sys/param.h defines the BYTE_ORDER macro.
1950 AC_TRY_COMPILE([#include <sys/types.h>
1951 #include <sys/param.h>], [
1952 #if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
1953  bogus endian macros
1954 #endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
1955 AC_TRY_COMPILE([#include <sys/types.h>
1956 #include <sys/param.h>], [
1957 #if BYTE_ORDER != BIG_ENDIAN
1958  not big endian
1959 #endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
1960 if test $ac_cv_c_bigendian = unknown; then
1961 AC_TRY_RUN([int main () {
1962   /* Are we little or big endian?  From Harbison&Steele.  */
1963   union
1964   {
1965     long l;
1966     char c[sizeof (long)];
1967   } u;
1968   u.l = 1;
1969   exit (u.c[sizeof (long) - 1] == 1);
1970 }], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes)
1971 fi])
1972 if test $ac_cv_c_bigendian = yes; then
1973   AC_DEFINE(WORDS_BIGENDIAN)
1974 fi
1975 ])
1976
1977 dnl Do nothing if the compiler accepts the inline keyword.
1978 dnl Otherwise define inline to __inline__ or __inline if one of those work,
1979 dnl otherwise define inline to be empty.
1980 AC_DEFUN(AC_C_INLINE,
1981 [AC_CACHE_CHECK([for inline], ac_cv_c_inline,
1982 [ac_cv_c_inline=no
1983 for ac_kw in inline __inline__ __inline; do
1984   AC_TRY_COMPILE(, [} $ac_kw foo() {], [ac_cv_c_inline=$ac_kw; break])
1985 done
1986 ])
1987 case "$ac_cv_c_inline" in
1988   inline | yes) ;;
1989   no) AC_DEFINE(inline, ) ;;
1990   *)  AC_DEFINE_UNQUOTED(inline, $ac_cv_c_inline) ;;
1991 esac
1992 ])
1993
1994 AC_DEFUN(AC_C_CONST,
1995 [dnl This message is consistent in form with the other checking messages,
1996 dnl and with the result message.
1997 AC_CACHE_CHECK([for working const], ac_cv_c_const,
1998 [AC_TRY_COMPILE(,
1999 changequote(<<, >>)dnl
2000 <<
2001 #ifndef __cplusplus
2002 /* Ultrix mips cc rejects this.  */
2003 typedef int charset[2]; const charset x;
2004 #endif
2005 /* SunOS 4.1.1 cc rejects this.  */
2006 char const *const *ccp;
2007 char **p;
2008 /* NEC SVR4.0.2 mips cc rejects this.  */
2009 struct point {int x, y;};
2010 static struct point const zero = {0,0};
2011 /* AIX XL C 1.02.0.0 rejects this.
2012    It does not let you subtract one const X* pointer from another in an arm
2013    of an if-expression whose if-part is not a constant expression */
2014 const char *g = "string";
2015 ccp = &g + (g ? g-g : 0);
2016 /* HPUX 7.0 cc rejects these. */
2017 ++ccp;
2018 p = (char**) ccp;
2019 ccp = (char const *const *) p;
2020 { /* SCO 3.2v4 cc rejects this.  */
2021   char *t;
2022   char const *s = 0 ? (char *) 0 : (char const *) 0;
2023
2024   *t++ = 0;
2025 }
2026 { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
2027   int x[] = {25, 17};
2028   const int *foo = &x[0];
2029   ++foo;
2030 }
2031 { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
2032   typedef const int *iptr;
2033   iptr p = 0;
2034   ++p;
2035 }
2036 { /* AIX XL C 1.02.0.0 rejects this saying
2037      "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
2038   struct s { int j; const int *ap[3]; };
2039   struct s *b; b->j = 5;
2040 }
2041 { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
2042   const int foo = 10;
2043 }
2044 >>,
2045 changequote([, ])dnl
2046 ac_cv_c_const=yes, ac_cv_c_const=no)])
2047 if test $ac_cv_c_const = no; then
2048   AC_DEFINE(const, )
2049 fi
2050 ])
2051
2052 AC_DEFUN(AC_C_STRINGIZE, [
2053 AC_REQUIRE([AC_PROG_CPP])
2054 AC_MSG_CHECKING([for preprocessor stringizing operator])
2055 AC_CACHE_VAL(ac_cv_c_stringize,
2056 AC_EGREP_CPP([#teststring],[
2057 #define x(y) #y
2058
2059 char *s = x(teststring);
2060 ], ac_cv_c_stringize=no, ac_cv_c_stringize=yes))
2061 if test "${ac_cv_c_stringize}" = yes
2062 then
2063         AC_DEFINE(HAVE_STRINGIZE)
2064 fi
2065 AC_MSG_RESULT([${ac_cv_c_stringize}])
2066 ])dnl
2067
2068 define(AC_ARG_ARRAY,
2069 [errprint(__file__:__line__: [$0] has been removed; don't do unportable things with arguments
2070 )m4exit(4)])
2071
2072 dnl Check the object extension used by the compiler: typically .o or
2073 dnl .obj.  If this is called, some other behaviour will change,
2074 dnl determined by ac_objext.
2075 AC_DEFUN(AC_OBJEXT,
2076 [AC_MSG_CHECKING([for object suffix])
2077 AC_CACHE_VAL(ac_cv_objext,
2078 [rm -f conftest*
2079 echo 'int i = 1;' > conftest.$ac_ext
2080 if AC_TRY_EVAL(ac_compile); then
2081   for ac_file in conftest.*; do
2082     case $ac_file in
2083     *.c) ;;
2084     *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
2085     esac
2086   done
2087 else
2088   AC_MSG_ERROR([installation or configuration problem; compiler does not work])
2089 fi
2090 rm -f conftest*])
2091 AC_MSG_RESULT($ac_cv_objext)
2092 OBJEXT=$ac_cv_objext
2093 ac_objext=$ac_cv_objext
2094 AC_SUBST(OBJEXT)])
2095
2096 dnl Determine the linker flags (e.g. `-L' and `-l') for the Fortran 77
2097 dnl intrinsic and run-time libraries that are required to successfully
2098 dnl link a Fortran 77 program or shared library.  The output variable
2099 dnl FLIBS is set to these flags.
2100 dnl
2101 dnl This macro is intended to be used in those situations when it is
2102 dnl necessary to mix, e.g. C++ and Fortran 77, source code into a single
2103 dnl program or shared library.
2104 dnl
2105 dnl For example, if object files from a C++ and Fortran 77 compiler must
2106 dnl be linked together, then the C++ compiler/linker must be used for
2107 dnl linking (since special C++-ish things need to happen at link time
2108 dnl like calling global constructors, instantiating templates, enabling
2109 dnl exception support, etc.).
2110 dnl
2111 dnl However, the Fortran 77 intrinsic and run-time libraries must be
2112 dnl linked in as well, but the C++ compiler/linker doesn't know how to
2113 dnl add these Fortran 77 libraries.  Hence, the macro
2114 dnl `AC_F77_LIBRARY_LDFLAGS' was created to determine these Fortran 77
2115 dnl libraries.
2116 dnl
2117 dnl This macro was packaged in its current form by Matthew D. Langston
2118 dnl <langston@SLAC.Stanford.EDU>.  However, nearly all of this macro
2119 dnl came from the `OCTAVE_FLIBS' macro in `octave-2.0.13/aclocal.m4',
2120 dnl and full credit should go to John W. Eaton for writing this
2121 dnl extremely useful macro.  Thank you John.
2122 dnl
2123 dnl AC_F77_LIBRARY_LDFLAGS()
2124 AC_DEFUN(AC_F77_LIBRARY_LDFLAGS,
2125 [AC_MSG_CHECKING([for Fortran 77 libraries])
2126 AC_REQUIRE([AC_PROG_F77])
2127 AC_REQUIRE([AC_CANONICAL_HOST])
2128 AC_CACHE_VAL(ac_cv_flibs,
2129 [changequote(, )dnl
2130 dnl Write a minimal program and compile it with -v.  I don't know what
2131 dnl to do if your compiler doesn't have -v...
2132 echo "      END" > conftest.f
2133 foutput=`${F77} -v -o conftest conftest.f 2>&1`
2134 dnl
2135 dnl The easiest thing to do for xlf output is to replace all the commas
2136 dnl with spaces.  Try to only do that if the output is really from xlf,
2137 dnl since doing that causes problems on other systems.
2138 dnl
2139 xlf_p=`echo $foutput | grep xlfentry`
2140 if test -n "$xlf_p"; then
2141   foutput=`echo $foutput | sed 's/,/ /g'`
2142 fi
2143 dnl
2144 ld_run_path=`echo $foutput | \
2145   sed -n -e 's/^.*LD_RUN_PATH *= *\([^ ]*\).*/\1/p'`
2146 dnl
2147 dnl We are only supposed to find this on Solaris systems...
2148 dnl Uh, the run path should be absolute, shouldn't it?
2149 dnl
2150 case "$ld_run_path" in
2151   /*)
2152     if test "$ac_cv_prog_gcc" = yes; then
2153       ld_run_path="-Xlinker -R -Xlinker $ld_run_path"
2154     else
2155       ld_run_path="-R $ld_run_path"
2156     fi
2157   ;;
2158   *)
2159     ld_run_path=
2160   ;;
2161 esac
2162 dnl
2163 flibs=
2164 lflags=
2165 dnl
2166 dnl If want_arg is set, we know we want the arg to be added to the list,
2167 dnl so we don't have to examine it.
2168 dnl
2169 want_arg=
2170 dnl
2171 for arg in $foutput; do
2172   old_want_arg=$want_arg
2173   want_arg=
2174 dnl
2175 dnl None of the options that take arguments expect the argument to
2176 dnl start with a -, so pretend we didn't see anything special.
2177 dnl
2178   if test -n "$old_want_arg"; then
2179     case "$arg" in
2180       -*)
2181         old_want_arg=
2182       ;;
2183     esac
2184   fi
2185   case "$old_want_arg" in
2186     '')
2187       case $arg in
2188         /*.a)
2189           exists=false
2190           for f in $lflags; do
2191             if test x$arg = x$f; then
2192               exists=true
2193             fi
2194           done
2195           if $exists; then
2196             arg=
2197           else
2198             lflags="$lflags $arg"
2199           fi
2200         ;;
2201         -bI:*)
2202           exists=false
2203           for f in $lflags; do
2204             if test x$arg = x$f; then
2205               exists=true
2206             fi
2207           done
2208           if $exists; then
2209             arg=
2210           else
2211             if test "$ac_cv_prog_gcc" = yes; then
2212               lflags="$lflags -Xlinker $arg"
2213             else
2214               lflags="$lflags $arg"
2215             fi
2216           fi
2217         ;;
2218         -lang* | -lcrt0.o | -lc | -lgcc)
2219           arg=
2220         ;;
2221         -[lLR])
2222           want_arg=$arg
2223           arg=
2224         ;;
2225         -[lLR]*)
2226           exists=false
2227           for f in $lflags; do
2228             if test x$arg = x$f; then
2229               exists=true
2230             fi
2231           done
2232           if $exists; then
2233             arg=
2234           else
2235             case "$arg" in
2236               -lkernel32)
2237                 case "$canonical_host_type" in
2238                   *-*-cygwin*)
2239                     arg=
2240                   ;;
2241                   *)
2242                     lflags="$lflags $arg"
2243                   ;;
2244                 esac
2245               ;;
2246               -lm)
2247               ;;
2248               *)
2249                 lflags="$lflags $arg"
2250               ;;
2251             esac
2252           fi
2253         ;;
2254         -u)
2255           want_arg=$arg
2256           arg=
2257         ;;
2258         -Y)
2259           want_arg=$arg
2260           arg=
2261         ;;
2262         *)
2263           arg=
2264         ;;
2265       esac
2266     ;;
2267     -[lLR])
2268       arg="$old_want_arg $arg"
2269     ;;
2270     -u)
2271       arg="-u $arg"
2272     ;;
2273     -Y)
2274 dnl
2275 dnl Should probably try to ensure unique directory options here too.
2276 dnl This probably only applies to Solaris systems, and then will only
2277 dnl work with gcc...
2278 dnl
2279       arg=`echo $arg | sed -e 's%^P,%%'`
2280       SAVE_IFS=$IFS
2281       IFS=:
2282       list=
2283       for elt in $arg; do
2284         list="$list -L$elt"
2285       done
2286       IFS=$SAVE_IFS
2287       arg="$list"
2288     ;;
2289   esac
2290 dnl
2291   if test -n "$arg"; then
2292     flibs="$flibs $arg"
2293   fi
2294 done
2295 if test -n "$ld_run_path"; then
2296   flibs_result="$ld_run_path $flibs"
2297 else
2298   flibs_result="$flibs"
2299 fi
2300 changequote([, ])dnl
2301 ac_cv_flibs="$flibs_result"])
2302 FLIBS="$ac_cv_flibs"
2303 AC_SUBST(FLIBS)dnl
2304 AC_MSG_RESULT($FLIBS)
2305 ])
2306
2307
2308 dnl ### Checks for operating system services
2309
2310
2311 AC_DEFUN(AC_SYS_INTERPRETER,
2312 [# Pull the hash mark out of the macro call to avoid m4 problems.
2313 ac_msg="whether #! works in shell scripts"
2314 AC_CACHE_CHECK($ac_msg, ac_cv_sys_interpreter,
2315 [echo '#! /bin/cat
2316 exit 69
2317 ' > conftest
2318 chmod u+x conftest
2319 (SHELL=/bin/sh; export SHELL; ./conftest >/dev/null)
2320 if test $? -ne 69; then
2321    ac_cv_sys_interpreter=yes
2322 else
2323    ac_cv_sys_interpreter=no
2324 fi
2325 rm -f conftest])
2326 interpval="$ac_cv_sys_interpreter"
2327 ])
2328
2329 define(AC_HAVE_POUNDBANG,
2330 [errprint(__file__:__line__: [$0 has been replaced by AC_SYS_INTERPRETER, taking no arguments
2331 ])m4exit(4)])
2332
2333 AC_DEFUN(AC_SYS_LONG_FILE_NAMES,
2334 [AC_CACHE_CHECK(for long file names, ac_cv_sys_long_file_names,
2335 [ac_cv_sys_long_file_names=yes
2336 # Test for long file names in all the places we know might matter:
2337 #      .                the current directory, where building will happen
2338 #      $prefix/lib      where we will be installing things
2339 #      $exec_prefix/lib likewise
2340 # eval it to expand exec_prefix.
2341 #      $TMPDIR          if set, where it might want to write temporary files
2342 # if $TMPDIR is not set:
2343 #      /tmp             where it might want to write temporary files
2344 #      /var/tmp         likewise
2345 #      /usr/tmp         likewise
2346 if test -n "$TMPDIR" && test -d "$TMPDIR" && test -w "$TMPDIR"; then
2347   ac_tmpdirs="$TMPDIR"
2348 else
2349   ac_tmpdirs='/tmp /var/tmp /usr/tmp'
2350 fi
2351 for ac_dir in  . $ac_tmpdirs `eval echo $prefix/lib $exec_prefix/lib` ; do
2352   test -d $ac_dir || continue
2353   test -w $ac_dir || continue # It is less confusing to not echo anything here.
2354   (echo 1 > $ac_dir/conftest9012345) 2>/dev/null
2355   (echo 2 > $ac_dir/conftest9012346) 2>/dev/null
2356   val=`cat $ac_dir/conftest9012345 2>/dev/null`
2357   if test ! -f $ac_dir/conftest9012345 || test "$val" != 1; then
2358     ac_cv_sys_long_file_names=no
2359     rm -f $ac_dir/conftest9012345 $ac_dir/conftest9012346 2>/dev/null
2360     break
2361   fi
2362   rm -f $ac_dir/conftest9012345 $ac_dir/conftest9012346 2>/dev/null
2363 done])
2364 if test $ac_cv_sys_long_file_names = yes; then
2365   AC_DEFINE(HAVE_LONG_FILE_NAMES)
2366 fi
2367 ])
2368
2369 AC_DEFUN(AC_SYS_RESTARTABLE_SYSCALLS,
2370 [AC_CACHE_CHECK(for restartable system calls, ac_cv_sys_restartable_syscalls,
2371 [AC_TRY_RUN(
2372 [/* Exit 0 (true) if wait returns something other than -1,
2373    i.e. the pid of the child, which means that wait was restarted
2374    after getting the signal.  */
2375 #include <sys/types.h>
2376 #include <signal.h>
2377 ucatch (isig) { }
2378 int main () {
2379   int i = fork (), status;
2380   if (i == 0) { sleep (3); kill (getppid (), SIGINT); sleep (3); exit (0); }
2381   signal (SIGINT, ucatch);
2382   status = wait(&i);
2383   if (status == -1) wait(&i);
2384   exit (status == -1);
2385 }
2386 ], ac_cv_sys_restartable_syscalls=yes, ac_cv_sys_restartable_syscalls=no)])
2387 if test $ac_cv_sys_restartable_syscalls = yes; then
2388   AC_DEFINE(HAVE_RESTARTABLE_SYSCALLS)
2389 fi
2390 ])
2391
2392 AC_DEFUN(AC_PATH_X,
2393 [AC_REQUIRE_CPP()dnl Set CPP; we run AC_PATH_X_DIRECT conditionally.
2394 # If we find X, set shell vars x_includes and x_libraries to the
2395 # paths, otherwise set no_x=yes.
2396 # Uses ac_ vars as temps to allow command line to override cache and checks.
2397 # --without-x overrides everything else, but does not touch the cache.
2398 AC_MSG_CHECKING(for X)
2399
2400 AC_ARG_WITH(x, [  --with-x                use the X Window System])
2401 # $have_x is `yes', `no', `disabled', or empty when we do not yet know.
2402 if test "x$with_x" = xno; then
2403   # The user explicitly disabled X.
2404   have_x=disabled
2405 else
2406   if test "x$x_includes" != xNONE && test "x$x_libraries" != xNONE; then
2407     # Both variables are already set.
2408     have_x=yes
2409   else
2410 AC_CACHE_VAL(ac_cv_have_x,
2411 [# One or both of the vars are not set, and there is no cached value.
2412 ac_x_includes=NO ac_x_libraries=NO
2413 AC_PATH_X_XMKMF
2414 AC_PATH_X_DIRECT
2415 if test "$ac_x_includes" = NO || test "$ac_x_libraries" = NO; then
2416   # Didn't find X anywhere.  Cache the known absence of X.
2417   ac_cv_have_x="have_x=no"
2418 else
2419   # Record where we found X for the cache.
2420   ac_cv_have_x="have_x=yes \
2421                 ac_x_includes=$ac_x_includes ac_x_libraries=$ac_x_libraries"
2422 fi])dnl
2423   fi
2424   eval "$ac_cv_have_x"
2425 fi # $with_x != no
2426
2427 if test "$have_x" != yes; then
2428   AC_MSG_RESULT($have_x)
2429   no_x=yes
2430 else
2431   # If each of the values was on the command line, it overrides each guess.
2432   test "x$x_includes" = xNONE && x_includes=$ac_x_includes
2433   test "x$x_libraries" = xNONE && x_libraries=$ac_x_libraries
2434   # Update the cache value to reflect the command line values.
2435   ac_cv_have_x="have_x=yes \
2436                 ac_x_includes=$x_includes ac_x_libraries=$x_libraries"
2437   AC_MSG_RESULT([libraries $x_libraries, headers $x_includes])
2438 fi
2439 ])
2440
2441 dnl Internal subroutine of AC_PATH_X.
2442 dnl Set ac_x_includes and/or ac_x_libraries.
2443 AC_DEFUN(AC_PATH_X_XMKMF,
2444 [rm -fr conftestdir
2445 if mkdir conftestdir; then
2446   cd conftestdir
2447   # Make sure to not put "make" in the Imakefile rules, since we grep it out.
2448   cat > Imakefile <<'EOF'
2449 acfindx:
2450         @echo 'ac_im_incroot="${INCROOT}"; ac_im_usrlibdir="${USRLIBDIR}"; ac_im_libdir="${LIBDIR}"'
2451 EOF
2452   if (xmkmf) >/dev/null 2>/dev/null && test -f Makefile; then
2453     # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
2454     eval `${MAKE-make} acfindx 2>/dev/null | grep -v make`
2455     # Open Windows xmkmf reportedly sets LIBDIR instead of USRLIBDIR.
2456     for ac_extension in a so sl; do
2457       if test ! -f $ac_im_usrlibdir/libX11.$ac_extension &&
2458         test -f $ac_im_libdir/libX11.$ac_extension; then
2459         ac_im_usrlibdir=$ac_im_libdir; break
2460       fi
2461     done
2462     # Screen out bogus values from the imake configuration.  They are
2463     # bogus both because they are the default anyway, and because
2464     # using them would break gcc on systems where it needs fixed includes.
2465     case "$ac_im_incroot" in
2466         /usr/include) ;;
2467         *) test -f "$ac_im_incroot/X11/Xos.h" && ac_x_includes="$ac_im_incroot" ;;
2468     esac
2469     case "$ac_im_usrlibdir" in
2470         /usr/lib | /lib) ;;
2471         *) test -d "$ac_im_usrlibdir" && ac_x_libraries="$ac_im_usrlibdir" ;;
2472     esac
2473   fi
2474   cd ..
2475   rm -fr conftestdir
2476 fi
2477 ])
2478
2479 dnl Internal subroutine of AC_PATH_X.
2480 dnl Set ac_x_includes and/or ac_x_libraries.
2481 AC_DEFUN(AC_PATH_X_DIRECT,
2482 [if test "$ac_x_includes" = NO; then
2483   # Guess where to find include files, by looking for this one X11 .h file.
2484   test -z "$x_direct_test_include" && x_direct_test_include=X11/Intrinsic.h
2485
2486   # First, try using that file with no special directory specified.
2487 AC_TRY_CPP([#include <$x_direct_test_include>],
2488 [# We can compile using X headers with no special include directory.
2489 ac_x_includes=],
2490 [# Look for the header file in a standard set of common directories.
2491 # Check X11 before X11Rn because it is often a symlink to the current release.
2492   for ac_dir in               \
2493     /usr/X11/include          \
2494     /usr/X11R6/include        \
2495     /usr/X11R5/include        \
2496     /usr/X11R4/include        \
2497                               \
2498     /usr/include/X11          \
2499     /usr/include/X11R6        \
2500     /usr/include/X11R5        \
2501     /usr/include/X11R4        \
2502                               \
2503     /usr/local/X11/include    \
2504     /usr/local/X11R6/include  \
2505     /usr/local/X11R5/include  \
2506     /usr/local/X11R4/include  \
2507                               \
2508     /usr/local/include/X11    \
2509     /usr/local/include/X11R6  \
2510     /usr/local/include/X11R5  \
2511     /usr/local/include/X11R4  \
2512                               \
2513     /usr/X386/include         \
2514     /usr/x386/include         \
2515     /usr/XFree86/include/X11  \
2516                               \
2517     /usr/include              \
2518     /usr/local/include        \
2519     /usr/unsupported/include  \
2520     /usr/athena/include       \
2521     /usr/local/x11r5/include  \
2522     /usr/lpp/Xamples/include  \
2523                               \
2524     /usr/openwin/include      \
2525     /usr/openwin/share/include \
2526     ; \
2527   do
2528     if test -r "$ac_dir/$x_direct_test_include"; then
2529       ac_x_includes=$ac_dir
2530       break
2531     fi
2532   done])
2533 fi # $ac_x_includes = NO
2534
2535 if test "$ac_x_libraries" = NO; then
2536   # Check for the libraries.
2537
2538   test -z "$x_direct_test_library" && x_direct_test_library=Xt
2539   test -z "$x_direct_test_function" && x_direct_test_function=XtMalloc
2540
2541   # See if we find them without any special options.
2542   # Don't add to $LIBS permanently.
2543   ac_save_LIBS="$LIBS"
2544   LIBS="-l$x_direct_test_library $LIBS"
2545 AC_TRY_LINK(, [${x_direct_test_function}()],
2546 [LIBS="$ac_save_LIBS"
2547 # We can link X programs with no special library path.
2548 ac_x_libraries=],
2549 [LIBS="$ac_save_LIBS"
2550 # First see if replacing the include by lib works.
2551 # Check X11 before X11Rn because it is often a symlink to the current release.
2552 for ac_dir in `echo "$ac_x_includes" | sed s/include/lib/` \
2553     /usr/X11/lib          \
2554     /usr/X11R6/lib        \
2555     /usr/X11R5/lib        \
2556     /usr/X11R4/lib        \
2557                           \
2558     /usr/lib/X11          \
2559     /usr/lib/X11R6        \
2560     /usr/lib/X11R5        \
2561     /usr/lib/X11R4        \
2562                           \
2563     /usr/local/X11/lib    \
2564     /usr/local/X11R6/lib  \
2565     /usr/local/X11R5/lib  \
2566     /usr/local/X11R4/lib  \
2567                           \
2568     /usr/local/lib/X11    \
2569     /usr/local/lib/X11R6  \
2570     /usr/local/lib/X11R5  \
2571     /usr/local/lib/X11R4  \
2572                           \
2573     /usr/X386/lib         \
2574     /usr/x386/lib         \
2575     /usr/XFree86/lib/X11  \
2576                           \
2577     /usr/lib              \
2578     /usr/local/lib        \
2579     /usr/unsupported/lib  \
2580     /usr/athena/lib       \
2581     /usr/local/x11r5/lib  \
2582     /usr/lpp/Xamples/lib  \
2583     /lib/usr/lib/X11      \
2584                           \
2585     /usr/openwin/lib      \
2586     /usr/openwin/share/lib \
2587     ; \
2588 do
2589 dnl Don't even attempt the hair of trying to link an X program!
2590   for ac_extension in a so sl; do
2591     if test -r $ac_dir/lib${x_direct_test_library}.$ac_extension; then
2592       ac_x_libraries=$ac_dir
2593       break 2
2594     fi
2595   done
2596 done])
2597 fi # $ac_x_libraries = NO
2598 ])
2599
2600 dnl Find additional X libraries, magic flags, etc.
2601 AC_DEFUN(AC_PATH_XTRA,
2602 [AC_REQUIRE([AC_PATH_X])dnl
2603 if test "$no_x" = yes; then
2604   # Not all programs may use this symbol, but it does not hurt to define it.
2605   AC_DEFINE(X_DISPLAY_MISSING)
2606   X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
2607 else
2608   if test -n "$x_includes"; then
2609     X_CFLAGS="$X_CFLAGS -I$x_includes"
2610   fi
2611
2612   # It would also be nice to do this for all -L options, not just this one.
2613   if test -n "$x_libraries"; then
2614     X_LIBS="$X_LIBS -L$x_libraries"
2615 dnl FIXME banish uname from this macro!
2616     # For Solaris; some versions of Sun CC require a space after -R and
2617     # others require no space.  Words are not sufficient . . . .
2618     case "`(uname -sr) 2>/dev/null`" in
2619     "SunOS 5"*)
2620       AC_MSG_CHECKING(whether -R must be followed by a space)
2621       ac_xsave_LIBS="$LIBS"; LIBS="$LIBS -R$x_libraries"
2622       AC_TRY_LINK(, , ac_R_nospace=yes, ac_R_nospace=no)
2623       if test $ac_R_nospace = yes; then
2624         AC_MSG_RESULT(no)
2625         X_LIBS="$X_LIBS -R$x_libraries"
2626       else
2627         LIBS="$ac_xsave_LIBS -R $x_libraries"
2628         AC_TRY_LINK(, , ac_R_space=yes, ac_R_space=no)
2629         if test $ac_R_space = yes; then
2630           AC_MSG_RESULT(yes)
2631           X_LIBS="$X_LIBS -R $x_libraries"
2632         else
2633           AC_MSG_RESULT(neither works)
2634         fi
2635       fi
2636       LIBS="$ac_xsave_LIBS"
2637     esac
2638   fi
2639
2640   # Check for system-dependent libraries X programs must link with.
2641   # Do this before checking for the system-independent R6 libraries
2642   # (-lICE), since we may need -lsocket or whatever for X linking.
2643
2644   if test "$ISC" = yes; then
2645     X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl_s -linet"
2646   else
2647     # Martyn.Johnson@cl.cam.ac.uk says this is needed for Ultrix, if the X
2648     # libraries were built with DECnet support.  And karl@cs.umb.edu says
2649     # the Alpha needs dnet_stub (dnet does not exist).
2650     AC_CHECK_LIB(dnet, dnet_ntoa, [X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"])
2651     if test $ac_cv_lib_dnet_dnet_ntoa = no; then
2652       AC_CHECK_LIB(dnet_stub, dnet_ntoa,
2653         [X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"])
2654     fi
2655
2656     # msh@cis.ufl.edu says -lnsl (and -lsocket) are needed for his 386/AT,
2657     # to get the SysV transport functions.
2658     # chad@anasazi.com says the Pyramis MIS-ES running DC/OSx (SVR4)
2659     # needs -lnsl.
2660     # The nsl library prevents programs from opening the X display
2661     # on Irix 5.2, according to dickey@clark.net.
2662     AC_CHECK_FUNC(gethostbyname)
2663     if test $ac_cv_func_gethostbyname = no; then
2664       AC_CHECK_LIB(nsl, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl")
2665     fi
2666
2667     # lieder@skyler.mavd.honeywell.com says without -lsocket,
2668     # socket/setsockopt and other routines are undefined under SCO ODT
2669     # 2.0.  But -lsocket is broken on IRIX 5.2 (and is not necessary
2670     # on later versions), says simon@lia.di.epfl.ch: it contains
2671     # gethostby* variants that don't use the nameserver (or something).
2672     # -lsocket must be given before -lnsl if both are needed.
2673     # We assume that if connect needs -lnsl, so does gethostbyname.
2674     AC_CHECK_FUNC(connect)
2675     if test $ac_cv_func_connect = no; then
2676       AC_CHECK_LIB(socket, connect, X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS", ,
2677         $X_EXTRA_LIBS)
2678     fi
2679
2680     # gomez@mi.uni-erlangen.de says -lposix is necessary on A/UX.
2681     AC_CHECK_FUNC(remove)
2682     if test $ac_cv_func_remove = no; then
2683       AC_CHECK_LIB(posix, remove, X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix")
2684     fi
2685
2686     # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
2687     AC_CHECK_FUNC(shmat)
2688     if test $ac_cv_func_shmat = no; then
2689       AC_CHECK_LIB(ipc, shmat, X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc")
2690     fi
2691   fi
2692
2693   # Check for libraries that X11R6 Xt/Xaw programs need.
2694   ac_save_LDFLAGS="$LDFLAGS"
2695   test -n "$x_libraries" && LDFLAGS="$LDFLAGS -L$x_libraries"
2696   # SM needs ICE to (dynamically) link under SunOS 4.x (so we have to
2697   # check for ICE first), but we must link in the order -lSM -lICE or
2698   # we get undefined symbols.  So assume we have SM if we have ICE.
2699   # These have to be linked with before -lX11, unlike the other
2700   # libraries we check for below, so use a different variable.
2701   #  --interran@uluru.Stanford.EDU, kb@cs.umb.edu.
2702   AC_CHECK_LIB(ICE, IceConnectionNumber,
2703     [X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"], , $X_EXTRA_LIBS)
2704   LDFLAGS="$ac_save_LDFLAGS"
2705
2706 fi
2707 AC_SUBST(X_CFLAGS)dnl
2708 AC_SUBST(X_PRE_LIBS)dnl
2709 AC_SUBST(X_LIBS)dnl
2710 AC_SUBST(X_EXTRA_LIBS)dnl
2711 ])
2712
2713 dnl The old Cygwin32 macro is deprecated.
2714 AC_DEFUN(AC_CYGWIN32,
2715 [AC_OBSOLETE([$0], [; instead use AC_CYGWIN])dnl
2716 AC_CYGWIN])
2717
2718 dnl Check for Cygwin.  This is a way to set the right value for
2719 dnl EXEEXT.
2720 AC_DEFUN(AC_CYGWIN,
2721 [AC_CACHE_CHECK(for Cygwin environment, ac_cv_cygwin,
2722 [AC_TRY_COMPILE(,[
2723 #ifndef __CYGWIN__
2724 #define __CYGWIN__ __CYGWIN32__
2725 #endif
2726 return __CYGWIN__;],
2727 ac_cv_cygwin=yes, ac_cv_cygwin=no)
2728 rm -f conftest*])
2729 CYGWIN=
2730 test "$ac_cv_cygwin" = yes && CYGWIN=yes])
2731
2732 dnl Check for mingw32.  This is another way to set the right value for
2733 dnl EXEEXT.
2734 AC_DEFUN(AC_MINGW32,
2735 [AC_CACHE_CHECK(for mingw32 environment, ac_cv_mingw32,
2736 [AC_TRY_COMPILE(,[return __MINGW32__;],
2737 ac_cv_mingw32=yes, ac_cv_mingw32=no)
2738 rm -f conftest*])
2739 MINGW32=
2740 test "$ac_cv_mingw32" = yes && MINGW32=yes])
2741
2742 dnl Check for the extension used for executables.  This knows that we
2743 dnl add .exe for Cygwin or mingw32.  Otherwise, it compiles a test
2744 dnl executable.  If this is called, the executable extensions will be
2745 dnl automatically used by link commands run by the configure script.
2746 AC_DEFUN(AC_EXEEXT,
2747 [AC_REQUIRE([AC_CYGWIN])
2748 AC_REQUIRE([AC_MINGW32])
2749 AC_MSG_CHECKING([for executable suffix])
2750 AC_CACHE_VAL(ac_cv_exeext,
2751 [if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
2752   ac_cv_exeext=.exe
2753 else
2754   rm -f conftest*
2755   echo 'int main () { return 0; }' > conftest.$ac_ext
2756   ac_cv_exeext=
2757   if AC_TRY_EVAL(ac_link); then
2758     for file in conftest.*; do
2759       case $file in
2760       *.c | *.o | *.obj) ;;
2761       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
2762       esac
2763     done
2764   else
2765     AC_MSG_ERROR([installation or configuration problem: compiler cannot create executables.])
2766   fi
2767   rm -f conftest*
2768   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
2769 fi])
2770 EXEEXT=""
2771 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
2772 AC_MSG_RESULT(${ac_cv_exeext})
2773 dnl Setting ac_exeext will implicitly change the ac_link command.
2774 ac_exeext=$EXEEXT
2775 AC_SUBST(EXEEXT)])
2776
2777
2778 dnl ### Checks for UNIX variants
2779 dnl These are kludges which should be replaced by a single POSIX check.
2780 dnl They aren't cached, to discourage their use.
2781
2782
2783 AC_DEFUN(AC_AIX,
2784 [AC_BEFORE([$0], [AC_TRY_COMPILE])dnl
2785 AC_BEFORE([$0], [AC_TRY_RUN])dnl
2786 AC_MSG_CHECKING(for AIX)
2787 AC_CACHE_VAL(ac_cv_sys_aix,[
2788 AC_EGREP_CPP(yes,
2789 [#ifdef _AIX
2790   yes
2791 #endif
2792 ], [ac_cv_sys_aix=yes], [ac_cv_sys_aix=no])])
2793 AC_MSG_RESULT($ac_cv_sys_aix)
2794 if test $ac_cv_sys_aix = yes; then
2795   AC_DEFINE(_ALL_SOURCE)
2796 fi
2797 ])
2798
2799 AC_DEFUN(AC_MINIX,
2800 [AC_BEFORE([$0], [AC_TRY_COMPILE])dnl
2801 AC_BEFORE([$0], [AC_TRY_RUN])dnl
2802 AC_CHECK_HEADER(minix/config.h, MINIX=yes, MINIX=)
2803 if test "$MINIX" = yes; then
2804   AC_DEFINE(_POSIX_SOURCE)
2805   AC_DEFINE(_POSIX_1_SOURCE, 2)
2806   AC_DEFINE(_MINIX)
2807 fi
2808 ])
2809
2810 AC_DEFUN(AC_ISC_POSIX,
2811 [AC_REQUIRE([AC_PROG_CC])dnl
2812 AC_BEFORE([$0], [AC_TRY_COMPILE])dnl
2813 AC_BEFORE([$0], [AC_TRY_RUN])dnl
2814 AC_MSG_CHECKING(for POSIXized ISC)
2815 AC_CACHE_VAL(ac_cv_sys_isc_posix,[
2816 if test -d /etc/conf/kconfig.d &&
2817   grep _POSIX_VERSION [/usr/include/sys/unistd.h] >/dev/null 2>&1
2818 then
2819   ac_cv_sys_isc_posix=yes
2820 else
2821   ac_cv_sys_isc_posix=no
2822 fi
2823 ])
2824 AC_MSG_RESULT($ac_cv_sys_isc_posix)
2825 if test $ac_cv_sys_isc_posix = yes; then
2826   ISC=yes # If later tests want to check for ISC.
2827   AC_DEFINE(_POSIX_SOURCE)
2828   if test "$GCC" = yes; then
2829     CC="$CC -posix"
2830   else
2831     CC="$CC -Xp"
2832   fi
2833 else
2834   ISC=
2835 fi
2836 ])
2837
2838 AC_DEFUN(AC_XENIX_DIR,
2839 [AC_OBSOLETE([$0], [; instead use AC_HEADER_DIRENT])dnl
2840 AC_REQUIRE([AC_DIR_HEADER])dnl
2841 AC_MSG_CHECKING(for Xenix)
2842 AC_EGREP_CPP(yes,
2843 [#if defined(M_XENIX) && !defined(M_UNIX)
2844   yes
2845 #endif
2846 ], [AC_MSG_RESULT(yes); XENIX=yes], [AC_MSG_RESULT(no); XENIX=])
2847 if test "$XENIX" = yes; then
2848   # Make sure -ldir precedes -lx.
2849   test $ac_header_dirent = dirent.h && LIBS="-ldir $LIBS"
2850   LIBS="$LIBS -lx"
2851 fi
2852 ])
2853
2854 AC_DEFUN(AC_DYNIX_SEQ,
2855 [AC_OBSOLETE([$0], [; instead use AC_FUNC_GETMNTENT])dnl
2856 AC_CHECK_LIB(seq, getmntent, LIBS="-lseq $LIBS")
2857 ])
2858
2859 AC_DEFUN(AC_IRIX_SUN,
2860 [AC_OBSOLETE([$0], [; instead use AC_FUNC_GETMNTENT or AC_CHECK_LIB(sun, getpwnam)])dnl
2861 AC_CHECK_LIB(sun, getmntent, LIBS="-lsun $LIBS")
2862 ])
2863
2864 AC_DEFUN(AC_SCO_INTL,
2865 [AC_OBSOLETE([$0], [; instead use AC_FUNC_STRFTIME])dnl
2866 AC_CHECK_LIB(intl, strftime, LIBS="-lintl $LIBS")
2867 ])