dnl aclocal.m4 generated automatically by aclocal 1.4

dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.

dnl This file is free software; the Free Software Foundation

dnl gives unlimited permission to copy and/or distribute it,

dnl with or without modifications, as long as this notice is preserved.

dnl This program is distributed in the hope that it will be useful,

dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without

dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A

dnl PARTICULAR PURPOSE.

# Like AC_CONFIG_HEADER, but automatically create stamp file.

AC_DEFUN(AM_CONFIG_HEADER,

[AC_PREREQ([2.12])

AC_CONFIG_HEADER([$1])

dnl When config.status generates a header, we must update the stamp-h file.

dnl This file resides in the same directory as the config header

dnl that is generated. We must strip everything past the first ":",

dnl and everything past the last "/".

AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl

ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>,

<<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^\([^:]*/\)?.*>>, <<\1>>)stamp-h<<>>dnl>>,

<<am_indx=1

for am_file in <<$1>>; do

case " <<$>>CONFIG_HEADERS " in

*" <<$>>am_file "*<<)>>

echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx

;;

esac

am_indx=`expr "<<$>>am_indx" + 1`

done<<>>dnl>>)

changequote([,]))])

# 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 1

dnl Usage:

dnl AM_INIT_AUTOMAKE(package,version, [no-define])

AC_DEFUN(AM_INIT_AUTOMAKE,

[AC_REQUIRE([AC_PROG_INSTALL])

PACKAGE=[$1]

AC_SUBST(PACKAGE)

VERSION=[$2]

AC_SUBST(VERSION)

dnl test to see if srcdir already configured

if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then

AC_MSG_ERROR([source directory already configured; run "make distclean" there first])

fi

ifelse([$3],,

AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])

AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))

AC_REQUIRE([AM_SANITY_CHECK])

AC_REQUIRE([AC_ARG_PROGRAM])

dnl FIXME This is truly gross.

missing_dir=`cd $ac_aux_dir && pwd`

AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)

AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)

AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)

AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)

AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)

AC_REQUIRE([AC_PROG_MAKE_SET])])

#

# 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)])

dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)

dnl The program must properly implement --version.

AC_DEFUN(AM_MISSING_PROG,

[AC_MSG_CHECKING(for working $2)

# Run test in a subshell; some versions of sh will print an error if

# an executable is not found, even if stderr is redirected.

# Redirect stdin to placate older versions of autoconf. Sigh.

if ($2 --version) < /dev/null > /dev/null 2>&1; then

$1=$2

AC_MSG_RESULT(found)

else

$1="$3/missing $2"

AC_MSG_RESULT(missing)

fi

AC_SUBST($1)])

# Add --enable-maintainer-mode option to configure.

# From Jim Meyering

# serial 1

AC_DEFUN(AM_MAINTAINER_MODE,

[AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])

dnl maintainer-mode is disabled by default

AC_ARG_ENABLE(maintainer-mode,

[ --enable-maintainer-mode enable make rules and dependencies not useful

(and sometimes confusing) to the casual installer],

USE_MAINTAINER_MODE=$enableval,

USE_MAINTAINER_MODE=no)

AC_MSG_RESULT($USE_MAINTAINER_MODE)

AM_CONDITIONAL(MAINTAINER_MODE, test $USE_MAINTAINER_MODE = yes)

MAINT=$MAINTAINER_MODE_TRUE

AC_SUBST(MAINT)dnl

]

)

# 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])

# serial 40 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.

CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \

LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \

LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" \

DLLTOOL="$DLLTOOL" AS="$AS" OBJDUMP="$OBJDUMP" \

${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \

$libtool_flags --no-verify $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_RANLIB])dnl

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_PROG_LD])dnl

AC_REQUIRE([AC_PROG_NM])dnl

AC_REQUIRE([AC_PROG_LN_S])dnl

dnl

# 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"

# 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)

;;

])

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_ENABLE_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_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])

ac_prog=`($CC -print-prog-name=ld) 2>&5`

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_SUBST(LD)

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])

])

# 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=.

if test -f $ac_dir/nm || test -f $ac_dir/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 ($ac_dir/nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then

ac_cv_path_NM="$ac_dir/nm -B"

break

elif ($ac_dir/nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then

ac_cv_path_NM="$ac_dir/nm -p"

break

else

ac_cv_path_NM=${ac_cv_path_NM="$ac_dir/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_SUBST(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, adds --enable-ltdl-convenience to

# the configure arguments. Note that LIBLTDL is not AC_SUBSTed, nor

# is AC_CONFIG_SUBDIRS called. If DIR is not provided, it is assumed

# to be `${top_builddir}/libltdl'. Make sure you start DIR with

# '${top_builddir}/' (note the single quotes!) if your package is not

# flat, and, if you're not using automake, define top_builddir as

# appropriate 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=ifelse($#,1,$1,['${top_builddir}/libltdl'])/libltdlc.la

INCLTDL=ifelse($#,1,-I$1,['-I${top_builddir}/libltdl'])

])

# AC_LIBLTDL_INSTALLABLE[(dir)] - sets LIBLTDL to the link flags for

# the libltdl installable library, and adds --enable-ltdl-install to

# the configure arguments. Note that LIBLTDL is not AC_SUBSTed, nor

# is AC_CONFIG_SUBDIRS called. If DIR is not provided, it is assumed

# to be `${top_builddir}/libltdl'. Make sure you start DIR with

# '${top_builddir}/' (note the single quotes!) if your package is not

# flat, and, if you're not using automake, define top_builddir as

# appropriate 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=ifelse($#,1,$1,['${top_builddir}/libltdl'])/libltdl.la

INCLTDL=ifelse($#,1,-I$1,['-I${top_builddir}/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

# Configure paths for GLIB

# Owen Taylor 97-11-3

dnl AM_PATH_GLIB([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, MODULES]]]])

dnl Test for GLIB, and define GLIB_CFLAGS and GLIB_LIBS, if "gmodule" or

dnl gthread is specified in MODULES, pass to glib-config

dnl

AC_DEFUN(AM_PATH_GLIB,

[dnl

dnl Get the cflags and libraries from the glib-config script

dnl

AC_ARG_WITH(glib-prefix,[ --with-glib-prefix=PFX Prefix where GLIB is installed (optional)],

glib_config_prefix="$withval", glib_config_prefix="")

AC_ARG_WITH(glib-exec-prefix,[ --with-glib-exec-prefix=PFX Exec prefix where GLIB is installed (optional)],

glib_config_exec_prefix="$withval", glib_config_exec_prefix="")

AC_ARG_ENABLE(glibtest, [ --disable-glibtest Do not try to compile and run a test GLIB program],

, enable_glibtest=yes)

if test x$glib_config_exec_prefix != x ; then

glib_config_args="$glib_config_args --exec-prefix=$glib_config_exec_prefix"

if test x${GLIB_CONFIG+set} != xset ; then

GLIB_CONFIG=$glib_config_exec_prefix/bin/glib-config

fi

fi

if test x$glib_config_prefix != x ; then

glib_config_args="$glib_config_args --prefix=$glib_config_prefix"

if test x${GLIB_CONFIG+set} != xset ; then

GLIB_CONFIG=$glib_config_prefix/bin/glib-config

fi

fi

for module in . $4

do

case "$module" in

gmodule)

glib_config_args="$glib_config_args gmodule"

;;

gthread)

glib_config_args="$glib_config_args gthread"

;;

esac

done

AC_PATH_PROG(GLIB_CONFIG, glib-config, no)

min_glib_version=ifelse([$1], ,0.99.7,$1)

AC_MSG_CHECKING(for GLIB - version >= $min_glib_version)

no_glib=""

if test "$GLIB_CONFIG" = "no" ; then

no_glib=yes

else

GLIB_CFLAGS=`$GLIB_CONFIG $glib_config_args --cflags`

GLIB_LIBS=`$GLIB_CONFIG $glib_config_args --libs`

glib_config_major_version=`$GLIB_CONFIG $glib_config_args --version | \

sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`

glib_config_minor_version=`$GLIB_CONFIG $glib_config_args --version | \

sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`

glib_config_micro_version=`$GLIB_CONFIG $glib_config_args --version | \

sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`

if test "x$enable_glibtest" = "xyes" ; then

ac_save_CFLAGS="$CFLAGS"

ac_save_LIBS="$LIBS"

CFLAGS="$CFLAGS $GLIB_CFLAGS"

LIBS="$GLIB_LIBS $LIBS"

dnl

dnl Now check if the installed GLIB is sufficiently new. (Also sanity

dnl checks the results of glib-config to some extent

dnl

rm -f conf.glibtest

AC_TRY_RUN([

#include <glib.h>

#include <stdio.h>

#include <stdlib.h>

int

main ()

{

int major, minor, micro;

char *tmp_version;

system ("touch conf.glibtest");

/* HP/UX 9 (%@#!) writes to sscanf strings */

tmp_version = g_strdup("$min_glib_version");

if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {

printf("%s, bad version string\n", "$min_glib_version");

exit(1);

}

if ((glib_major_version != $glib_config_major_version) ||

(glib_minor_version != $glib_config_minor_version) ||

(glib_micro_version != $glib_config_micro_version))

{

printf("\n*** 'glib-config --version' returned %d.%d.%d, but GLIB (%d.%d.%d)\n",

$glib_config_major_version, $glib_config_minor_version, $glib_config_micro_version,

glib_major_version, glib_minor_version, glib_micro_version);

printf ("*** was found! If glib-config was correct, then it is best\n");

printf ("*** to remove the old version of GLIB. You may also be able to fix the error\n");

printf("*** by modifying your LD_LIBRARY_PATH enviroment variable, or by editing\n");

printf("*** /etc/ld.so.conf. Make sure you have run ldconfig if that is\n");

printf("*** required on your system.\n");

printf("*** If glib-config was wrong, set the environment variable GLIB_CONFIG\n");

printf("*** to point to the correct copy of glib-config, and remove the file config.cache\n");

printf("*** before re-running configure\n");

}

else if ((glib_major_version != GLIB_MAJOR_VERSION) ||

(glib_minor_version != GLIB_MINOR_VERSION) ||

(glib_micro_version != GLIB_MICRO_VERSION))

{

printf("*** GLIB header files (version %d.%d.%d) do not match\n",

GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);

printf("*** library (version %d.%d.%d)\n",

glib_major_version, glib_minor_version, glib_micro_version);

}

else

{

if ((glib_major_version > major) ||

((glib_major_version == major) && (glib_minor_version > minor)) ||

((glib_major_version == major) && (glib_minor_version == minor) && (glib_micro_version >= micro)))

{

return 0;

}

else

{

printf("\n*** An old version of GLIB (%d.%d.%d) was found.\n",

glib_major_version, glib_minor_version, glib_micro_version);

printf("*** You need a version of GLIB newer than %d.%d.%d. The latest version of\n",

major, minor, micro);

printf("*** GLIB is always available from ftp://ftp.gtk.org.\n");

printf("***\n");

printf("*** If you have already installed a sufficiently new version, this error\n");

printf("*** probably means that the wrong copy of the glib-config shell script is\n");

printf("*** being found. The easiest way to fix this is to remove the old version\n");

printf("*** of GLIB, but you can also set the GLIB_CONFIG environment to point to the\n");

printf("*** correct copy of glib-config. (In this case, you will have to\n");

printf("*** modify your LD_LIBRARY_PATH enviroment variable, or edit /etc/ld.so.conf\n");

printf("*** so that the correct libraries are found at run-time))\n");

}

}

return 1;

}

],, no_glib=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])

CFLAGS="$ac_save_CFLAGS"

LIBS="$ac_save_LIBS"

fi

fi

if test "x$no_glib" = x ; then

AC_MSG_RESULT(yes)

ifelse([$2], , :, [$2])

else

AC_MSG_RESULT(no)

if test "$GLIB_CONFIG" = "no" ; then

echo "*** The glib-config script installed by GLIB could not be found"

echo "*** If GLIB was installed in PREFIX, make sure PREFIX/bin is in"

echo "*** your path, or set the GLIB_CONFIG environment variable to the"

echo "*** full path to glib-config."

else

if test -f conf.glibtest ; then

:

else

echo "*** Could not run GLIB test program, checking why..."

CFLAGS="$CFLAGS $GLIB_CFLAGS"

LIBS="$LIBS $GLIB_LIBS"

AC_TRY_LINK([

#include <glib.h>

#include <stdio.h>

], [ return ((glib_major_version) || (glib_minor_version) || (glib_micro_version)); ],

[ echo "*** The test program compiled, but did not run. This usually means"

echo "*** that the run-time linker is not finding GLIB or finding the wrong"

echo "*** version of GLIB. If it is not finding GLIB, you'll need to set your"

echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"

echo "*** to the installed location Also, make sure you have run ldconfig if that"

echo "*** is required on your system"

echo "***"

echo "*** If you have an old version installed, it is best to remove it, although"

echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"

echo "***"

echo "*** If you have a RedHat 5.0 system, you should remove the GTK package that"

echo "*** came with the system with the command"

echo "***"

echo "*** rpm --erase --nodeps gtk gtk-devel" ],

[ echo "*** The test program failed to compile or link. See the file config.log for the"

echo "*** exact error that occured. This usually means GLIB was incorrectly installed"

echo "*** or that you have moved GLIB since it was installed. In the latter case, you"

echo "*** may want to edit the glib-config script: $GLIB_CONFIG" ])

CFLAGS="$ac_save_CFLAGS"

LIBS="$ac_save_LIBS"

fi

fi

GLIB_CFLAGS=""

GLIB_LIBS=""

ifelse([$3], , :, [$3])

fi

AC_SUBST(GLIB_CFLAGS)

AC_SUBST(GLIB_LIBS)

rm -f conf.glibtest

])