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