acspecific.m4
上传用户:xiejiait
上传日期:2007-01-06
资源大小:881k
文件大小:82k
源码类别:

SCSI/ASPI

开发平台:

MultiPlatform

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