mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-25 11:37:56 +00:00
3175 lines
80 KiB
Plaintext
3175 lines
80 KiB
Plaintext
# ./aclocal.m4 generated automatically by aclocal 1.4b
|
|
|
|
# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000
|
|
# Free Software Foundation, Inc.
|
|
# This file is free software; the Free Software Foundation
|
|
# gives unlimited permission to copy and/or distribute it,
|
|
# with or without modifications, as long as this notice is preserved.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
|
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
|
# PARTICULAR PURPOSE.
|
|
|
|
dnl $Id: acinclude.m4,v 1.15 1998/05/23 14:54:53 joda Exp $
|
|
dnl
|
|
dnl Only put things that for some reason can't live in the `cf'
|
|
dnl directory in this file.
|
|
dnl
|
|
|
|
dnl $xId: misc.m4,v 1.1 1997/12/14 15:59:04 joda Exp $
|
|
dnl
|
|
define(upcase,`echo $1 | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ`)dnl
|
|
|
|
dnl $Id: misc.m4,v 1.2 2000/07/19 15:04:00 joda Exp $
|
|
dnl
|
|
AC_DEFUN([upcase],[`echo $1 | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ`])dnl
|
|
AC_DEFUN([rk_CONFIG_HEADER],[AH_TOP([#ifndef RCSID
|
|
#define RCSID(msg) \
|
|
static /**/const char *const rcsid[] = { (const char *)rcsid, "\100(#)" msg }
|
|
#endif
|
|
|
|
#undef BINDIR
|
|
#undef LIBDIR
|
|
#undef LIBEXECDIR
|
|
#undef SBINDIR
|
|
|
|
#undef HAVE_INT8_T
|
|
#undef HAVE_INT16_T
|
|
#undef HAVE_INT32_T
|
|
#undef HAVE_INT64_T
|
|
#undef HAVE_U_INT8_T
|
|
#undef HAVE_U_INT16_T
|
|
#undef HAVE_U_INT32_T
|
|
#undef HAVE_U_INT64_T
|
|
|
|
/* Maximum values on all known systems */
|
|
#define MaxHostNameLen (64+4)
|
|
#define MaxPathLen (1024+4)
|
|
|
|
])])
|
|
# Like AC_CONFIG_HEADER, but automatically create stamp file.
|
|
|
|
# serial 3
|
|
|
|
# When config.status generates a header, we must update the stamp-h file.
|
|
# This file resides in the same directory as the config header
|
|
# that is generated. We must strip everything past the first ":",
|
|
# and everything past the last "/".
|
|
|
|
AC_PREREQ([2.12])
|
|
|
|
AC_DEFUN([AM_CONFIG_HEADER],
|
|
[AC_CONFIG_HEADER([$1])
|
|
AC_OUTPUT_COMMANDS(
|
|
ifelse(patsubst([$1], [[^ ]], []),
|
|
[],
|
|
[test -z "$CONFIG_HEADERS" || echo timestamp >dnl
|
|
patsubst([$1], [^\([^:]*/\)?.*], [\1])stamp-h]),
|
|
[am_indx=1
|
|
for am_file in $1; do
|
|
case " $CONFIG_HEADERS " in
|
|
*" $am_file "*)
|
|
echo timestamp > `echo $am_file | sed 's%:.*%%;s%[^/]*$%%'`stamp-h$am_indx
|
|
;;
|
|
esac
|
|
am_indx=\`expr \$am_indx + 1\`
|
|
done])
|
|
])
|
|
|
|
# Do all the work for Automake. This macro actually does too much --
|
|
# some checks are only needed if your package does certain things.
|
|
# But this isn't really a big deal.
|
|
|
|
# serial 3
|
|
|
|
AC_PREREQ([2.13])
|
|
|
|
# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)
|
|
# -----------------------------------------------------------
|
|
# If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED.
|
|
# The purpose of this macro is to provide the user with a means to
|
|
# check macros which are provided without letting her know how the
|
|
# information is coded.
|
|
# If this macro is not defined by Autoconf, define it here.
|
|
ifdef([AC_PROVIDE_IFELSE],
|
|
[],
|
|
[define([AC_PROVIDE_IFELSE],
|
|
[ifdef([AC_PROVIDE_$1],
|
|
[$2], [$3])])])
|
|
|
|
|
|
# AM_INIT_AUTOMAKE(PACKAGE,VERSION, [NO-DEFINE])
|
|
# ----------------------------------------------
|
|
AC_DEFUN([AM_INIT_AUTOMAKE],
|
|
[dnl We require 2.13 because we rely on SHELL being computed by configure.
|
|
AC_REQUIRE([AC_PROG_INSTALL])dnl
|
|
# test to see if srcdir already configured
|
|
if test "`CDPATH=:; cd $srcdir && pwd`" != "`pwd`" &&
|
|
test -f $srcdir/config.status; then
|
|
AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
|
|
fi
|
|
|
|
# Define the identity of the package.
|
|
PACKAGE=$1
|
|
AC_SUBST(PACKAGE)dnl
|
|
VERSION=$2
|
|
AC_SUBST(VERSION)dnl
|
|
ifelse([$3],,
|
|
[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
|
|
AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])
|
|
|
|
# Some tools Automake needs.
|
|
AC_REQUIRE([AM_SANITY_CHECK])dnl
|
|
AC_REQUIRE([AC_ARG_PROGRAM])dnl
|
|
AM_MISSING_PROG(ACLOCAL, aclocal)
|
|
AM_MISSING_PROG(AUTOCONF, autoconf)
|
|
AM_MISSING_PROG(AUTOMAKE, automake)
|
|
AM_MISSING_PROG(AUTOHEADER, autoheader)
|
|
AM_MISSING_PROG(MAKEINFO, makeinfo)
|
|
AM_MISSING_PROG(AMTAR, tar)
|
|
AM_MISSING_INSTALL_SH
|
|
# We need awk for the "check" target. The system "awk" is bad on
|
|
# some platforms.
|
|
AC_REQUIRE([AC_PROG_AWK])dnl
|
|
AC_REQUIRE([AC_PROG_MAKE_SET])dnl
|
|
AC_REQUIRE([AM_DEP_TRACK])dnl
|
|
AC_REQUIRE([AM_SET_DEPDIR])dnl
|
|
AC_PROVIDE_IFELSE([AC_PROG_CC],
|
|
[AM_DEPENDENCIES(CC)],
|
|
[define([AC_PROG_CC],
|
|
defn([AC_PROG_CC])[AM_DEPENDENCIES(CC)])])dnl
|
|
AC_PROVIDE_IFELSE([AC_PROG_CXX],
|
|
[AM_DEPENDENCIES(CXX)],
|
|
[define([AC_PROG_CXX],
|
|
defn([AC_PROG_CXX])[AM_DEPENDENCIES(CXX)])])dnl
|
|
])
|
|
|
|
#
|
|
# Check to make sure that the build environment is sane.
|
|
#
|
|
|
|
AC_DEFUN([AM_SANITY_CHECK],
|
|
[AC_MSG_CHECKING([whether build environment is sane])
|
|
# Just in case
|
|
sleep 1
|
|
echo timestamp > conftestfile
|
|
# Do `set' in a subshell so we don't clobber the current shell's
|
|
# arguments. Must try -L first in case configure is actually a
|
|
# symlink; some systems play weird games with the mod time of symlinks
|
|
# (eg FreeBSD returns the mod time of the symlink's containing
|
|
# directory).
|
|
if (
|
|
set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
|
|
if test "[$]*" = "X"; then
|
|
# -L didn't work.
|
|
set X `ls -t $srcdir/configure conftestfile`
|
|
fi
|
|
if test "[$]*" != "X $srcdir/configure conftestfile" \
|
|
&& test "[$]*" != "X conftestfile $srcdir/configure"; then
|
|
|
|
# If neither matched, then we have a broken ls. This can happen
|
|
# if, for instance, CONFIG_SHELL is bash and it inherits a
|
|
# broken ls alias from the environment. This has actually
|
|
# happened. Such a system could not be considered "sane".
|
|
AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
|
|
alias in your environment])
|
|
fi
|
|
|
|
test "[$]2" = conftestfile
|
|
)
|
|
then
|
|
# Ok.
|
|
:
|
|
else
|
|
AC_MSG_ERROR([newly created file is older than distributed files!
|
|
Check your system clock])
|
|
fi
|
|
rm -f conftest*
|
|
AC_MSG_RESULT(yes)])
|
|
|
|
# AM_MISSING_PROG(NAME, PROGRAM)
|
|
AC_DEFUN([AM_MISSING_PROG], [
|
|
AC_REQUIRE([AM_MISSING_HAS_RUN])
|
|
$1=${$1-"${am_missing_run}$2"}
|
|
AC_SUBST($1)])
|
|
|
|
# Like AM_MISSING_PROG, but only looks for install-sh.
|
|
# AM_MISSING_INSTALL_SH()
|
|
AC_DEFUN([AM_MISSING_INSTALL_SH], [
|
|
AC_REQUIRE([AM_MISSING_HAS_RUN])
|
|
if test -z "$install_sh"; then
|
|
install_sh="$ac_aux_dir/install-sh"
|
|
test -f "$install_sh" || install_sh="$ac_aux_dir/install.sh"
|
|
test -f "$install_sh" || install_sh="${am_missing_run}${ac_auxdir}/install-sh"
|
|
dnl FIXME: an evil hack: we remove the SHELL invocation from
|
|
dnl install_sh because automake adds it back in. Sigh.
|
|
install_sh="`echo $install_sh | sed -e 's/\${SHELL}//'`"
|
|
fi
|
|
AC_SUBST(install_sh)])
|
|
|
|
# AM_MISSING_HAS_RUN.
|
|
# Define MISSING if not defined so far and test if it supports --run.
|
|
# If it does, set am_missing_run to use it, otherwise, to nothing.
|
|
AC_DEFUN([AM_MISSING_HAS_RUN], [
|
|
test x"${MISSING+set}" = xset || \
|
|
MISSING="\${SHELL} `CDPATH=:; cd $ac_aux_dir && pwd`/missing"
|
|
# Use eval to expand $SHELL
|
|
if eval "$MISSING --run :"; then
|
|
am_missing_run="$MISSING --run "
|
|
else
|
|
am_missing_run=
|
|
am_backtick='`'
|
|
AC_MSG_WARN([${am_backtick}missing' script is too old or missing])
|
|
fi
|
|
])
|
|
|
|
# See how the compiler implements dependency checking.
|
|
# Usage:
|
|
# AM_DEPENDENCIES(NAME)
|
|
# NAME is "CC", "CXX" or "OBJC".
|
|
|
|
# We try a few techniques and use that to set a single cache variable.
|
|
|
|
AC_DEFUN([AM_DEPENDENCIES],[
|
|
AC_REQUIRE([AM_SET_DEPDIR])
|
|
AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])
|
|
ifelse([$1],CC,[
|
|
AC_REQUIRE([AC_PROG_CC])
|
|
AC_REQUIRE([AC_PROG_CPP])
|
|
depcc="$CC"
|
|
depcpp="$CPP"],[$1],CXX,[
|
|
AC_REQUIRE([AC_PROG_CXX])
|
|
AC_REQUIRE([AC_PROG_CXXCPP])
|
|
depcc="$CXX"
|
|
depcpp="$CXXCPP"],[$1],OBJC,[
|
|
am_cv_OBJC_dependencies_compiler_type=gcc],[
|
|
AC_REQUIRE([AC_PROG_][$1])
|
|
depcc="$[$1]"
|
|
depcpp=""])
|
|
AC_MSG_CHECKING([dependency style of $depcc])
|
|
AC_CACHE_VAL(am_cv_[$1]_dependencies_compiler_type,[
|
|
if test -z "$AMDEP"; then
|
|
echo '#include "conftest.h"' > conftest.c
|
|
echo 'int i;' > conftest.h
|
|
|
|
am_cv_[$1]_dependencies_compiler_type=none
|
|
for depmode in `sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < "$am_depcomp"`; do
|
|
case "$depmode" in
|
|
nosideeffect)
|
|
# after this tag, mechanisms are not by side-effect, so they'll
|
|
# only be used when explicitly requested
|
|
if test "x$enable_dependency_tracking" = xyes; then
|
|
continue
|
|
else
|
|
break
|
|
fi
|
|
;;
|
|
none) break ;;
|
|
esac
|
|
# We check with `-c' and `-o' for the sake of the "dashmstdout"
|
|
# mode. It turns out that the SunPro C++ compiler does not properly
|
|
# handle `-M -o', and we need to detect this.
|
|
if depmode="$depmode" \
|
|
source=conftest.c object=conftest.o \
|
|
depfile=conftest.Po tmpdepfile=conftest.TPo \
|
|
$SHELL $am_depcomp $depcc -c conftest.c -o conftest.o >/dev/null 2>&1 &&
|
|
grep conftest.h conftest.Po > /dev/null 2>&1; then
|
|
am_cv_[$1]_dependencies_compiler_type="$depmode"
|
|
break
|
|
fi
|
|
done
|
|
|
|
rm -f conftest.*
|
|
else
|
|
am_cv_[$1]_dependencies_compiler_type=none
|
|
fi
|
|
])
|
|
AC_MSG_RESULT($am_cv_[$1]_dependencies_compiler_type)
|
|
[$1]DEPMODE="depmode=$am_cv_[$1]_dependencies_compiler_type"
|
|
AC_SUBST([$1]DEPMODE)
|
|
])
|
|
|
|
# Choose a directory name for dependency files.
|
|
# This macro is AC_REQUIREd in AM_DEPENDENCIES
|
|
|
|
AC_DEFUN([AM_SET_DEPDIR],[
|
|
if test -d .deps || mkdir .deps 2> /dev/null || test -d .deps; then
|
|
DEPDIR=.deps
|
|
# We redirect because .deps might already exist and be populated.
|
|
# In this situation we don't want to see an error.
|
|
rmdir .deps > /dev/null 2>&1
|
|
else
|
|
DEPDIR=_deps
|
|
fi
|
|
AC_SUBST(DEPDIR)
|
|
])
|
|
|
|
AC_DEFUN([AM_DEP_TRACK],[
|
|
AC_ARG_ENABLE(dependency-tracking,
|
|
[ --disable-dependency-tracking Speeds up one-time builds
|
|
--enable-dependency-tracking Do not reject slow dependency extractors])
|
|
if test "x$enable_dependency_tracking" = xno; then
|
|
AMDEP="#"
|
|
else
|
|
am_depcomp="$ac_aux_dir/depcomp"
|
|
if test ! -f "$am_depcomp"; then
|
|
AMDEP="#"
|
|
else
|
|
AMDEP=
|
|
fi
|
|
fi
|
|
AC_SUBST(AMDEP)
|
|
if test -z "$AMDEP"; then
|
|
AMDEPBACKSLASH='\'
|
|
else
|
|
AMDEPBACKSLASH=
|
|
fi
|
|
pushdef([subst], defn([AC_SUBST]))
|
|
subst(AMDEPBACKSLASH)
|
|
popdef([subst])
|
|
])
|
|
|
|
# Generate code to set up dependency tracking.
|
|
# This macro should only be invoked once -- use via AC_REQUIRE.
|
|
# Usage:
|
|
# AM_OUTPUT_DEPENDENCY_COMMANDS
|
|
|
|
#
|
|
# This code is only required when automatic dependency tracking
|
|
# is enabled. FIXME. This creates each `.P' file that we will
|
|
# need in order to bootstrap the dependency handling code.
|
|
AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],[
|
|
AC_OUTPUT_COMMANDS([
|
|
test x"$AMDEP" != x"" ||
|
|
for mf in $CONFIG_FILES; do
|
|
case "$mf" in
|
|
Makefile) dirpart=.;;
|
|
*/Makefile) dirpart=`echo "$mf" | sed -e 's|/[^/]*$||'`;;
|
|
*) continue;;
|
|
esac
|
|
grep '^DEP_FILES *= *[^ #]' < "$mf" > /dev/null || continue
|
|
# Extract the definition of DEP_FILES from the Makefile without
|
|
# running `make'.
|
|
DEPDIR=`sed -n -e '/^DEPDIR = / s///p' < "$mf"`
|
|
test -z "$DEPDIR" && continue
|
|
# When using ansi2knr, U may be empty or an underscore; expand it
|
|
U=`sed -n -e '/^U = / s///p' < "$mf"`
|
|
test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR"
|
|
# We invoke sed twice because it is the simplest approach to
|
|
# changing $(DEPDIR) to its actual value in the expansion.
|
|
for file in `sed -n -e '
|
|
/^DEP_FILES = .*\\\\$/ {
|
|
s/^DEP_FILES = //
|
|
:loop
|
|
s/\\\\$//
|
|
p
|
|
n
|
|
/\\\\$/ b loop
|
|
p
|
|
}
|
|
/^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \
|
|
sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do
|
|
# Make sure the directory exists.
|
|
test -f "$dirpart/$file" && continue
|
|
fdir=`echo "$file" | sed -e 's|/[^/]*$||'`
|
|
$ac_aux_dir/mkinstalldirs "$dirpart/$fdir" > /dev/null 2>&1
|
|
# echo "creating $dirpart/$file"
|
|
echo '# dummy' > "$dirpart/$file"
|
|
done
|
|
done
|
|
], [AMDEP="$AMDEP"
|
|
ac_aux_dir="$ac_aux_dir"])])
|
|
|
|
|
|
# AM_PROG_LEX
|
|
# Look for flex, lex or missing, then run AC_PROG_LEX and AC_DECL_YYTEXT
|
|
AC_DEFUN([AM_PROG_LEX],
|
|
[AC_REQUIRE([AM_MISSING_HAS_RUN])
|
|
AC_CHECK_PROGS(LEX, flex lex, [${am_missing_run}flex])
|
|
AC_PROG_LEX
|
|
AC_DECL_YYTEXT])
|
|
|
|
dnl $Id: krb-prog-ln-s.m4,v 1.1 1997/12/14 15:59:01 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Better test for ln -s, ln or cp
|
|
dnl
|
|
|
|
AC_DEFUN(AC_KRB_PROG_LN_S,
|
|
[AC_MSG_CHECKING(for ln -s or something else)
|
|
AC_CACHE_VAL(ac_cv_prog_LN_S,
|
|
[rm -f conftestdata
|
|
if ln -s X conftestdata 2>/dev/null
|
|
then
|
|
rm -f conftestdata
|
|
ac_cv_prog_LN_S="ln -s"
|
|
else
|
|
touch conftestdata1
|
|
if ln conftestdata1 conftestdata2; then
|
|
rm -f conftestdata*
|
|
ac_cv_prog_LN_S=ln
|
|
else
|
|
ac_cv_prog_LN_S=cp
|
|
fi
|
|
fi])dnl
|
|
LN_S="$ac_cv_prog_LN_S"
|
|
AC_MSG_RESULT($ac_cv_prog_LN_S)
|
|
AC_SUBST(LN_S)dnl
|
|
])
|
|
|
|
|
|
dnl $Id: mips-abi.m4,v 1.5 2000/07/18 15:01:42 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Check for MIPS/IRIX ABI flags. Sets $abi and $abilibdirext to some
|
|
dnl value.
|
|
|
|
AC_DEFUN(AC_MIPS_ABI, [
|
|
AC_ARG_WITH(mips_abi,
|
|
[ --with-mips-abi=abi ABI to use for IRIX (32, n32, or 64)])
|
|
|
|
case "$host_os" in
|
|
irix*)
|
|
with_mips_abi="${with_mips_abi:-yes}"
|
|
if test -n "$GCC"; then
|
|
|
|
# GCC < 2.8 only supports the O32 ABI. GCC >= 2.8 has a flag to select
|
|
# which ABI to use, but only supports (as of 2.8.1) the N32 and 64 ABIs.
|
|
#
|
|
# Default to N32, but if GCC doesn't grok -mabi=n32, we assume an old
|
|
# GCC and revert back to O32. The same goes if O32 is asked for - old
|
|
# GCCs doesn't like the -mabi option, and new GCCs can't output O32.
|
|
#
|
|
# Don't you just love *all* the different SGI ABIs?
|
|
|
|
case "${with_mips_abi}" in
|
|
32|o32) abi='-mabi=32'; abilibdirext='' ;;
|
|
n32|yes) abi='-mabi=n32'; abilibdirext='32' ;;
|
|
64) abi='-mabi=64'; abilibdirext='64' ;;
|
|
no) abi=''; abilibdirext='';;
|
|
*) AC_MSG_ERROR("Invalid ABI specified") ;;
|
|
esac
|
|
if test -n "$abi" ; then
|
|
ac_foo=krb_cv_gcc_`echo $abi | tr =- __`
|
|
dnl
|
|
dnl can't use AC_CACHE_CHECK here, since it doesn't quote CACHE-ID to
|
|
dnl AC_MSG_RESULT
|
|
dnl
|
|
AC_MSG_CHECKING([if $CC supports the $abi option])
|
|
AC_CACHE_VAL($ac_foo, [
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $abi"
|
|
AC_TRY_COMPILE(,int x;, eval $ac_foo=yes, eval $ac_foo=no)
|
|
CFLAGS="$save_CFLAGS"
|
|
])
|
|
ac_res=`eval echo \\\$$ac_foo`
|
|
AC_MSG_RESULT($ac_res)
|
|
if test $ac_res = no; then
|
|
# Try to figure out why that failed...
|
|
case $abi in
|
|
-mabi=32)
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -mabi=n32"
|
|
AC_TRY_COMPILE(,int x;, ac_res=yes, ac_res=no)
|
|
CLAGS="$save_CFLAGS"
|
|
if test $ac_res = yes; then
|
|
# New GCC
|
|
AC_MSG_ERROR([$CC does not support the $with_mips_abi ABI])
|
|
fi
|
|
# Old GCC
|
|
abi=''
|
|
abilibdirext=''
|
|
;;
|
|
-mabi=n32|-mabi=64)
|
|
if test $with_mips_abi = yes; then
|
|
# Old GCC, default to O32
|
|
abi=''
|
|
abilibdirext=''
|
|
else
|
|
# Some broken GCC
|
|
AC_MSG_ERROR([$CC does not support the $with_mips_abi ABI])
|
|
fi
|
|
;;
|
|
esac
|
|
fi #if test $ac_res = no; then
|
|
fi #if test -n "$abi" ; then
|
|
else
|
|
case "${with_mips_abi}" in
|
|
32|o32) abi='-32'; abilibdirext='' ;;
|
|
n32|yes) abi='-n32'; abilibdirext='32' ;;
|
|
64) abi='-64'; abilibdirext='64' ;;
|
|
no) abi=''; abilibdirext='';;
|
|
*) AC_MSG_ERROR("Invalid ABI specified") ;;
|
|
esac
|
|
fi #if test -n "$GCC"; then
|
|
;;
|
|
esac
|
|
])
|
|
|
|
dnl
|
|
dnl $Id: c-attribute.m4,v 1.2 1999/03/01 09:52:23 joda Exp $
|
|
dnl
|
|
|
|
dnl
|
|
dnl Test for __attribute__
|
|
dnl
|
|
|
|
AC_DEFUN(AC_C___ATTRIBUTE__, [
|
|
AC_MSG_CHECKING(for __attribute__)
|
|
AC_CACHE_VAL(ac_cv___attribute__, [
|
|
AC_TRY_COMPILE([
|
|
#include <stdlib.h>
|
|
],
|
|
[
|
|
static void foo(void) __attribute__ ((noreturn));
|
|
|
|
static void
|
|
foo(void)
|
|
{
|
|
exit(1);
|
|
}
|
|
],
|
|
ac_cv___attribute__=yes,
|
|
ac_cv___attribute__=no)])
|
|
if test "$ac_cv___attribute__" = "yes"; then
|
|
AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])
|
|
fi
|
|
AC_MSG_RESULT($ac_cv___attribute__)
|
|
])
|
|
|
|
|
|
|
|
# serial 44 AC_PROG_LIBTOOL
|
|
AC_DEFUN(AC_PROG_LIBTOOL,[AC_REQUIRE([_AC_PROG_LIBTOOL])])
|
|
AC_DEFUN(_AC_PROG_LIBTOOL,
|
|
[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl
|
|
|
|
# Save cache, so that ltconfig can load it
|
|
AC_CACHE_SAVE
|
|
|
|
# Actually configure libtool. ac_aux_dir is where install-sh is found.
|
|
AR="$AR" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
|
|
MAGIC="$MAGIC" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
|
|
LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
|
|
AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
|
|
objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
|
|
deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
|
|
${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
|
|
$libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
|
|
|| AC_MSG_ERROR([libtool configure failed])
|
|
|
|
# Reload cache, that may have been modified by ltconfig
|
|
AC_CACHE_LOAD
|
|
|
|
# This can be used to rebuild libtool when needed
|
|
LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh"
|
|
|
|
# Always use our own libtool.
|
|
LIBTOOL='$(SHELL) $(top_builddir)/libtool'
|
|
AC_SUBST(LIBTOOL)dnl
|
|
|
|
# Redirect the config.log output again, so that the ltconfig log is not
|
|
# clobbered by the next message.
|
|
exec 5>>./config.log
|
|
])
|
|
|
|
AC_DEFUN(AC_LIBTOOL_SETUP,
|
|
[AC_PREREQ(2.13)dnl
|
|
AC_REQUIRE([AC_ENABLE_SHARED])dnl
|
|
AC_REQUIRE([AC_ENABLE_STATIC])dnl
|
|
AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl
|
|
AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
|
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
|
|
AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_PROG_LD])dnl
|
|
AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl
|
|
AC_REQUIRE([AC_PROG_NM])dnl
|
|
AC_REQUIRE([AC_PROG_LN_S])dnl
|
|
AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl
|
|
AC_REQUIRE([AC_OBJEXT])dnl
|
|
AC_REQUIRE([AC_EXEEXT])dnl
|
|
dnl
|
|
|
|
# Only perform the check for file, if the check method requires it
|
|
case "$deplibs_check_method" in
|
|
file_magic*)
|
|
if test "$file_magic_cmd" = '${MAGIC}'; then
|
|
AC_PATH_MAGIC
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
AC_CHECK_TOOL(RANLIB, ranlib, :)
|
|
AC_CHECK_TOOL(STRIP, strip, :)
|
|
|
|
# Check for any special flags to pass to ltconfig.
|
|
libtool_flags="--cache-file=$cache_file"
|
|
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
|
|
test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
|
|
test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
|
|
test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
|
|
test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
|
|
ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN],
|
|
[libtool_flags="$libtool_flags --enable-dlopen"])
|
|
ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],
|
|
[libtool_flags="$libtool_flags --enable-win32-dll"])
|
|
AC_ARG_ENABLE(libtool-lock,
|
|
[ --disable-libtool-lock avoid locking (might break parallel builds)])
|
|
test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
|
|
test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
|
|
|
|
AC_ARG_WITH(pic,
|
|
[ --with-pic try to use only PIC/non-PIC objects [default=use both]],
|
|
pic_mode="$withval", pic_mode=default)
|
|
test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
|
|
test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
|
|
|
|
# Some flags need to be propagated to the compiler or linker for good
|
|
# libtool support.
|
|
case "$host" in
|
|
*-*-irix6*)
|
|
# Find out which ABI we are using.
|
|
echo '[#]line __oline__ "configure"' > conftest.$ac_ext
|
|
if AC_TRY_EVAL(ac_compile); then
|
|
case "`/usr/bin/file conftest.o`" in
|
|
*32-bit*)
|
|
LD="${LD-ld} -32"
|
|
;;
|
|
*N32*)
|
|
LD="${LD-ld} -n32"
|
|
;;
|
|
*64-bit*)
|
|
LD="${LD-ld} -64"
|
|
;;
|
|
esac
|
|
fi
|
|
rm -rf conftest*
|
|
;;
|
|
|
|
*-*-sco3.2v5*)
|
|
# On SCO OpenServer 5, we need -belf to get full-featured binaries.
|
|
SAVE_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -belf"
|
|
AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
|
|
[AC_LANG_SAVE
|
|
AC_LANG_C
|
|
AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
|
|
AC_LANG_RESTORE])
|
|
if test x"$lt_cv_cc_needs_belf" != x"yes"; then
|
|
# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
|
|
CFLAGS="$SAVE_CFLAGS"
|
|
fi
|
|
;;
|
|
|
|
ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],
|
|
[*-*-cygwin* | *-*-mingw*)
|
|
AC_CHECK_TOOL(DLLTOOL, dlltool, false)
|
|
AC_CHECK_TOOL(AS, as, false)
|
|
AC_CHECK_TOOL(OBJDUMP, objdump, false)
|
|
|
|
# recent cygwin and mingw systems supply a stub DllMain which the user
|
|
# can override, but on older systems we have to supply one
|
|
AC_CACHE_CHECK([if libtool should supply DllMain function], lt_cv_need_dllmain,
|
|
[AC_TRY_LINK([],
|
|
[extern int __attribute__((__stdcall__)) DllMain(void*, int, void*);
|
|
DllMain (0, 0, 0);],
|
|
[lt_cv_need_dllmain=no],[lt_cv_need_dllmain=yes])])
|
|
|
|
case "$host/$CC" in
|
|
*-*-cygwin*/gcc*-mno-cygwin*|*-*-mingw*)
|
|
# old mingw systems require "-dll" to link a DLL, while more recent ones
|
|
# require "-mdll"
|
|
SAVE_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS -mdll"
|
|
AC_CACHE_CHECK([how to link DLLs], lt_cv_cc_dll_switch,
|
|
[AC_TRY_LINK([], [], [lt_cv_cc_dll_switch=-mdll],[lt_cv_cc_dll_switch=-dll])])
|
|
CFLAGS="$SAVE_CFLAGS" ;;
|
|
*-*-cygwin*)
|
|
# cygwin systems need to pass --dll to the linker, and not link
|
|
# crt.o which will require a WinMain@16 definition.
|
|
lt_cv_cc_dll_switch="-Wl,--dll -nostartfiles" ;;
|
|
esac
|
|
;;
|
|
])
|
|
esac
|
|
])
|
|
|
|
# AC_LIBTOOL_DLOPEN - enable checks for dlopen support
|
|
AC_DEFUN(AC_LIBTOOL_DLOPEN, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])])
|
|
|
|
# AC_LIBTOOL_WIN32_DLL - declare package support for building win32 dll's
|
|
AC_DEFUN(AC_LIBTOOL_WIN32_DLL, [AC_BEFORE([$0], [AC_LIBTOOL_SETUP])])
|
|
|
|
# AC_ENABLE_SHARED - implement the --enable-shared flag
|
|
# Usage: AC_ENABLE_SHARED[(DEFAULT)]
|
|
# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to
|
|
# `yes'.
|
|
AC_DEFUN(AC_ENABLE_SHARED, [dnl
|
|
define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl
|
|
AC_ARG_ENABLE(shared,
|
|
changequote(<<, >>)dnl
|
|
<< --enable-shared[=PKGS] build shared libraries [default=>>AC_ENABLE_SHARED_DEFAULT],
|
|
changequote([, ])dnl
|
|
[p=${PACKAGE-default}
|
|
case "$enableval" in
|
|
yes) enable_shared=yes ;;
|
|
no) enable_shared=no ;;
|
|
*)
|
|
enable_shared=no
|
|
# Look at the argument we got. We use all the common list separators.
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
|
|
for pkg in $enableval; do
|
|
if test "X$pkg" = "X$p"; then
|
|
enable_shared=yes
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
;;
|
|
esac],
|
|
enable_shared=AC_ENABLE_SHARED_DEFAULT)dnl
|
|
])
|
|
|
|
# AC_DISABLE_SHARED - set the default shared flag to --disable-shared
|
|
AC_DEFUN(AC_DISABLE_SHARED, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_ENABLE_SHARED(no)])
|
|
|
|
# AC_ENABLE_STATIC - implement the --enable-static flag
|
|
# Usage: AC_ENABLE_STATIC[(DEFAULT)]
|
|
# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to
|
|
# `yes'.
|
|
AC_DEFUN(AC_ENABLE_STATIC, [dnl
|
|
define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl
|
|
AC_ARG_ENABLE(static,
|
|
changequote(<<, >>)dnl
|
|
<< --enable-static[=PKGS] build static libraries [default=>>AC_ENABLE_STATIC_DEFAULT],
|
|
changequote([, ])dnl
|
|
[p=${PACKAGE-default}
|
|
case "$enableval" in
|
|
yes) enable_static=yes ;;
|
|
no) enable_static=no ;;
|
|
*)
|
|
enable_static=no
|
|
# Look at the argument we got. We use all the common list separators.
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
|
|
for pkg in $enableval; do
|
|
if test "X$pkg" = "X$p"; then
|
|
enable_static=yes
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
;;
|
|
esac],
|
|
enable_static=AC_ENABLE_STATIC_DEFAULT)dnl
|
|
])
|
|
|
|
# AC_DISABLE_STATIC - set the default static flag to --disable-static
|
|
AC_DEFUN(AC_DISABLE_STATIC, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_ENABLE_STATIC(no)])
|
|
|
|
|
|
# AC_ENABLE_FAST_INSTALL - implement the --enable-fast-install flag
|
|
# Usage: AC_ENABLE_FAST_INSTALL[(DEFAULT)]
|
|
# Where DEFAULT is either `yes' or `no'. If omitted, it defaults to
|
|
# `yes'.
|
|
AC_DEFUN(AC_ENABLE_FAST_INSTALL, [dnl
|
|
define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl
|
|
AC_ARG_ENABLE(fast-install,
|
|
changequote(<<, >>)dnl
|
|
<< --enable-fast-install[=PKGS] optimize for fast installation [default=>>AC_ENABLE_FAST_INSTALL_DEFAULT],
|
|
changequote([, ])dnl
|
|
[p=${PACKAGE-default}
|
|
case "$enableval" in
|
|
yes) enable_fast_install=yes ;;
|
|
no) enable_fast_install=no ;;
|
|
*)
|
|
enable_fast_install=no
|
|
# Look at the argument we got. We use all the common list separators.
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
|
|
for pkg in $enableval; do
|
|
if test "X$pkg" = "X$p"; then
|
|
enable_fast_install=yes
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
;;
|
|
esac],
|
|
enable_fast_install=AC_ENABLE_FAST_INSTALL_DEFAULT)dnl
|
|
])
|
|
|
|
# AC_DISABLE_FAST_INSTALL - set the default to --disable-fast-install
|
|
AC_DEFUN(AC_DISABLE_FAST_INSTALL, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_ENABLE_FAST_INSTALL(no)])
|
|
|
|
# AC_LIBTOOL_PICMODE - implement the --with-pic flag
|
|
# Usage: AC_LIBTOOL_PICMODE[(MODE)]
|
|
# Where MODE is either `yes' or `no'. If omitted, it defaults to
|
|
# `both'.
|
|
AC_DEFUN(AC_LIBTOOL_PICMODE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
pic_mode=ifelse($#,1,$1,default)])
|
|
|
|
|
|
# AC_PATH_TOOL_PREFIX - find a file program which can recognise shared library
|
|
AC_DEFUN(AC_PATH_TOOL_PREFIX,
|
|
[AC_MSG_CHECKING([for $1])
|
|
AC_CACHE_VAL(lt_cv_path_MAGIC,
|
|
[case "$MAGIC" in
|
|
/*)
|
|
lt_cv_path_MAGIC="$MAGIC" # Let the user override the test with a path.
|
|
;;
|
|
?:/*)
|
|
ac_cv_path_MAGIC="$MAGIC" # Let the user override the test with a dos path.
|
|
;;
|
|
*)
|
|
ac_save_MAGIC="$MAGIC"
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":"
|
|
dnl $ac_dummy forces splitting on constant user-supplied paths.
|
|
dnl POSIX.2 word splitting is done only on the output of word expansions,
|
|
dnl not every word. This closes a longstanding sh security hole.
|
|
ac_dummy="ifelse([$2], , $PATH, [$2])"
|
|
for ac_dir in $ac_dummy; do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f $ac_dir/$1; then
|
|
lt_cv_path_MAGIC="$ac_dir/$1"
|
|
if test -n "$file_magic_test_file"; then
|
|
case "$deplibs_check_method" in
|
|
"file_magic "*)
|
|
file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
|
|
MAGIC="$lt_cv_path_MAGIC"
|
|
if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
|
|
egrep "$file_magic_regex" > /dev/null; then
|
|
:
|
|
else
|
|
cat <<EOF 1>&2
|
|
|
|
*** Warning: the command libtool uses to detect shared libraries,
|
|
*** $file_magic_cmd, produces output that libtool cannot recognize.
|
|
*** The result is that libtool may fail to recognize shared libraries
|
|
*** as such. This will affect the creation of libtool libraries that
|
|
*** depend on shared libraries, but programs linked with such libtool
|
|
*** libraries will work regardless of this problem. Nevertheless, you
|
|
*** may want to report the problem to your system manager and/or to
|
|
*** bug-libtool@gnu.org
|
|
|
|
EOF
|
|
fi ;;
|
|
esac
|
|
fi
|
|
break
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
MAGIC="$ac_save_MAGIC"
|
|
;;
|
|
esac])
|
|
MAGIC="$lt_cv_path_MAGIC"
|
|
if test -n "$MAGIC"; then
|
|
AC_MSG_RESULT($MAGIC)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
])
|
|
|
|
|
|
# AC_PATH_MAGIC - find a file program which can recognise a shared library
|
|
AC_DEFUN(AC_PATH_MAGIC,
|
|
[AC_REQUIRE([AC_CHECK_TOOL_PREFIX])dnl
|
|
AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin:$PATH)
|
|
if test -z "$lt_cv_path_MAGIC"; then
|
|
if test -n "$ac_tool_prefix"; then
|
|
AC_PATH_TOOL_PREFIX(file, /usr/bin:$PATH)
|
|
else
|
|
MAGIC=:
|
|
fi
|
|
fi
|
|
])
|
|
|
|
|
|
# AC_PROG_LD - find the path to the GNU or non-GNU linker
|
|
AC_DEFUN(AC_PROG_LD,
|
|
[AC_ARG_WITH(gnu-ld,
|
|
[ --with-gnu-ld assume the C compiler uses GNU ld [default=no]],
|
|
test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
|
|
AC_REQUIRE([AC_PROG_CC])dnl
|
|
AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
|
AC_REQUIRE([AC_CANONICAL_BUILD])dnl
|
|
ac_prog=ld
|
|
if test "$ac_cv_prog_gcc" = yes; then
|
|
# Check if gcc -print-prog-name=ld gives a path.
|
|
AC_MSG_CHECKING([for ld used by GCC])
|
|
case $host in
|
|
*-*-mingw*)
|
|
# gcc leaves a trailing carriage return which upsets mingw
|
|
ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
|
|
*)
|
|
ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
|
|
esac
|
|
case "$ac_prog" in
|
|
# Accept absolute paths.
|
|
changequote(,)dnl
|
|
[\\/]* | [A-Za-z]:[\\/]*)
|
|
re_direlt='/[^/][^/]*/\.\./'
|
|
changequote([,])dnl
|
|
# Canonicalize the path of ld
|
|
ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
|
|
while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
|
|
ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
|
|
done
|
|
test -z "$LD" && LD="$ac_prog"
|
|
;;
|
|
"")
|
|
# If it fails, then pretend we aren't using GCC.
|
|
ac_prog=ld
|
|
;;
|
|
*)
|
|
# If it is relative, then search for the first ld in PATH.
|
|
with_gnu_ld=unknown
|
|
;;
|
|
esac
|
|
elif test "$with_gnu_ld" = yes; then
|
|
AC_MSG_CHECKING([for GNU ld])
|
|
else
|
|
AC_MSG_CHECKING([for non-GNU ld])
|
|
fi
|
|
AC_CACHE_VAL(ac_cv_path_LD,
|
|
[if test -z "$LD"; then
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
|
|
for ac_dir in $PATH; do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
|
|
ac_cv_path_LD="$ac_dir/$ac_prog"
|
|
# Check to see if the program is GNU ld. I'd rather use --version,
|
|
# but apparently some GNU ld's only accept -v.
|
|
# Break only if it was the GNU/non-GNU ld that we prefer.
|
|
if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
|
|
test "$with_gnu_ld" != no && break
|
|
else
|
|
test "$with_gnu_ld" != yes && break
|
|
fi
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
else
|
|
ac_cv_path_LD="$LD" # Let the user override the test with a path.
|
|
fi])
|
|
LD="$ac_cv_path_LD"
|
|
if test -n "$LD"; then
|
|
AC_MSG_RESULT($LD)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
|
|
AC_PROG_LD_GNU
|
|
])
|
|
|
|
AC_DEFUN(AC_PROG_LD_GNU,
|
|
[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], ac_cv_prog_gnu_ld,
|
|
[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
|
|
if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
|
|
ac_cv_prog_gnu_ld=yes
|
|
else
|
|
ac_cv_prog_gnu_ld=no
|
|
fi])
|
|
with_gnu_ld=$ac_cv_prog_gnu_ld
|
|
])
|
|
|
|
# AC_PROG_LD_RELOAD_FLAG - find reload flag for linker
|
|
# -- PORTME Some linkers may need a different reload flag.
|
|
AC_DEFUN(AC_PROG_LD_RELOAD_FLAG,
|
|
[AC_CACHE_CHECK([for $LD option to reload object files], lt_cv_ld_reload_flag,
|
|
[lt_cv_ld_reload_flag='-r'])
|
|
reload_flag=$lt_cv_ld_reload_flag
|
|
test -n "$reload_flag" && reload_flag=" $reload_flag"
|
|
])
|
|
|
|
# AC_DEPLIBS_CHECK_METHOD - how to check for library dependencies
|
|
# -- PORTME fill in with the dynamic library characteristics
|
|
AC_DEFUN(AC_DEPLIBS_CHECK_METHOD,
|
|
[AC_CACHE_CHECK([how to recognise dependant libraries],
|
|
lt_cv_deplibs_check_method,
|
|
[lt_cv_file_magic_cmd='${MAGIC}'
|
|
lt_cv_file_magic_test_file=
|
|
lt_cv_deplibs_check_method='unknown'
|
|
# Need to set the preceding variable on all platforms that support
|
|
# interlibrary dependencies.
|
|
# 'none' -- dependencies not supported.
|
|
# `unknown' -- same as none, but documents that we really don't know.
|
|
# 'pass_all' -- all dependencies passed with no checks.
|
|
# 'test_compile' -- check by making test program.
|
|
# 'file_magic [regex]' -- check by looking for files in library path
|
|
# which responds to the $file_magic_cmd with a given egrep regex.
|
|
# If you have `file' or equivalent on your system and you're not sure
|
|
# whether `pass_all' will *always* work, you probably want this one.
|
|
|
|
case "$host_os" in
|
|
aix4*)
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
|
|
beos*)
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
|
|
bsdi4*)
|
|
changequote(,)dnl
|
|
lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
|
|
changequote([, ])dnl
|
|
lt_cv_file_magic_cmd='/usr/bin/file -L'
|
|
lt_cv_file_magic_test_file=/shlib/libc.so
|
|
;;
|
|
|
|
cygwin* | mingw*)
|
|
lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
|
|
lt_cv_file_magic_cmd='${OBJDUMP} -f'
|
|
;;
|
|
|
|
freebsd*)
|
|
if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
|
|
case "$host_cpu" in
|
|
i*86 )
|
|
changequote(,)dnl
|
|
lt_cv_deplibs_check_method=='file_magic OpenBSD/i[3-9]86 demand paged shared library'
|
|
changequote([, ])dnl
|
|
lt_cv_file_magic_cmd=/usr/bin/file
|
|
lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
|
|
;;
|
|
esac
|
|
else
|
|
lt_cv_deplibs_check_method=pass_all
|
|
fi
|
|
;;
|
|
|
|
gnu*)
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
|
|
hpux10.20*)
|
|
# TODO: Does this work for hpux-11 too?
|
|
lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
|
|
lt_cv_file_magic_cmd=/usr/bin/file
|
|
lt_cv_file_magic_test_file=/usr/lib/libc.sl
|
|
;;
|
|
|
|
irix5* | irix6*)
|
|
case "$host_os" in
|
|
irix5*)
|
|
# this will be overridden with pass_all, but let us keep it just in case
|
|
lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
|
|
;;
|
|
*)
|
|
case "$LD" in
|
|
*-32|*"-32 ") libmagic=32-bit;;
|
|
*-n32|*"-n32 ") libmagic=N32;;
|
|
*-64|*"-64 ") libmagic=64-bit;;
|
|
*) libmagic=never-match;;
|
|
esac
|
|
# this will be overridden with pass_all, but let us keep it just in case
|
|
changequote(,)dnl
|
|
lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
|
|
changequote([, ])dnl
|
|
;;
|
|
esac
|
|
lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
|
|
# This must be Linux ELF.
|
|
linux-gnu*)
|
|
case "$host_cpu" in
|
|
alpha* | i*86 | powerpc* | sparc* | ia64* )
|
|
lt_cv_deplibs_check_method=pass_all ;;
|
|
*)
|
|
# glibc up to 2.1.1 does not perform some relocations on ARM
|
|
changequote(,)dnl
|
|
lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;
|
|
changequote([, ])dnl
|
|
esac
|
|
lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
|
|
;;
|
|
|
|
netbsd*)
|
|
if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then :
|
|
else
|
|
changequote(,)dnl
|
|
lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
|
|
changequote([, ])dnl
|
|
lt_cv_file_magic_cmd='/usr/bin/file -L'
|
|
lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
|
|
fi
|
|
;;
|
|
|
|
osf3* | osf4* | osf5*)
|
|
# this will be overridden with pass_all, but let us keep it just in case
|
|
lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
|
|
lt_cv_file_magic_test_file=/shlib/libc.so
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
|
|
sco3.2v5*)
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
|
|
solaris*)
|
|
lt_cv_deplibs_check_method=pass_all
|
|
lt_cv_file_magic_test_file=/lib/libc.so
|
|
;;
|
|
|
|
sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
|
|
case "$host_vendor" in
|
|
ncr)
|
|
lt_cv_deplibs_check_method=pass_all
|
|
;;
|
|
motorola)
|
|
changequote(,)dnl
|
|
lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
|
|
changequote([, ])dnl
|
|
lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
])
|
|
file_magic_cmd=$lt_cv_file_magic_cmd
|
|
deplibs_check_method=$lt_cv_deplibs_check_method
|
|
])
|
|
|
|
|
|
# AC_PROG_NM - find the path to a BSD-compatible name lister
|
|
AC_DEFUN(AC_PROG_NM,
|
|
[AC_MSG_CHECKING([for BSD-compatible nm])
|
|
AC_CACHE_VAL(ac_cv_path_NM,
|
|
[if test -n "$NM"; then
|
|
# Let the user override the test.
|
|
ac_cv_path_NM="$NM"
|
|
else
|
|
IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
|
|
for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
|
|
test -z "$ac_dir" && ac_dir=.
|
|
tmp_nm=$ac_dir/${ac_tool_prefix}nm
|
|
if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
|
|
# Check to see if the nm accepts a BSD-compat flag.
|
|
# Adding the `sed 1q' prevents false positives on HP-UX, which says:
|
|
# nm: unknown option "B" ignored
|
|
if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
|
|
ac_cv_path_NM="$tmp_nm -B"
|
|
break
|
|
elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
|
|
ac_cv_path_NM="$tmp_nm -p"
|
|
break
|
|
else
|
|
ac_cv_path_NM=${ac_cv_path_NM="$tmp_nm"} # keep the first match, but
|
|
continue # so that we can try to find one that supports BSD flags
|
|
fi
|
|
fi
|
|
done
|
|
IFS="$ac_save_ifs"
|
|
test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
|
|
fi])
|
|
NM="$ac_cv_path_NM"
|
|
AC_MSG_RESULT([$NM])
|
|
])
|
|
|
|
# AC_CHECK_LIBM - check for math library
|
|
AC_DEFUN(AC_CHECK_LIBM,
|
|
[AC_REQUIRE([AC_CANONICAL_HOST])dnl
|
|
LIBM=
|
|
case "$host" in
|
|
*-*-beos* | *-*-cygwin*)
|
|
# These system don't have libm
|
|
;;
|
|
*-ncr-sysv4.3*)
|
|
AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
|
|
AC_CHECK_LIB(m, main, LIBM="$LIBM -lm")
|
|
;;
|
|
*)
|
|
AC_CHECK_LIB(m, main, LIBM="-lm")
|
|
;;
|
|
esac
|
|
])
|
|
|
|
# AC_LIBLTDL_CONVENIENCE[(dir)] - sets LIBLTDL to the link flags for
|
|
# the libltdl convenience library and INCLTDL to the include flags for
|
|
# the libltdl header and adds --enable-ltdl-convenience to the
|
|
# configure arguments. Note that LIBLTDL and INCLTDL are not
|
|
# AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If DIR is not
|
|
# provided, it is assumed to be `libltdl'. LIBLTDL will be prefixed
|
|
# with '${top_builddir}/' and INCLTDL will be prefixed with
|
|
# '${top_srcdir}/' (note the single quotes!). If your package is not
|
|
# flat and you're not using automake, define top_builddir and
|
|
# top_srcdir appropriately in the Makefiles.
|
|
AC_DEFUN(AC_LIBLTDL_CONVENIENCE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
case "$enable_ltdl_convenience" in
|
|
no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
|
|
"") enable_ltdl_convenience=yes
|
|
ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
|
|
esac
|
|
LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la
|
|
INCLTDL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
|
|
])
|
|
|
|
# AC_LIBLTDL_INSTALLABLE[(dir)] - sets LIBLTDL to the link flags for
|
|
# the libltdl installable library and INCLTDL to the include flags for
|
|
# the libltdl header and adds --enable-ltdl-install to the configure
|
|
# arguments. Note that LIBLTDL and INCLTDL are not AC_SUBSTed, nor is
|
|
# AC_CONFIG_SUBDIRS called. If DIR is not provided and an installed
|
|
# libltdl is not found, it is assumed to be `libltdl'. LIBLTDL will
|
|
# be prefixed with '${top_builddir}/' and INCLTDL will be prefixed
|
|
# with '${top_srcdir}/' (note the single quotes!). If your package is
|
|
# not flat and you're not using automake, define top_builddir and
|
|
# top_srcdir appropriately in the Makefiles.
|
|
# In the future, this macro may have to be called after AC_PROG_LIBTOOL.
|
|
AC_DEFUN(AC_LIBLTDL_INSTALLABLE, [AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
|
|
AC_CHECK_LIB(ltdl, main,
|
|
[test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],
|
|
[if test x"$enable_ltdl_install" = xno; then
|
|
AC_MSG_WARN([libltdl not installed, but installation disabled])
|
|
else
|
|
enable_ltdl_install=yes
|
|
fi
|
|
])
|
|
if test x"$enable_ltdl_install" = x"yes"; then
|
|
ac_configure_args="$ac_configure_args --enable-ltdl-install"
|
|
LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdl.la
|
|
INCLTDL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])
|
|
else
|
|
ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
|
|
LIBLTDL="-lltdl"
|
|
INCLTDL=
|
|
fi
|
|
])
|
|
|
|
dnl old names
|
|
AC_DEFUN(AM_PROG_LIBTOOL, [indir([AC_PROG_LIBTOOL])])dnl
|
|
AC_DEFUN(AM_ENABLE_SHARED, [indir([AC_ENABLE_SHARED], $@)])dnl
|
|
AC_DEFUN(AM_ENABLE_STATIC, [indir([AC_ENABLE_STATIC], $@)])dnl
|
|
AC_DEFUN(AM_DISABLE_SHARED, [indir([AC_DISABLE_SHARED], $@)])dnl
|
|
AC_DEFUN(AM_DISABLE_STATIC, [indir([AC_DISABLE_STATIC], $@)])dnl
|
|
AC_DEFUN(AM_PROG_LD, [indir([AC_PROG_LD])])dnl
|
|
AC_DEFUN(AM_PROG_NM, [indir([AC_PROG_NM])])dnl
|
|
|
|
dnl This is just to silence aclocal about the macro not being used
|
|
ifelse([AC_DISABLE_FAST_INSTALL])dnl
|
|
|
|
dnl $Id: wflags.m4,v 1.3 1999/03/11 12:11:41 joda Exp $
|
|
dnl
|
|
dnl set WFLAGS
|
|
|
|
AC_DEFUN(AC_WFLAGS,[
|
|
WFLAGS_NOUNUSED=""
|
|
WFLAGS_NOIMPLICITINT=""
|
|
if test -z "$WFLAGS" -a "$GCC" = "yes"; then
|
|
# -Wno-implicit-int for broken X11 headers
|
|
# leave these out for now:
|
|
# -Wcast-align doesn't work well on alpha osf/1
|
|
# -Wmissing-prototypes -Wpointer-arith -Wbad-function-cast
|
|
# -Wmissing-declarations -Wnested-externs
|
|
WFLAGS="ifelse($#, 0,-Wall, $1)"
|
|
WFLAGS_NOUNUSED="-Wno-unused"
|
|
WFLAGS_NOIMPLICITINT="-Wno-implicit-int"
|
|
fi
|
|
AC_SUBST(WFLAGS)dnl
|
|
AC_SUBST(WFLAGS_NOUNUSED)dnl
|
|
AC_SUBST(WFLAGS_NOIMPLICITINT)dnl
|
|
])
|
|
|
|
dnl $Id: db.m4,v 1.1 2000/07/19 11:21:07 joda Exp $
|
|
dnl
|
|
dnl tests for various db libraries
|
|
dnl
|
|
AC_DEFUN([rk_DB],[berkeley_db=db
|
|
AC_ARG_WITH(berkeley-db,
|
|
[ --without-berkeley-db if you don't want berkeley db],[
|
|
if test "$withval" = no; then
|
|
berkeley_db=""
|
|
fi
|
|
])
|
|
if test "$berkeley_db"; then
|
|
AC_CHECK_HEADERS([ \
|
|
db.h \
|
|
db_185.h \
|
|
])
|
|
fi
|
|
|
|
AC_FIND_FUNC_NO_LIBS2(dbopen, $berkeley_db, [
|
|
#include <stdio.h>
|
|
#if defined(HAVE_DB_185_H)
|
|
#include <db_185.h>
|
|
#elif defined(HAVE_DB_H)
|
|
#include <db.h>
|
|
#endif
|
|
],[NULL, 0, 0, 0, NULL])
|
|
|
|
AC_FIND_FUNC_NO_LIBS(dbm_firstkey, $berkeley_db gdbm ndbm)
|
|
AC_FIND_FUNC_NO_LIBS(db_create, $berkeley_db)
|
|
|
|
DBLIB="$LIB_dbopen"
|
|
if test "$LIB_dbopen" != "$LIB_db_create"; then
|
|
DBLIB="$DBLIB $LIB_db_create"
|
|
fi
|
|
if test "$LIB_dbopen" != "$LIB_dbm_firstkey"; then
|
|
DBLIB="$DBLIB $LIB_dbm_firstkey"
|
|
fi
|
|
AC_SUBST(DBLIB)dnl
|
|
|
|
])
|
|
|
|
dnl $Id: find-func-no-libs2.m4,v 1.4 2000/07/15 18:10:19 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Look for function in any of the specified libraries
|
|
dnl
|
|
|
|
dnl AC_FIND_FUNC_NO_LIBS2(func, libraries, includes, arguments, extra libs, extra args)
|
|
AC_DEFUN(AC_FIND_FUNC_NO_LIBS2, [
|
|
|
|
AC_MSG_CHECKING([for $1])
|
|
AC_CACHE_VAL(ac_cv_funclib_$1,
|
|
[
|
|
if eval "test \"\$ac_cv_func_$1\" != yes" ; then
|
|
ac_save_LIBS="$LIBS"
|
|
for ac_lib in $2; do
|
|
if test -n "$ac_lib"; then
|
|
ac_lib="-l$ac_lib"
|
|
else
|
|
ac_lib=""
|
|
fi
|
|
LIBS="$6 $ac_lib $5 $ac_save_LIBS"
|
|
AC_TRY_LINK([$3],[$1($4)],eval "if test -n \"$ac_lib\";then ac_cv_funclib_$1=$ac_lib; else ac_cv_funclib_$1=yes; fi";break)
|
|
done
|
|
eval "ac_cv_funclib_$1=\${ac_cv_funclib_$1-no}"
|
|
LIBS="$ac_save_LIBS"
|
|
fi
|
|
])
|
|
|
|
eval "ac_res=\$ac_cv_funclib_$1"
|
|
|
|
if false; then
|
|
AC_CHECK_FUNCS($1)
|
|
dnl AC_CHECK_LIBS($2, foo)
|
|
fi
|
|
# $1
|
|
eval "ac_tr_func=HAVE_[]upcase($1)"
|
|
eval "ac_tr_lib=HAVE_LIB[]upcase($ac_res | sed -e 's/-l//')"
|
|
eval "LIB_$1=$ac_res"
|
|
|
|
case "$ac_res" in
|
|
yes)
|
|
eval "ac_cv_func_$1=yes"
|
|
eval "LIB_$1="
|
|
AC_DEFINE_UNQUOTED($ac_tr_func)
|
|
AC_MSG_RESULT([yes])
|
|
;;
|
|
no)
|
|
eval "ac_cv_func_$1=no"
|
|
eval "LIB_$1="
|
|
AC_MSG_RESULT([no])
|
|
;;
|
|
*)
|
|
eval "ac_cv_func_$1=yes"
|
|
eval "ac_cv_lib_`echo "$ac_res" | sed 's/-l//'`=yes"
|
|
AC_DEFINE_UNQUOTED($ac_tr_func)
|
|
AC_DEFINE_UNQUOTED($ac_tr_lib)
|
|
AC_MSG_RESULT([yes, in $ac_res])
|
|
;;
|
|
esac
|
|
AC_SUBST(LIB_$1)
|
|
])
|
|
|
|
dnl $Id: find-func-no-libs.m4,v 1.5 1999/10/30 21:08:18 assar Exp $
|
|
dnl
|
|
dnl
|
|
dnl Look for function in any of the specified libraries
|
|
dnl
|
|
|
|
dnl AC_FIND_FUNC_NO_LIBS(func, libraries, includes, arguments, extra libs, extra args)
|
|
AC_DEFUN(AC_FIND_FUNC_NO_LIBS, [
|
|
AC_FIND_FUNC_NO_LIBS2([$1], ["" $2], [$3], [$4], [$5], [$6])])
|
|
|
|
dnl $Id: roken-frag.m4,v 1.21 2001/05/11 13:58:21 joda Exp $
|
|
dnl
|
|
dnl some code to get roken working
|
|
dnl
|
|
dnl rk_ROKEN(subdir)
|
|
dnl
|
|
AC_DEFUN(rk_ROKEN, [
|
|
|
|
AC_REQUIRE([rk_CONFIG_HEADER])
|
|
|
|
DIR_roken=roken
|
|
LIB_roken='$(top_builddir)/$1/libroken.la'
|
|
INCLUDES_roken='-I$(top_builddir)/$1 -I$(top_srcdir)/$1'
|
|
|
|
dnl Checks for programs
|
|
AC_REQUIRE([AC_PROG_CC])
|
|
AC_REQUIRE([AC_PROG_AWK])
|
|
AC_REQUIRE([AC_OBJEXT])
|
|
AC_REQUIRE([AC_EXEEXT])
|
|
AC_REQUIRE([AC_PROG_LIBTOOL])
|
|
|
|
AC_REQUIRE([AC_MIPS_ABI])
|
|
|
|
dnl C characteristics
|
|
|
|
AC_REQUIRE([AC_C___ATTRIBUTE__])
|
|
AC_REQUIRE([AC_C_INLINE])
|
|
AC_REQUIRE([AC_C_CONST])
|
|
AC_WFLAGS(-Wall -Wmissing-prototypes -Wpointer-arith -Wbad-function-cast -Wmissing-declarations -Wnested-externs)
|
|
|
|
AC_REQUIRE([rk_DB])
|
|
|
|
dnl C types
|
|
|
|
AC_REQUIRE([AC_TYPE_SIZE_T])
|
|
AC_CHECK_TYPE_EXTRA(ssize_t, int, [#include <unistd.h>])
|
|
AC_REQUIRE([AC_TYPE_PID_T])
|
|
AC_REQUIRE([AC_TYPE_UID_T])
|
|
AC_HAVE_TYPE([long long])
|
|
|
|
AC_REQUIRE([rk_RETSIGTYPE])
|
|
|
|
dnl Checks for header files.
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([AC_HEADER_TIME])
|
|
|
|
AC_CHECK_HEADERS([\
|
|
arpa/inet.h \
|
|
arpa/nameser.h \
|
|
config.h \
|
|
crypt.h \
|
|
dbm.h \
|
|
db.h \
|
|
dirent.h \
|
|
errno.h \
|
|
err.h \
|
|
fcntl.h \
|
|
gdbm/ndbm.h \
|
|
grp.h \
|
|
ifaddrs.h \
|
|
ndbm.h \
|
|
net/if.h \
|
|
netdb.h \
|
|
netinet/in.h \
|
|
netinet/in6.h \
|
|
netinet/in_systm.h \
|
|
netinet6/in6.h \
|
|
netinet6/in6_var.h \
|
|
paths.h \
|
|
pwd.h \
|
|
resolv.h \
|
|
rpcsvc/dbm.h \
|
|
rpcsvc/ypclnt.h \
|
|
shadow.h \
|
|
sys/bswap.h \
|
|
sys/ioctl.h \
|
|
sys/param.h \
|
|
sys/proc.h \
|
|
sys/resource.h \
|
|
sys/socket.h \
|
|
sys/sockio.h \
|
|
sys/stat.h \
|
|
sys/sysctl.h \
|
|
sys/time.h \
|
|
sys/tty.h \
|
|
sys/types.h \
|
|
sys/uio.h \
|
|
sys/utsname.h \
|
|
sys/wait.h \
|
|
syslog.h \
|
|
termios.h \
|
|
unistd.h \
|
|
userconf.h \
|
|
usersec.h \
|
|
util.h \
|
|
vis.h \
|
|
winsock.h \
|
|
])
|
|
|
|
AC_REQUIRE([CHECK_NETINET_IP_AND_TCP])
|
|
|
|
AM_CONDITIONAL(have_err_h, test "$ac_cv_header_err_h" = yes)
|
|
AM_CONDITIONAL(have_fnmatch_h, test "$ac_cv_header_fnmatch_h" = yes)
|
|
AM_CONDITIONAL(have_ifaddrs_h, test "$ac_cv_header_ifaddrs_h" = yes)
|
|
AM_CONDITIONAL(have_vis_h, test "$ac_cv_header_vis_h" = yes)
|
|
|
|
dnl Check for functions and libraries
|
|
|
|
AC_KRB_IPV6
|
|
|
|
AC_FIND_FUNC(socket, socket)
|
|
AC_FIND_FUNC(gethostbyname, nsl)
|
|
AC_FIND_FUNC(syslog, syslog)
|
|
AC_FIND_FUNC(gethostbyname2, inet6 ip6)
|
|
|
|
AC_FIND_FUNC(res_search, resolv,
|
|
[
|
|
#include <stdio.h>
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_NAMESER_H
|
|
#include <arpa/nameser.h>
|
|
#endif
|
|
#ifdef HAVE_RESOLV_H
|
|
#include <resolv.h>
|
|
#endif
|
|
],
|
|
[0,0,0,0,0])
|
|
|
|
AC_FIND_FUNC(dn_expand, resolv,
|
|
[
|
|
#include <stdio.h>
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_NAMESER_H
|
|
#include <arpa/nameser.h>
|
|
#endif
|
|
#ifdef HAVE_RESOLV_H
|
|
#include <resolv.h>
|
|
#endif
|
|
],
|
|
[0,0,0,0,0])
|
|
|
|
AC_BROKEN_SNPRINTF
|
|
AC_BROKEN_VSNPRINTF
|
|
|
|
AC_BROKEN_GLOB
|
|
if test "$ac_cv_func_glob_working" != yes; then
|
|
LIBOBJS="$LIBOBJS glob.o"
|
|
fi
|
|
AM_CONDITIONAL(have_glob_h, test "$ac_cv_func_glob_working" = yes)
|
|
|
|
|
|
AC_CHECK_FUNCS([ \
|
|
asnprintf \
|
|
asprintf \
|
|
cgetent \
|
|
getconfattr \
|
|
getprogname \
|
|
getrlimit \
|
|
getspnam \
|
|
setprogname \
|
|
strsvis \
|
|
strunvis \
|
|
strvis \
|
|
strvisx \
|
|
svis \
|
|
sysconf \
|
|
sysctl \
|
|
uname \
|
|
unvis \
|
|
vasnprintf \
|
|
vasprintf \
|
|
vis \
|
|
])
|
|
|
|
if test "$ac_cv_func_cgetent" = no; then
|
|
LIBOBJS="$LIBOBJS getcap.o"
|
|
fi
|
|
|
|
AC_REQUIRE([AC_FUNC_GETLOGIN])
|
|
|
|
AC_FIND_FUNC_NO_LIBS(getsockopt,,
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif],
|
|
[0,0,0,0,0])
|
|
AC_FIND_FUNC_NO_LIBS(setsockopt,,
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif],
|
|
[0,0,0,0,0])
|
|
|
|
AC_FIND_IF_NOT_BROKEN(hstrerror, resolv,
|
|
[#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif],
|
|
17)
|
|
if test "$ac_cv_func_hstrerror" = yes; then
|
|
AC_NEED_PROTO([
|
|
#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif],
|
|
hstrerror)
|
|
fi
|
|
|
|
dnl sigh, wish this could be done in a loop
|
|
if test "$ac_cv_func_asprintf" = yes; then
|
|
AC_NEED_PROTO([
|
|
#include <stdio.h>
|
|
#include <string.h>],
|
|
asprintf)dnl
|
|
fi
|
|
if test "$ac_cv_func_vasprintf" = yes; then
|
|
AC_NEED_PROTO([
|
|
#include <stdio.h>
|
|
#include <string.h>],
|
|
vasprintf)dnl
|
|
fi
|
|
if test "$ac_cv_func_asnprintf" = yes; then
|
|
AC_NEED_PROTO([
|
|
#include <stdio.h>
|
|
#include <string.h>],
|
|
asnprintf)dnl
|
|
fi
|
|
if test "$ac_cv_func_vasnprintf" = yes; then
|
|
AC_NEED_PROTO([
|
|
#include <stdio.h>
|
|
#include <string.h>],
|
|
vasnprintf)dnl
|
|
fi
|
|
|
|
AC_FIND_FUNC_NO_LIBS(bswap16,,
|
|
[#ifdef HAVE_SYS_BSWAP_H
|
|
#include <sys/bswap.h>
|
|
#endif],0)
|
|
|
|
AC_FIND_FUNC_NO_LIBS(bswap32,,
|
|
[#ifdef HAVE_SYS_BSWAP_H
|
|
#include <sys/bswap.h>
|
|
#endif],0)
|
|
|
|
AC_FIND_FUNC_NO_LIBS(pidfile,util,
|
|
[#ifdef HAVE_UTIL_H
|
|
#include <util.h>
|
|
#endif],0)
|
|
|
|
AC_BROKEN([ \
|
|
chown \
|
|
copyhostent \
|
|
daemon \
|
|
err \
|
|
errx \
|
|
fchown \
|
|
flock \
|
|
fnmatch \
|
|
freeaddrinfo \
|
|
freehostent \
|
|
gai_strerror \
|
|
getaddrinfo \
|
|
getcwd \
|
|
getdtablesize \
|
|
getegid \
|
|
geteuid \
|
|
getgid \
|
|
gethostname \
|
|
getifaddrs \
|
|
getipnodebyaddr \
|
|
getipnodebyname \
|
|
getnameinfo \
|
|
getopt \
|
|
gettimeofday \
|
|
getuid \
|
|
getusershell \
|
|
initgroups \
|
|
innetgr \
|
|
iruserok \
|
|
lstat \
|
|
memmove \
|
|
mkstemp \
|
|
putenv \
|
|
rcmd \
|
|
readv \
|
|
recvmsg \
|
|
sendmsg \
|
|
setegid \
|
|
setenv \
|
|
seteuid \
|
|
strcasecmp \
|
|
strdup \
|
|
strerror \
|
|
strftime \
|
|
strlcat \
|
|
strlcpy \
|
|
strlwr \
|
|
strncasecmp \
|
|
strndup \
|
|
strnlen \
|
|
strptime \
|
|
strsep \
|
|
strsep_copy \
|
|
strtok_r \
|
|
strupr \
|
|
swab \
|
|
unsetenv \
|
|
verr \
|
|
verrx \
|
|
vsyslog \
|
|
vwarn \
|
|
vwarnx \
|
|
warn \
|
|
warnx \
|
|
writev \
|
|
])
|
|
|
|
AC_BROKEN2(inet_aton,
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif],
|
|
[0,0])
|
|
|
|
AC_BROKEN2(inet_ntop,
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif],
|
|
[0, 0, 0, 0])
|
|
|
|
AC_BROKEN2(inet_pton,
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif],
|
|
[0,0,0])
|
|
|
|
dnl
|
|
dnl Check for sa_len in struct sockaddr,
|
|
dnl needs to come before the getnameinfo test
|
|
dnl
|
|
AC_HAVE_STRUCT_FIELD(struct sockaddr, sa_len, [#include <sys/types.h>
|
|
#include <sys/socket.h>])
|
|
|
|
if test "$ac_cv_func_getnameinfo" = "yes"; then
|
|
rk_BROKEN_GETNAMEINFO
|
|
if test "$ac_cv_func_getnameinfo_broken" = yes; then
|
|
LIBOBJS="$LIBOBJS getnameinfo.o"
|
|
fi
|
|
fi
|
|
|
|
AC_NEED_PROTO([#include <stdlib.h>], setenv)
|
|
AC_NEED_PROTO([#include <stdlib.h>], unsetenv)
|
|
AC_NEED_PROTO([#include <unistd.h>], gethostname)
|
|
AC_NEED_PROTO([#include <unistd.h>], mkstemp)
|
|
AC_NEED_PROTO([#include <unistd.h>], getusershell)
|
|
|
|
AC_NEED_PROTO([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif],
|
|
inet_aton)
|
|
|
|
AC_FIND_FUNC_NO_LIBS(crypt, crypt)dnl
|
|
|
|
AC_REQUIRE([rk_BROKEN_REALLOC])dnl
|
|
|
|
dnl AC_KRB_FUNC_GETCWD_BROKEN
|
|
|
|
dnl
|
|
dnl Checks for prototypes and declarations
|
|
dnl
|
|
|
|
AC_PROTO_COMPAT([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif
|
|
],
|
|
gethostbyname, struct hostent *gethostbyname(const char *))
|
|
|
|
AC_PROTO_COMPAT([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif
|
|
],
|
|
gethostbyaddr, struct hostent *gethostbyaddr(const void *, size_t, int))
|
|
|
|
AC_PROTO_COMPAT([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_ARPA_INET_H
|
|
#include <arpa/inet.h>
|
|
#endif
|
|
#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif
|
|
],
|
|
getservbyname, struct servent *getservbyname(const char *, const char *))
|
|
|
|
AC_PROTO_COMPAT([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
],
|
|
getsockname, int getsockname(int, struct sockaddr*, socklen_t*))
|
|
|
|
AC_PROTO_COMPAT([
|
|
#ifdef HAVE_SYSLOG_H
|
|
#include <syslog.h>
|
|
#endif
|
|
],
|
|
openlog, void openlog(const char *, int, int))
|
|
|
|
AC_NEED_PROTO([
|
|
#ifdef HAVE_CRYPT_H
|
|
#include <crypt.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
],
|
|
crypt)
|
|
|
|
AC_NEED_PROTO([
|
|
#include <string.h>
|
|
],
|
|
strtok_r)
|
|
|
|
AC_NEED_PROTO([
|
|
#include <string.h>
|
|
],
|
|
strsep)
|
|
|
|
dnl variables
|
|
|
|
rk_CHECK_VAR(h_errno,
|
|
[#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif])
|
|
|
|
rk_CHECK_VAR(h_errlist,
|
|
[#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif])
|
|
|
|
rk_CHECK_VAR(h_nerr,
|
|
[#ifdef HAVE_NETDB_H
|
|
#include <netdb.h>
|
|
#endif])
|
|
|
|
rk_CHECK_VAR([__progname],
|
|
[#ifdef HAVE_ERR_H
|
|
#include <err.h>
|
|
#endif])
|
|
|
|
AC_CHECK_DECLARATION([#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif], optarg)
|
|
AC_CHECK_DECLARATION([#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif], optind)
|
|
AC_CHECK_DECLARATION([#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif], opterr)
|
|
AC_CHECK_DECLARATION([#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif], optopt)
|
|
|
|
AC_CHECK_DECLARATION([#include <stdlib.h>], environ)
|
|
|
|
dnl
|
|
dnl Check for fields in struct tm
|
|
dnl
|
|
|
|
AC_HAVE_STRUCT_FIELD(struct tm, tm_gmtoff, [#include <time.h>])
|
|
AC_HAVE_STRUCT_FIELD(struct tm, tm_zone, [#include <time.h>])
|
|
|
|
dnl
|
|
dnl or do we have a variable `timezone' ?
|
|
dnl
|
|
|
|
rk_CHECK_VAR(timezone,[#include <time.h>])
|
|
|
|
AC_HAVE_TYPE([sa_family_t],[#include <sys/socket.h>])
|
|
AC_HAVE_TYPE([socklen_t],[#include <sys/socket.h>])
|
|
AC_HAVE_TYPE([struct sockaddr], [#include <sys/socket.h>])
|
|
AC_HAVE_TYPE([struct sockaddr_storage], [#include <sys/socket.h>])
|
|
AC_HAVE_TYPE([struct addrinfo], [#include <netdb.h>])
|
|
AC_HAVE_TYPE([struct ifaddrs], [#include <ifaddrs.h>])
|
|
|
|
dnl
|
|
dnl Check for struct winsize
|
|
dnl
|
|
|
|
AC_KRB_STRUCT_WINSIZE
|
|
|
|
dnl
|
|
dnl Check for struct spwd
|
|
dnl
|
|
|
|
AC_KRB_STRUCT_SPWD
|
|
|
|
dnl won't work with automake
|
|
dnl moved to AC_OUTPUT in configure.in
|
|
dnl AC_CONFIG_FILES($1/Makefile)
|
|
|
|
LIB_roken="${LIB_roken} \$(LIB_crypt) \$(LIB_dbopen)"
|
|
|
|
AC_SUBST(DIR_roken)dnl
|
|
AC_SUBST(LIB_roken)dnl
|
|
AC_SUBST(INCLUDES_roken)dnl
|
|
])
|
|
dnl $Id: check-type-extra.m4,v 1.2 1999/03/01 09:52:23 joda Exp $
|
|
dnl
|
|
dnl ac_check_type + extra headers
|
|
|
|
dnl AC_CHECK_TYPE_EXTRA(TYPE, DEFAULT, HEADERS)
|
|
AC_DEFUN(AC_CHECK_TYPE_EXTRA,
|
|
[AC_REQUIRE([AC_HEADER_STDC])dnl
|
|
AC_MSG_CHECKING(for $1)
|
|
AC_CACHE_VAL(ac_cv_type_$1,
|
|
[AC_EGREP_CPP(dnl
|
|
changequote(<<,>>)dnl
|
|
<<$1[^a-zA-Z_0-9]>>dnl
|
|
changequote([,]), [#include <sys/types.h>
|
|
#if STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#endif
|
|
$3], ac_cv_type_$1=yes, ac_cv_type_$1=no)])dnl
|
|
AC_MSG_RESULT($ac_cv_type_$1)
|
|
if test $ac_cv_type_$1 = no; then
|
|
AC_DEFINE($1, $2, [Define this to what the type $1 should be.])
|
|
fi
|
|
])
|
|
|
|
dnl $Id: have-type.m4,v 1.6 2000/07/15 18:10:00 joda Exp $
|
|
dnl
|
|
dnl check for existance of a type
|
|
|
|
dnl AC_HAVE_TYPE(TYPE,INCLUDES)
|
|
AC_DEFUN(AC_HAVE_TYPE, [
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
cv=`echo "$1" | sed 'y%./+- %__p__%'`
|
|
AC_MSG_CHECKING(for $1)
|
|
AC_CACHE_VAL([ac_cv_type_$cv],
|
|
AC_TRY_COMPILE(
|
|
[#include <sys/types.h>
|
|
#if STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#endif
|
|
$2],
|
|
[$1 foo;],
|
|
eval "ac_cv_type_$cv=yes",
|
|
eval "ac_cv_type_$cv=no"))dnl
|
|
ac_foo=`eval echo \\$ac_cv_type_$cv`
|
|
AC_MSG_RESULT($ac_foo)
|
|
if test "$ac_foo" = yes; then
|
|
ac_tr_hdr=HAVE_`echo $1 | sed 'y%abcdefghijklmnopqrstuvwxyz./- %ABCDEFGHIJKLMNOPQRSTUVWXYZ____%'`
|
|
if false; then
|
|
AC_CHECK_TYPES($1)
|
|
fi
|
|
AC_DEFINE_UNQUOTED($ac_tr_hdr, 1, [Define if you have type `$1'])
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl $Id: retsigtype.m4,v 1.1 2000/07/15 18:05:56 joda Exp $
|
|
dnl
|
|
dnl Figure out return type of signal handlers, and define SIGRETURN macro
|
|
dnl that can be used to return from one
|
|
dnl
|
|
AC_DEFUN(rk_RETSIGTYPE,[
|
|
AC_TYPE_SIGNAL
|
|
if test "$ac_cv_type_signal" = "void" ; then
|
|
AC_DEFINE(VOID_RETSIGTYPE, 1, [Define if signal handlers return void.])
|
|
fi
|
|
AC_SUBST(VOID_RETSIGTYPE)
|
|
AH_BOTTOM([#ifdef VOID_RETSIGTYPE
|
|
#define SIGRETURN(x) return
|
|
#else
|
|
#define SIGRETURN(x) return (RETSIGTYPE)(x)
|
|
#endif])
|
|
])
|
|
dnl
|
|
dnl $Id: check-netinet-ip-and-tcp.m4,v 1.3 2000/07/18 10:33:02 joda Exp $
|
|
dnl
|
|
|
|
dnl extra magic check for netinet/{ip.h,tcp.h} because on irix 6.5.3
|
|
dnl you have to include standards.h before including these files
|
|
|
|
AC_DEFUN(CHECK_NETINET_IP_AND_TCP,
|
|
[
|
|
AC_CHECK_HEADERS(standards.h)
|
|
for i in netinet/ip.h netinet/tcp.h; do
|
|
|
|
cv=`echo "$i" | sed 'y%./+-%__p_%'`
|
|
|
|
AC_CACHE_CHECK([for $i],ac_cv_header_$cv,
|
|
[AC_TRY_CPP([\
|
|
#ifdef HAVE_STANDARDS_H
|
|
#include <standards.h>
|
|
#endif
|
|
#include <$i>
|
|
],
|
|
eval "ac_cv_header_$cv=yes",
|
|
eval "ac_cv_header_$cv=no")])
|
|
ac_res=`eval echo \\$ac_cv_header_$cv`
|
|
if test "$ac_res" = yes; then
|
|
ac_tr_hdr=HAVE_`echo $i | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
|
|
AC_DEFINE_UNQUOTED($ac_tr_hdr, 1)
|
|
fi
|
|
done
|
|
if false;then
|
|
AC_CHECK_HEADERS(netinet/ip.h netinet/tcp.h)
|
|
fi
|
|
])
|
|
|
|
# Define a conditional.
|
|
|
|
AC_DEFUN([AM_CONDITIONAL],
|
|
[AC_SUBST($1_TRUE)
|
|
AC_SUBST($1_FALSE)
|
|
if $2; then
|
|
$1_TRUE=
|
|
$1_FALSE='#'
|
|
else
|
|
$1_TRUE='#'
|
|
$1_FALSE=
|
|
fi])
|
|
|
|
dnl $Id: krb-ipv6.m4,v 1.10 2001/03/26 03:28:03 assar Exp $
|
|
dnl
|
|
dnl test for IPv6
|
|
dnl
|
|
AC_DEFUN(AC_KRB_IPV6, [
|
|
AC_ARG_WITH(ipv6,
|
|
[ --without-ipv6 do not enable IPv6 support],[
|
|
if test "$withval" = "no"; then
|
|
ac_cv_lib_ipv6=no
|
|
fi])
|
|
save_CFLAGS="${CFLAGS}"
|
|
AC_CACHE_VAL(ac_cv_lib_ipv6,
|
|
[dnl check for different v6 implementations (by itojun)
|
|
v6type=unknown
|
|
v6lib=none
|
|
|
|
AC_MSG_CHECKING([ipv6 stack type])
|
|
for i in v6d toshiba kame inria zeta linux; do
|
|
case $i in
|
|
v6d)
|
|
AC_EGREP_CPP(yes, [
|
|
#include </usr/local/v6/include/sys/types.h>
|
|
#ifdef __V6D__
|
|
yes
|
|
#endif],
|
|
[v6type=$i; v6lib=v6;
|
|
v6libdir=/usr/local/v6/lib;
|
|
CFLAGS="-I/usr/local/v6/include $CFLAGS"])
|
|
;;
|
|
toshiba)
|
|
AC_EGREP_CPP(yes, [
|
|
#include <sys/param.h>
|
|
#ifdef _TOSHIBA_INET6
|
|
yes
|
|
#endif],
|
|
[v6type=$i; v6lib=inet6;
|
|
v6libdir=/usr/local/v6/lib;
|
|
CFLAGS="-DINET6 $CFLAGS"])
|
|
;;
|
|
kame)
|
|
AC_EGREP_CPP(yes, [
|
|
#include <netinet/in.h>
|
|
#ifdef __KAME__
|
|
yes
|
|
#endif],
|
|
[v6type=$i; v6lib=inet6;
|
|
v6libdir=/usr/local/v6/lib;
|
|
CFLAGS="-DINET6 $CFLAGS"])
|
|
;;
|
|
inria)
|
|
AC_EGREP_CPP(yes, [
|
|
#include <netinet/in.h>
|
|
#ifdef IPV6_INRIA_VERSION
|
|
yes
|
|
#endif],
|
|
[v6type=$i; CFLAGS="-DINET6 $CFLAGS"])
|
|
;;
|
|
zeta)
|
|
AC_EGREP_CPP(yes, [
|
|
#include <sys/param.h>
|
|
#ifdef _ZETA_MINAMI_INET6
|
|
yes
|
|
#endif],
|
|
[v6type=$i; v6lib=inet6;
|
|
v6libdir=/usr/local/v6/lib;
|
|
CFLAGS="-DINET6 $CFLAGS"])
|
|
;;
|
|
linux)
|
|
if test -d /usr/inet6; then
|
|
v6type=$i
|
|
v6lib=inet6
|
|
v6libdir=/usr/inet6
|
|
CFLAGS="-DINET6 $CFLAGS"
|
|
fi
|
|
;;
|
|
esac
|
|
if test "$v6type" != "unknown"; then
|
|
break
|
|
fi
|
|
done
|
|
AC_MSG_RESULT($v6type)
|
|
|
|
if test "$v6lib" != "none"; then
|
|
for dir in $v6libdir /usr/local/v6/lib /usr/local/lib; do
|
|
if test -d $dir -a -f $dir/lib$v6lib.a; then
|
|
LIBS="-L$dir -l$v6lib $LIBS"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
AC_TRY_LINK([
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_SOCKET_H
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN_H
|
|
#include <netinet/in.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN6_H
|
|
#include <netinet/in6.h>
|
|
#endif
|
|
],
|
|
[
|
|
struct sockaddr_in6 sin6;
|
|
int s;
|
|
|
|
s = socket(AF_INET6, SOCK_DGRAM, 0);
|
|
|
|
sin6.sin6_family = AF_INET6;
|
|
sin6.sin6_port = htons(17);
|
|
sin6.sin6_addr = in6addr_any;
|
|
bind(s, (struct sockaddr *)&sin6, sizeof(sin6));
|
|
],
|
|
ac_cv_lib_ipv6=yes,
|
|
ac_cv_lib_ipv6=no)])
|
|
AC_MSG_CHECKING(for IPv6)
|
|
AC_MSG_RESULT($ac_cv_lib_ipv6)
|
|
if test "$ac_cv_lib_ipv6" = yes; then
|
|
AC_DEFINE(HAVE_IPV6, 1, [Define if you have IPv6.])
|
|
else
|
|
CFLAGS="${save_CFLAGS}"
|
|
fi
|
|
])
|
|
|
|
dnl $Id: find-func.m4,v 1.1 1997/12/14 15:58:58 joda Exp $
|
|
dnl
|
|
dnl AC_FIND_FUNC(func, libraries, includes, arguments)
|
|
AC_DEFUN(AC_FIND_FUNC, [
|
|
AC_FIND_FUNC_NO_LIBS([$1], [$2], [$3], [$4])
|
|
if test -n "$LIB_$1"; then
|
|
LIBS="$LIB_$1 $LIBS"
|
|
fi
|
|
])
|
|
|
|
dnl $Id: broken-snprintf.m4,v 1.3 1999/03/01 09:52:22 joda Exp $
|
|
dnl
|
|
AC_DEFUN(AC_BROKEN_SNPRINTF, [
|
|
AC_CACHE_CHECK(for working snprintf,ac_cv_func_snprintf_working,
|
|
ac_cv_func_snprintf_working=yes
|
|
AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
int main()
|
|
{
|
|
changequote(`,')dnl
|
|
char foo[3];
|
|
changequote([,])dnl
|
|
snprintf(foo, 2, "12");
|
|
return strcmp(foo, "1");
|
|
}],:,ac_cv_func_snprintf_working=no,:))
|
|
|
|
if test "$ac_cv_func_snprintf_working" = yes; then
|
|
AC_DEFINE_UNQUOTED(HAVE_SNPRINTF, 1, [define if you have a working snprintf])
|
|
fi
|
|
if test "$ac_cv_func_snprintf_working" = yes; then
|
|
AC_NEED_PROTO([#include <stdio.h>],snprintf)
|
|
fi
|
|
])
|
|
|
|
AC_DEFUN(AC_BROKEN_VSNPRINTF,[
|
|
AC_CACHE_CHECK(for working vsnprintf,ac_cv_func_vsnprintf_working,
|
|
ac_cv_func_vsnprintf_working=yes
|
|
AC_TRY_RUN([
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
|
|
int foo(int num, ...)
|
|
{
|
|
changequote(`,')dnl
|
|
char bar[3];
|
|
changequote([,])dnl
|
|
va_list arg;
|
|
va_start(arg, num);
|
|
vsnprintf(bar, 2, "%s", arg);
|
|
va_end(arg);
|
|
return strcmp(bar, "1");
|
|
}
|
|
|
|
|
|
int main()
|
|
{
|
|
return foo(0, "12");
|
|
}],:,ac_cv_func_vsnprintf_working=no,:))
|
|
|
|
if test "$ac_cv_func_vsnprintf_working" = yes; then
|
|
AC_DEFINE_UNQUOTED(HAVE_VSNPRINTF, 1, [define if you have a working vsnprintf])
|
|
fi
|
|
if test "$ac_cv_func_vsnprintf_working" = yes; then
|
|
AC_NEED_PROTO([#include <stdio.h>],vsnprintf)
|
|
fi
|
|
])
|
|
|
|
dnl $Id: need-proto.m4,v 1.2 1999/03/01 09:52:24 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Check if we need the prototype for a function
|
|
dnl
|
|
|
|
dnl AC_NEED_PROTO(includes, function)
|
|
|
|
AC_DEFUN(AC_NEED_PROTO, [
|
|
if test "$ac_cv_func_$2+set" != set -o "$ac_cv_func_$2" = yes; then
|
|
AC_CACHE_CHECK([if $2 needs a prototype], ac_cv_func_$2_noproto,
|
|
AC_TRY_COMPILE([$1],
|
|
[struct foo { int foo; } xx;
|
|
extern int $2 (struct foo*);
|
|
$2(&xx);
|
|
],
|
|
eval "ac_cv_func_$2_noproto=yes",
|
|
eval "ac_cv_func_$2_noproto=no"))
|
|
define([foo], [NEED_]translit($2, [a-z], [A-Z])[_PROTO])
|
|
if test "$ac_cv_func_$2_noproto" = yes; then
|
|
AC_DEFINE(foo, 1, [define if the system is missing a prototype for $2()])
|
|
fi
|
|
undefine([foo])
|
|
fi
|
|
])
|
|
|
|
dnl $Id: broken-glob.m4,v 1.3 2001/03/26 11:40:24 assar Exp $
|
|
dnl
|
|
dnl check for glob(3)
|
|
dnl
|
|
AC_DEFUN(AC_BROKEN_GLOB,[
|
|
AC_CACHE_CHECK(for working glob, ac_cv_func_glob_working,
|
|
ac_cv_func_glob_working=yes
|
|
AC_TRY_LINK([
|
|
#include <stdio.h>
|
|
#include <glob.h>],[
|
|
glob(NULL, GLOB_BRACE|GLOB_NOCHECK|GLOB_QUOTE|GLOB_TILDE|GLOB_LIMIT,
|
|
NULL, NULL);
|
|
],:,ac_cv_func_glob_working=no,:))
|
|
|
|
if test "$ac_cv_func_glob_working" = yes; then
|
|
AC_DEFINE(HAVE_GLOB, 1, [define if you have a glob() that groks
|
|
GLOB_BRACE, GLOB_NOCHECK, GLOB_QUOTE, GLOB_TILDE, and GLOB_LIMIT])
|
|
fi
|
|
if test "$ac_cv_func_glob_working" = yes; then
|
|
AC_NEED_PROTO([#include <stdio.h>
|
|
#include <glob.h>],glob)
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl $Id: krb-func-getlogin.m4,v 1.1 1999/07/13 17:45:30 assar Exp $
|
|
dnl
|
|
dnl test for POSIX (broken) getlogin
|
|
dnl
|
|
|
|
|
|
AC_DEFUN(AC_FUNC_GETLOGIN, [
|
|
AC_CHECK_FUNCS(getlogin setlogin)
|
|
if test "$ac_cv_func_getlogin" = yes; then
|
|
AC_CACHE_CHECK(if getlogin is posix, ac_cv_func_getlogin_posix, [
|
|
if test "$ac_cv_func_getlogin" = yes -a "$ac_cv_func_setlogin" = yes; then
|
|
ac_cv_func_getlogin_posix=no
|
|
else
|
|
ac_cv_func_getlogin_posix=yes
|
|
fi
|
|
])
|
|
if test "$ac_cv_func_getlogin_posix" = yes; then
|
|
AC_DEFINE(POSIX_GETLOGIN, 1, [Define if getlogin has POSIX flavour (and not BSD).])
|
|
fi
|
|
fi
|
|
])
|
|
|
|
dnl $Id: find-if-not-broken.m4,v 1.2 1998/03/16 22:16:27 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Mix between AC_FIND_FUNC and AC_BROKEN
|
|
dnl
|
|
|
|
AC_DEFUN(AC_FIND_IF_NOT_BROKEN,
|
|
[AC_FIND_FUNC([$1], [$2], [$3], [$4])
|
|
if eval "test \"$ac_cv_func_$1\" != yes"; then
|
|
LIBOBJS[]="$LIBOBJS $1.o"
|
|
fi
|
|
AC_SUBST(LIBOBJS)dnl
|
|
])
|
|
|
|
dnl $Id: broken.m4,v 1.4 2000/07/15 18:06:36 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Same as AC _REPLACE_FUNCS, just define HAVE_func if found in normal
|
|
dnl libraries
|
|
|
|
AC_DEFUN(AC_BROKEN,
|
|
[for ac_func in $1
|
|
do
|
|
AC_CHECK_FUNC($ac_func, [
|
|
ac_tr_func=HAVE_[]upcase($ac_func)
|
|
AC_DEFINE_UNQUOTED($ac_tr_func)],[LIBOBJS[]="$LIBOBJS ${ac_func}.o"])
|
|
if false; then
|
|
AC_CHECK_FUNCS($1)
|
|
fi
|
|
done
|
|
AC_SUBST(LIBOBJS)dnl
|
|
])
|
|
|
|
dnl $Id: broken2.m4,v 1.1 2000/12/15 14:27:33 assar Exp $
|
|
dnl
|
|
dnl AC_BROKEN but with more arguments
|
|
|
|
dnl AC_BROKEN2(func, includes, arguments)
|
|
AC_DEFUN(AC_BROKEN2,
|
|
[for ac_func in $1
|
|
do
|
|
AC_MSG_CHECKING([for $ac_func])
|
|
AC_CACHE_VAL(ac_cv_func_$ac_func,
|
|
[AC_TRY_LINK([$2],
|
|
[
|
|
/* The GNU C library defines this for functions which it implements
|
|
to always fail with ENOSYS. Some functions are actually named
|
|
something starting with __ and the normal name is an alias. */
|
|
#if defined (__stub_$1) || defined (__stub___$1)
|
|
choke me
|
|
#else
|
|
$ac_func($3)
|
|
#endif
|
|
], [eval "ac_cv_func_$ac_func=yes"], [eval "ac_cv_func_$ac_func=no"])])
|
|
if eval "test \"\${ac_cv_func_$ac_func}\" = yes"; then
|
|
ac_tr_func=HAVE_[]upcase($ac_func)
|
|
AC_DEFINE_UNQUOTED($ac_tr_func)
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
LIBOBJS[]="$LIBOBJS ${ac_func}.o"
|
|
fi
|
|
done
|
|
if false; then
|
|
AC_CHECK_FUNCS($1)
|
|
fi
|
|
AC_SUBST(LIBOBJS)dnl
|
|
])
|
|
|
|
dnl $Id: have-struct-field.m4,v 1.6 1999/07/29 01:44:32 assar Exp $
|
|
dnl
|
|
dnl check for fields in a structure
|
|
dnl
|
|
dnl AC_HAVE_STRUCT_FIELD(struct, field, headers)
|
|
|
|
AC_DEFUN(AC_HAVE_STRUCT_FIELD, [
|
|
define(cache_val, translit(ac_cv_type_$1_$2, [A-Z ], [a-z_]))
|
|
AC_CACHE_CHECK([for $2 in $1], cache_val,[
|
|
AC_TRY_COMPILE([$3],[$1 x; x.$2;],
|
|
cache_val=yes,
|
|
cache_val=no)])
|
|
if test "$cache_val" = yes; then
|
|
define(foo, translit(HAVE_$1_$2, [a-z ], [A-Z_]))
|
|
AC_DEFINE(foo, 1, [Define if $1 has field $2.])
|
|
undefine([foo])
|
|
fi
|
|
undefine([cache_val])
|
|
])
|
|
|
|
dnl $Id: broken-getnameinfo.m4,v 1.2 2000/12/05 09:09:00 joda Exp $
|
|
dnl
|
|
dnl test for broken AIX getnameinfo
|
|
|
|
AC_DEFUN(rk_BROKEN_GETNAMEINFO,[
|
|
AC_CACHE_CHECK([if getnameinfo is broken], ac_cv_func_getnameinfo_broken,
|
|
AC_TRY_RUN([[#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <netdb.h>
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
struct sockaddr_in sin;
|
|
char host[256];
|
|
memset(&sin, 0, sizeof(sin));
|
|
#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
|
|
sin.sin_len = sizeof(sin);
|
|
#endif
|
|
sin.sin_family = AF_INET;
|
|
sin.sin_addr.s_addr = 0xffffffff;
|
|
sin.sin_port = 0;
|
|
return getnameinfo((struct sockaddr*)&sin, sizeof(sin), host, sizeof(host),
|
|
NULL, 0, 0);
|
|
}
|
|
]], ac_cv_func_getnameinfo_broken=no, ac_cv_func_getnameinfo_broken=yes))])
|
|
|
|
dnl
|
|
dnl $Id: broken-realloc.m4,v 1.1 2000/07/15 18:05:36 joda Exp $
|
|
dnl
|
|
dnl Test for realloc that doesn't handle NULL as first parameter
|
|
dnl
|
|
AC_DEFUN(rk_BROKEN_REALLOC, [
|
|
AC_CACHE_CHECK(if realloc if broken, ac_cv_func_realloc_broken, [
|
|
ac_cv_func_realloc_broken=no
|
|
AC_TRY_RUN([
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
|
|
int main()
|
|
{
|
|
return realloc(NULL, 17) == NULL;
|
|
}
|
|
],:, ac_cv_func_realloc_broken=yes, :)
|
|
])
|
|
if test "$ac_cv_func_realloc_broken" = yes ; then
|
|
AC_DEFINE(BROKEN_REALLOC, 1, [Define if realloc(NULL) doesn't work.])
|
|
fi
|
|
AH_BOTTOM([#ifdef BROKEN_REALLOC
|
|
#define realloc(X, Y) isoc_realloc((X), (Y))
|
|
#define isoc_realloc(X, Y) ((X) ? realloc((X), (Y)) : malloc(Y))
|
|
#endif])
|
|
])
|
|
|
|
dnl $Id: proto-compat.m4,v 1.3 1999/03/01 13:03:48 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Check if the prototype of a function is compatible with another one
|
|
dnl
|
|
|
|
dnl AC_PROTO_COMPAT(includes, function, prototype)
|
|
|
|
AC_DEFUN(AC_PROTO_COMPAT, [
|
|
AC_CACHE_CHECK([if $2 is compatible with system prototype],
|
|
ac_cv_func_$2_proto_compat,
|
|
AC_TRY_COMPILE([$1],
|
|
[$3;],
|
|
eval "ac_cv_func_$2_proto_compat=yes",
|
|
eval "ac_cv_func_$2_proto_compat=no"))
|
|
define([foo], translit($2, [a-z], [A-Z])[_PROTO_COMPATIBLE])
|
|
if test "$ac_cv_func_$2_proto_compat" = yes; then
|
|
AC_DEFINE(foo, 1, [define if prototype of $2 is compatible with
|
|
$3])
|
|
fi
|
|
undefine([foo])
|
|
])
|
|
dnl $Id: check-var.m4,v 1.5 2000/12/15 04:54:06 assar Exp $
|
|
dnl
|
|
dnl rk_CHECK_VAR(variable, includes)
|
|
AC_DEFUN([rk_CHECK_VAR], [
|
|
AC_MSG_CHECKING(for $1)
|
|
AC_CACHE_VAL(ac_cv_var_$1, [
|
|
AC_TRY_LINK([extern int $1;
|
|
int foo() { return $1; }],
|
|
[foo()],
|
|
ac_cv_var_$1=yes, ac_cv_var_$1=no)
|
|
])
|
|
ac_foo=`eval echo \\$ac_cv_var_$1`
|
|
AC_MSG_RESULT($ac_foo)
|
|
if test "$ac_foo" = yes; then
|
|
AC_DEFINE_UNQUOTED(AC_TR_CPP(HAVE_[]$1), 1,
|
|
[Define if you have the `]$1[' variable.])
|
|
m4_ifval([$2], AC_CHECK_DECLARATION([$2],[$1]))
|
|
fi
|
|
])
|
|
|
|
AC_WARNING_ENABLE([obsolete])
|
|
AU_DEFUN([AC_CHECK_VAR], [rk_CHECK_VAR([$2], [$1])], [foo])
|
|
dnl $Id: check-declaration.m4,v 1.3 1999/03/01 13:03:08 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Check if we need the declaration of a variable
|
|
dnl
|
|
|
|
dnl AC_HAVE_DECLARATION(includes, variable)
|
|
AC_DEFUN(AC_CHECK_DECLARATION, [
|
|
AC_MSG_CHECKING([if $2 is properly declared])
|
|
AC_CACHE_VAL(ac_cv_var_$2_declaration, [
|
|
AC_TRY_COMPILE([$1
|
|
extern struct { int foo; } $2;],
|
|
[$2.foo = 1;],
|
|
eval "ac_cv_var_$2_declaration=no",
|
|
eval "ac_cv_var_$2_declaration=yes")
|
|
])
|
|
|
|
define(foo, [HAVE_]translit($2, [a-z], [A-Z])[_DECLARATION])
|
|
|
|
AC_MSG_RESULT($ac_cv_var_$2_declaration)
|
|
if eval "test \"\$ac_cv_var_$2_declaration\" = yes"; then
|
|
AC_DEFINE(foo, 1, [define if your system declares $2])
|
|
fi
|
|
undefine([foo])
|
|
])
|
|
|
|
dnl $Id: krb-struct-winsize.m4,v 1.2 1999/03/01 09:52:23 joda Exp $
|
|
dnl
|
|
dnl
|
|
dnl Search for struct winsize
|
|
dnl
|
|
|
|
AC_DEFUN(AC_KRB_STRUCT_WINSIZE, [
|
|
AC_MSG_CHECKING(for struct winsize)
|
|
AC_CACHE_VAL(ac_cv_struct_winsize, [
|
|
ac_cv_struct_winsize=no
|
|
for i in sys/termios.h sys/ioctl.h; do
|
|
AC_EGREP_HEADER(
|
|
changequote(, )dnl
|
|
struct[ ]*winsize,dnl
|
|
changequote([,])dnl
|
|
$i, ac_cv_struct_winsize=yes; break)dnl
|
|
done
|
|
])
|
|
if test "$ac_cv_struct_winsize" = "yes"; then
|
|
AC_DEFINE(HAVE_STRUCT_WINSIZE, 1, [define if struct winsize is declared in sys/termios.h])
|
|
fi
|
|
AC_MSG_RESULT($ac_cv_struct_winsize)
|
|
AC_EGREP_HEADER(ws_xpixel, termios.h,
|
|
AC_DEFINE(HAVE_WS_XPIXEL, 1, [define if struct winsize has ws_xpixel]))
|
|
AC_EGREP_HEADER(ws_ypixel, termios.h,
|
|
AC_DEFINE(HAVE_WS_YPIXEL, 1, [define if struct winsize has ws_ypixel]))
|
|
])
|
|
|
|
dnl $Id: krb-struct-spwd.m4,v 1.3 1999/07/13 21:04:11 assar Exp $
|
|
dnl
|
|
dnl Test for `struct spwd'
|
|
|
|
AC_DEFUN(AC_KRB_STRUCT_SPWD, [
|
|
AC_MSG_CHECKING(for struct spwd)
|
|
AC_CACHE_VAL(ac_cv_struct_spwd, [
|
|
AC_TRY_COMPILE(
|
|
[#include <pwd.h>
|
|
#ifdef HAVE_SHADOW_H
|
|
#include <shadow.h>
|
|
#endif],
|
|
[struct spwd foo;],
|
|
ac_cv_struct_spwd=yes,
|
|
ac_cv_struct_spwd=no)
|
|
])
|
|
AC_MSG_RESULT($ac_cv_struct_spwd)
|
|
|
|
if test "$ac_cv_struct_spwd" = "yes"; then
|
|
AC_DEFINE(HAVE_STRUCT_SPWD, 1, [define if you have struct spwd])
|
|
fi
|
|
])
|
|
|
|
dnl $Id: test-package.m4,v 1.9 2000/12/15 04:54:24 assar Exp $
|
|
dnl
|
|
dnl AC_TEST_PACKAGE_NEW(package,headers,libraries,extra libs,default locations, conditional)
|
|
|
|
AC_DEFUN(AC_TEST_PACKAGE,[AC_TEST_PACKAGE_NEW($1,[#include <$2>],$4,,$5)])
|
|
|
|
AC_DEFUN(AC_TEST_PACKAGE_NEW,[
|
|
AC_ARG_WITH($1,
|
|
[ --with-$1=dir use $1 in dir])
|
|
AC_ARG_WITH($1-lib,
|
|
[ --with-$1-lib=dir use $1 libraries in dir],
|
|
[if test "$withval" = "yes" -o "$withval" = "no"; then
|
|
AC_MSG_ERROR([No argument for --with-$1-lib])
|
|
elif test "X$with_$1" = "X"; then
|
|
with_$1=yes
|
|
fi])
|
|
AC_ARG_WITH($1-include,
|
|
[ --with-$1-include=dir use $1 headers in dir],
|
|
[if test "$withval" = "yes" -o "$withval" = "no"; then
|
|
AC_MSG_ERROR([No argument for --with-$1-include])
|
|
elif test "X$with_$1" = "X"; then
|
|
with_$1=yes
|
|
fi])
|
|
|
|
AC_MSG_CHECKING(for $1)
|
|
|
|
case "$with_$1" in
|
|
yes) ;;
|
|
no) ;;
|
|
"") ;;
|
|
*) if test "$with_$1_include" = ""; then
|
|
with_$1_include="$with_$1/include"
|
|
fi
|
|
if test "$with_$1_lib" = ""; then
|
|
with_$1_lib="$with_$1/lib$abilibdirext"
|
|
fi
|
|
;;
|
|
esac
|
|
header_dirs=
|
|
lib_dirs=
|
|
d='$5'
|
|
for i in $d; do
|
|
header_dirs="$header_dirs $i/include"
|
|
lib_dirs="$lib_dirs $i/lib$abilibdirext"
|
|
done
|
|
|
|
case "$with_$1_include" in
|
|
yes) ;;
|
|
no) ;;
|
|
*) header_dirs="$with_$1_include $header_dirs";;
|
|
esac
|
|
case "$with_$1_lib" in
|
|
yes) ;;
|
|
no) ;;
|
|
*) lib_dirs="$with_$1_lib $lib_dirs";;
|
|
esac
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
save_LIBS="$LIBS"
|
|
ires= lres=
|
|
for i in $header_dirs; do
|
|
CFLAGS="-I$i $save_CFLAGS"
|
|
AC_TRY_COMPILE([$2],,ires=$i;break)
|
|
done
|
|
for i in $lib_dirs; do
|
|
LIBS="-L$i $3 $4 $save_LIBS"
|
|
AC_TRY_LINK([$2],,lres=$i;break)
|
|
done
|
|
CFLAGS="$save_CFLAGS"
|
|
LIBS="$save_LIBS"
|
|
|
|
if test "$ires" -a "$lres" -a "$with_$1" != "no"; then
|
|
$1_includedir="$ires"
|
|
$1_libdir="$lres"
|
|
INCLUDE_$1="-I$$1_includedir"
|
|
LIB_$1="-L$$1_libdir $3"
|
|
m4_ifval([$6],
|
|
AC_DEFINE_UNQUOTED($6,1,[Define if you have the $1 package.]),
|
|
AC_DEFINE_UNQUOTED(upcase($1),1,[Define if you have the $1 package.]))
|
|
with_$1=yes
|
|
AC_MSG_RESULT([headers $ires, libraries $lres])
|
|
else
|
|
INCLUDE_$1=
|
|
LIB_$1=
|
|
with_$1=no
|
|
AC_MSG_RESULT($with_$1)
|
|
fi
|
|
dnl m4_ifval([$6],
|
|
dnl AM_CONDITIONAL($6, test "$with_$1" = yes)
|
|
dnl AM_CONDITIONAL(upcase($1), test "$with_$1" = yes))
|
|
AC_SUBST(INCLUDE_$1)
|
|
AC_SUBST(LIB_$1)
|
|
])
|
|
|
|
dnl $Id: osfc2.m4,v 1.2 1999/03/27 17:28:16 joda Exp $
|
|
dnl
|
|
dnl enable OSF C2 stuff
|
|
|
|
AC_DEFUN(AC_CHECK_OSFC2,[
|
|
AC_ARG_ENABLE(osfc2,
|
|
[ --enable-osfc2 enable some OSF C2 support])
|
|
LIB_security=
|
|
if test "$enable_osfc2" = yes; then
|
|
AC_DEFINE(HAVE_OSFC2, 1, [Define to enable basic OSF C2 support.])
|
|
LIB_security=-lsecurity
|
|
fi
|
|
AC_SUBST(LIB_security)
|
|
])
|
|
|
|
dnl $Id: check-man.m4,v 1.3 2000/11/30 01:47:17 joda Exp $
|
|
dnl check how to format manual pages
|
|
dnl
|
|
|
|
AC_DEFUN(rk_CHECK_MAN,
|
|
[AC_PATH_PROG(NROFF, nroff)
|
|
AC_PATH_PROG(GROFF, groff)
|
|
AC_CACHE_CHECK(how to format man pages,ac_cv_sys_man_format,
|
|
[cat > conftest.1 << END
|
|
.Dd January 1, 1970
|
|
.Dt CONFTEST 1
|
|
.Sh NAME
|
|
.Nm conftest
|
|
.Nd
|
|
foobar
|
|
END
|
|
|
|
if test "$NROFF" ; then
|
|
for i in "-mdoc" "-mandoc"; do
|
|
if "$NROFF" $i conftest.1 2> /dev/null | \
|
|
grep Jan > /dev/null 2>&1 ; then
|
|
ac_cv_sys_man_format="$NROFF $i"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
if test "$ac_cv_sys_man_format" = "" -a "$GROFF" ; then
|
|
for i in "-mdoc" "-mandoc"; do
|
|
if "$GROFF" -Tascii $i conftest.1 2> /dev/null | \
|
|
grep Jan > /dev/null 2>&1 ; then
|
|
ac_cv_sys_man_format="$GROFF -Tascii $i"
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
if test "$ac_cv_sys_man_format"; then
|
|
ac_cv_sys_man_format="$ac_cv_sys_man_format \[$]< > \[$]@"
|
|
fi
|
|
])
|
|
if test "$ac_cv_sys_man_format"; then
|
|
CATMAN="$ac_cv_sys_man_format"
|
|
AC_SUBST(CATMAN)
|
|
fi
|
|
AM_CONDITIONAL(CATMAN, test "$CATMAN")
|
|
AC_CACHE_CHECK(extension of pre-formatted manual pages,ac_cv_sys_catman_ext,
|
|
[if grep _suffix /etc/man.conf > /dev/null 2>&1; then
|
|
ac_cv_sys_catman_ext=0
|
|
else
|
|
ac_cv_sys_catman_ext=number
|
|
fi
|
|
])
|
|
if test "$ac_cv_sys_catman_ext" = number; then
|
|
CATMANEXT='$$section'
|
|
else
|
|
CATMANEXT=0
|
|
fi
|
|
AC_SUBST(CATMANEXT)
|
|
])
|
|
dnl
|
|
dnl $Id: krb-bigendian.m4,v 1.6 2000/08/19 15:37:00 assar Exp $
|
|
dnl
|
|
|
|
dnl check if this computer is little or big-endian
|
|
dnl if we can figure it out at compile-time then don't define the cpp symbol
|
|
dnl otherwise test for it and define it. also allow options for overriding
|
|
dnl it when cross-compiling
|
|
|
|
AC_DEFUN(KRB_C_BIGENDIAN, [
|
|
AC_ARG_ENABLE(bigendian,
|
|
[ --enable-bigendian the target is big endian],
|
|
krb_cv_c_bigendian=yes)
|
|
AC_ARG_ENABLE(littleendian,
|
|
[ --enable-littleendian the target is little endian],
|
|
krb_cv_c_bigendian=no)
|
|
AC_CACHE_CHECK(whether byte order is known at compile time,
|
|
krb_cv_c_bigendian_compile,
|
|
[AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>],[
|
|
#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
|
|
bogus endian macros
|
|
#endif], krb_cv_c_bigendian_compile=yes, krb_cv_c_bigendian_compile=no)])
|
|
AC_CACHE_CHECK(whether byte ordering is bigendian, krb_cv_c_bigendian,[
|
|
if test "$krb_cv_c_bigendian_compile" = "yes"; then
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>],[
|
|
#if BYTE_ORDER != BIG_ENDIAN
|
|
not big endian
|
|
#endif], krb_cv_c_bigendian=yes, krb_cv_c_bigendian=no)
|
|
else
|
|
AC_TRY_RUN([main () {
|
|
/* Are we little or big endian? From Harbison&Steele. */
|
|
union
|
|
{
|
|
long l;
|
|
char c[sizeof (long)];
|
|
} u;
|
|
u.l = 1;
|
|
exit (u.c[sizeof (long) - 1] == 1);
|
|
}], krb_cv_c_bigendian=no, krb_cv_c_bigendian=yes,
|
|
AC_MSG_ERROR([specify either --enable-bigendian or --enable-littleendian]))
|
|
fi
|
|
])
|
|
if test "$krb_cv_c_bigendian" = "yes"; then
|
|
AC_DEFINE(WORDS_BIGENDIAN, 1, [define if target is big endian])dnl
|
|
fi
|
|
if test "$krb_cv_c_bigendian_compile" = "yes"; then
|
|
AC_DEFINE(ENDIANESS_IN_SYS_PARAM_H, 1, [define if sys/param.h defines the endiness])dnl
|
|
fi
|
|
])
|
|
|
|
dnl
|
|
dnl $Id: aix.m4,v 1.5 2000/11/05 17:15:46 joda Exp $
|
|
dnl
|
|
|
|
AC_DEFUN(KRB_AIX,[
|
|
aix=no
|
|
case "$host" in
|
|
*-*-aix3*)
|
|
aix=3
|
|
;;
|
|
*-*-aix4*)
|
|
aix=4
|
|
;;
|
|
esac
|
|
AM_CONDITIONAL(AIX, test "$aix" != no)dnl
|
|
AM_CONDITIONAL(AIX4, test "$aix" = 4)
|
|
aix_dynamic_afs=yes
|
|
AM_CONDITIONAL(AIX_DYNAMIC_AFS, test "$aix_dynamic_afs" = yes)dnl
|
|
|
|
AC_FIND_FUNC_NO_LIBS(dlopen, dl)
|
|
|
|
if test "$aix" != no; then
|
|
if test "$aix_dynamic_afs" = yes; then
|
|
if test "$ac_cv_funclib_dlopen" = yes; then
|
|
AIX_EXTRA_KAFS=
|
|
elif test "$ac_cv_funclib_dlopen" != no; then
|
|
AIX_EXTRA_KAFS="$ac_cv_funclib_dlopen"
|
|
else
|
|
AIX_EXTRA_KAFS=-lld
|
|
fi
|
|
else
|
|
AIX_EXTRA_KAFS=
|
|
fi
|
|
fi
|
|
|
|
AM_CONDITIONAL(HAVE_DLOPEN, test "$ac_cv_funclib_dlopen" != no)dnl
|
|
AC_SUBST(AIX_EXTRA_KAFS)dnl
|
|
|
|
])
|
|
dnl
|
|
dnl $Id: krb-irix.m4,v 1.2 2000/12/13 12:48:45 assar Exp $
|
|
dnl
|
|
|
|
dnl requires AC_CANONICAL_HOST
|
|
AC_DEFUN(KRB_IRIX,[
|
|
irix=no
|
|
case "$host_os" in
|
|
irix*) irix=yes ;;
|
|
esac
|
|
AM_CONDITIONAL(IRIX, test "$irix" != no)dnl
|
|
])
|
|
|
|
dnl
|
|
dnl See if there is any X11 present
|
|
dnl
|
|
dnl $Id: check-x.m4,v 1.2 1999/11/05 04:25:23 assar Exp $
|
|
|
|
AC_DEFUN(KRB_CHECK_X,[
|
|
AC_PATH_XTRA
|
|
|
|
# try to figure out if we need any additional ld flags, like -R
|
|
# and yes, the autoconf X test is utterly broken
|
|
if test "$no_x" != yes; then
|
|
AC_CACHE_CHECK(for special X linker flags,krb_cv_sys_x_libs_rpath,[
|
|
ac_save_libs="$LIBS"
|
|
ac_save_cflags="$CFLAGS"
|
|
CFLAGS="$CFLAGS $X_CFLAGS"
|
|
krb_cv_sys_x_libs_rpath=""
|
|
krb_cv_sys_x_libs=""
|
|
for rflag in "" "-R" "-R " "-rpath "; do
|
|
if test "$rflag" = ""; then
|
|
foo="$X_LIBS"
|
|
else
|
|
foo=""
|
|
for flag in $X_LIBS; do
|
|
case $flag in
|
|
-L*)
|
|
foo="$foo $flag `echo $flag | sed \"s/-L/$rflag/\"`"
|
|
;;
|
|
*)
|
|
foo="$foo $flag"
|
|
;;
|
|
esac
|
|
done
|
|
fi
|
|
LIBS="$ac_save_libs $foo $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
|
|
AC_TRY_RUN([
|
|
#include <X11/Xlib.h>
|
|
foo()
|
|
{
|
|
XOpenDisplay(NULL);
|
|
}
|
|
main()
|
|
{
|
|
return 0;
|
|
}
|
|
], krb_cv_sys_x_libs_rpath="$rflag"; krb_cv_sys_x_libs="$foo"; break,:)
|
|
done
|
|
LIBS="$ac_save_libs"
|
|
CFLAGS="$ac_save_cflags"
|
|
])
|
|
X_LIBS="$krb_cv_sys_x_libs"
|
|
fi
|
|
])
|
|
|
|
dnl $Id: check-xau.m4,v 1.3 1999/05/14 01:17:06 assar Exp $
|
|
dnl
|
|
dnl check for Xau{Read,Write}Auth and XauFileName
|
|
dnl
|
|
AC_DEFUN(AC_CHECK_XAU,[
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$X_CFLAGS $CFLAGS"
|
|
save_LIBS="$LIBS"
|
|
dnl LIBS="$X_LIBS $X_PRE_LIBS $X_EXTRA_LIBS $LIBS"
|
|
LIBS="$X_PRE_LIBS $X_EXTRA_LIBS $LIBS"
|
|
save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS $X_LIBS"
|
|
|
|
|
|
AC_FIND_FUNC_NO_LIBS(XauWriteAuth, X11 Xau)
|
|
ac_xxx="$LIBS"
|
|
LIBS="$LIB_XauWriteAuth $LIBS"
|
|
AC_FIND_FUNC_NO_LIBS(XauReadAuth, X11 Xau)
|
|
LIBS="$LIB_XauReadAauth $LIBS"
|
|
AC_FIND_FUNC_NO_LIBS(XauFileName, X11 Xau)
|
|
LIBS="$ac_xxx"
|
|
|
|
case "$ac_cv_funclib_XauWriteAuth" in
|
|
yes) ;;
|
|
no) ;;
|
|
*) if test "$ac_cv_funclib_XauReadAuth" = yes; then
|
|
if test "$ac_cv_funclib_XauFileName" = yes; then
|
|
LIB_XauReadAuth="$LIB_XauWriteAuth"
|
|
else
|
|
LIB_XauReadAuth="$LIB_XauWriteAuth $LIB_XauFileName"
|
|
fi
|
|
else
|
|
if test "$ac_cv_funclib_XauFileName" = yes; then
|
|
LIB_XauReadAuth="$LIB_XauReadAuth $LIB_XauWriteAuth"
|
|
else
|
|
LIB_XauReadAuth="$LIB_XauReadAuth $LIB_XauWriteAuth $LIB_XauFileName"
|
|
fi
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
if test "$AUTOMAKE" != ""; then
|
|
AM_CONDITIONAL(NEED_WRITEAUTH, test "$ac_cv_func_XauWriteAuth" != "yes")
|
|
else
|
|
AC_SUBST(NEED_WRITEAUTH_TRUE)
|
|
AC_SUBST(NEED_WRITEAUTH_FALSE)
|
|
if test "$ac_cv_func_XauWriteAuth" != "yes"; then
|
|
NEED_WRITEAUTH_TRUE=
|
|
NEED_WRITEAUTH_FALSE='#'
|
|
else
|
|
NEED_WRITEAUTH_TRUE='#'
|
|
NEED_WRITEAUTH_FALSE=
|
|
fi
|
|
fi
|
|
CFLAGS=$save_CFLAGS
|
|
LIBS=$save_LIBS
|
|
LDFLAGS=$save_LDFLAGS
|
|
])
|
|
|
|
dnl
|
|
dnl $Id: capabilities.m4,v 1.2 1999/09/01 11:02:26 joda Exp $
|
|
dnl
|
|
|
|
dnl
|
|
dnl Test SGI capabilities
|
|
dnl
|
|
|
|
AC_DEFUN(KRB_CAPABILITIES,[
|
|
|
|
AC_CHECK_HEADERS(capability.h sys/capability.h)
|
|
|
|
AC_CHECK_FUNCS(sgi_getcapabilitybyname cap_set_proc)
|
|
])
|
|
|
|
dnl $Id: check-getpwnam_r-posix.m4,v 1.2 1999/03/23 16:47:31 joda Exp $
|
|
dnl
|
|
dnl check for getpwnam_r, and if it's posix or not
|
|
|
|
AC_DEFUN(AC_CHECK_GETPWNAM_R_POSIX,[
|
|
AC_FIND_FUNC_NO_LIBS(getpwnam_r,c_r)
|
|
if test "$ac_cv_func_getpwnam_r" = yes; then
|
|
AC_CACHE_CHECK(if getpwnam_r is posix,ac_cv_func_getpwnam_r_posix,
|
|
ac_libs="$LIBS"
|
|
LIBS="$LIBS $LIB_getpwnam_r"
|
|
AC_TRY_RUN([
|
|
#include <pwd.h>
|
|
int main()
|
|
{
|
|
struct passwd pw, *pwd;
|
|
return getpwnam_r("", &pw, NULL, 0, &pwd) < 0;
|
|
}
|
|
],ac_cv_func_getpwnam_r_posix=yes,ac_cv_func_getpwnam_r_posix=no,:)
|
|
LIBS="$ac_libs")
|
|
if test "$ac_cv_func_getpwnam_r_posix" = yes; then
|
|
AC_DEFINE(POSIX_GETPWNAM_R, 1, [Define if getpwnam_r has POSIX flavour.])
|
|
fi
|
|
fi
|
|
])
|
|
dnl $Id: grok-type.m4,v 1.4 1999/11/29 11:16:48 joda Exp $
|
|
dnl
|
|
AC_DEFUN(AC_GROK_TYPE, [
|
|
AC_CACHE_VAL(ac_cv_type_$1,
|
|
AC_TRY_COMPILE([
|
|
#ifdef HAVE_INTTYPES_H
|
|
#include <inttypes.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_BITYPES_H
|
|
#include <sys/bitypes.h>
|
|
#endif
|
|
#ifdef HAVE_BIND_BITYPES_H
|
|
#include <bind/bitypes.h>
|
|
#endif
|
|
#ifdef HAVE_NETINET_IN6_MACHTYPES_H
|
|
#include <netinet/in6_machtypes.h>
|
|
#endif
|
|
],
|
|
$i x;
|
|
,
|
|
eval ac_cv_type_$1=yes,
|
|
eval ac_cv_type_$1=no))])
|
|
|
|
AC_DEFUN(AC_GROK_TYPES, [
|
|
for i in $1; do
|
|
AC_MSG_CHECKING(for $i)
|
|
AC_GROK_TYPE($i)
|
|
eval ac_res=\$ac_cv_type_$i
|
|
if test "$ac_res" = yes; then
|
|
type=HAVE_[]upcase($i)
|
|
AC_DEFINE_UNQUOTED($type)
|
|
fi
|
|
AC_MSG_RESULT($ac_res)
|
|
done
|
|
])
|
|
|
|
dnl $Id: krb-readline.m4,v 1.2 2000/11/15 00:47:08 assar Exp $
|
|
dnl
|
|
dnl Tests for readline functions
|
|
dnl
|
|
|
|
dnl el_init
|
|
|
|
AC_DEFUN(KRB_READLINE,[
|
|
AC_FIND_FUNC_NO_LIBS(el_init, edit, [], [], [$LIB_tgetent])
|
|
if test "$ac_cv_func_el_init" = yes ; then
|
|
AC_CACHE_CHECK(for four argument el_init, ac_cv_func_el_init_four,[
|
|
AC_TRY_COMPILE([#include <stdio.h>
|
|
#include <histedit.h>],
|
|
[el_init("", NULL, NULL, NULL);],
|
|
ac_cv_func_el_init_four=yes,
|
|
ac_cv_func_el_init_four=no)])
|
|
if test "$ac_cv_func_el_init_four" = yes; then
|
|
AC_DEFINE(HAVE_FOUR_VALUED_EL_INIT, 1, [Define if el_init takes four arguments.])
|
|
fi
|
|
fi
|
|
|
|
dnl readline
|
|
|
|
ac_foo=no
|
|
if test "$with_readline" = yes; then
|
|
:
|
|
elif test "$ac_cv_func_readline" = yes; then
|
|
:
|
|
elif test "$ac_cv_func_el_init" = yes; then
|
|
ac_foo=yes
|
|
LIB_readline="\$(top_builddir)/lib/editline/libel_compat.la $LIB_el_init"
|
|
else
|
|
LIB_readline='$(top_builddir)/lib/editline/libeditline.la'
|
|
fi
|
|
AM_CONDITIONAL(el_compat, test "$ac_foo" = yes)
|
|
if test "$readline_libdir"; then
|
|
LIB_readline="-rpath $readline_libdir $LIB_readline"
|
|
fi
|
|
LIB_readline="$LIB_readline \$(LIB_tgetent)"
|
|
AC_DEFINE(HAVE_READLINE, 1,
|
|
[Define if you have a readline compatible library.])dnl
|
|
|
|
])
|
|
dnl $Id: auth-modules.m4,v 1.1 1999/03/21 13:48:00 joda Exp $
|
|
dnl
|
|
dnl Figure what authentication modules should be built
|
|
|
|
AC_DEFUN(AC_AUTH_MODULES,[
|
|
AC_MSG_CHECKING(which authentication modules should be built)
|
|
|
|
LIB_AUTH_SUBDIRS=
|
|
|
|
if test "$ac_cv_header_siad_h" = yes; then
|
|
LIB_AUTH_SUBDIRS="$LIB_AUTH_SUBDIRS sia"
|
|
fi
|
|
|
|
if test "$ac_cv_header_security_pam_modules_h" = yes -a "$enable_shared" = yes; then
|
|
LIB_AUTH_SUBDIRS="$LIB_AUTH_SUBDIRS pam"
|
|
fi
|
|
|
|
case "${host}" in
|
|
changequote(,)dnl
|
|
*-*-irix[56]*) LIB_AUTH_SUBDIRS="$LIB_AUTH_SUBDIRS afskauthlib" ;;
|
|
changequote([,])dnl
|
|
esac
|
|
|
|
AC_MSG_RESULT($LIB_AUTH_SUBDIRS)
|
|
|
|
AC_SUBST(LIB_AUTH_SUBDIRS)dnl
|
|
])
|
|
|