开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
acspecific.m4
资源名称：cdrdao-1.1.3.src.tar.gz　[点击查看]
上传用户：weiliju62
上传日期：2007-01-06
资源大小：619k
文件大小：81k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

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