define(AC_CHECK_DEFINE,[dnl

AC_CACHE_CHECK(for $1 in $2, ac_cv_define_$1,

AC_EGREP_CPP([YES_IS_DEFINED], [

#include <$2>

#ifdef $1

YES_IS_DEFINED

#endif

], ac_cv_define_$1=yes, ac_cv_define_$1=no)

)

if test "$ac_cv_define_$1" = "yes" ; then

AC_DEFINE(HAVE_$1)

fi

])dnl

AC_DEFINE(HAVE_$1)

dnl Configure Paths for Alsa

dnl Some modifications by Richard Boulton <richard-alsa@tartarus.org>

dnl Christopher Lansdown <lansdoct@cs.alfred.edu>

dnl Jaroslav Kysela <perex@suse.cz>

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

dnl Test for libasound, and define ALSA_CFLAGS and ALSA_LIBS as appropriate.

dnl enables arguments --with-alsa-prefix=

dnl --with-alsa-enc-prefix=

dnl

dnl For backwards compatibility, if ACTION_IF_NOT_FOUND is not specified,

dnl and the alsa libraries are not found, a fatal AC_MSG_ERROR() will result.

dnl

[dnl Save the original CFLAGS, LDFLAGS, and LIBS

alsa_save_CFLAGS="$CFLAGS"

alsa_save_LDFLAGS="$LDFLAGS"

alsa_save_LIBS="$LIBS"

alsa_found=yes

dnl

dnl Get the cflags and libraries for alsa

dnl

AC_ARG_WITH(alsa-prefix,

[ --with-alsa-prefix=PFX Prefix where Alsa library is installed(optional)],

[alsa_prefix="$withval"], [alsa_prefix=""])

AC_ARG_WITH(alsa-inc-prefix,

[ --with-alsa-inc-prefix=PFX Prefix where include libraries are (optional)],

[alsa_inc_prefix="$withval"], [alsa_inc_prefix=""])

dnl FIXME: this is not yet implemented

AC_ARG_ENABLE(alsatest,

[ --disable-alsatest Do not try to compile and run a test Alsa program],

[enable_alsatest=yes])

dnl Add any special include directories

AC_MSG_CHECKING(for ALSA CFLAGS)

if test "$alsa_inc_prefix" != "" ; then

ALSA_CFLAGS="$ALSA_CFLAGS -I$alsa_inc_prefix"

CFLAGS="$CFLAGS -I$alsa_inc_prefix"

fi

AC_MSG_RESULT($ALSA_CFLAGS)

dnl add any special lib dirs

AC_MSG_CHECKING(for ALSA LDFLAGS)

if test "$alsa_prefix" != "" ; then

ALSA_LIBS="$ALSA_LIBS -L$alsa_prefix"

LDFLAGS="$LDFLAGS $ALSA_LIBS"

fi

dnl add the alsa library

ALSA_LIBS="$ALSA_LIBS -lasound -lm -ldl -lpthread"

LIBS=`echo $LIBS | sed 's/-lm//'`

LIBS=`echo $LIBS | sed 's/-ldl//'`

LIBS=`echo $LIBS | sed 's/-lpthread//'`

LIBS=`echo $LIBS | sed 's/ //'`

LIBS="$ALSA_LIBS $LIBS"

AC_MSG_RESULT($ALSA_LIBS)

dnl Check for a working version of libasound that is of the right version.

min_alsa_version=ifelse([$1], ,0.1.1,$1)

AC_MSG_CHECKING(for libasound headers version >= $min_alsa_version)

no_alsa=""

alsa_min_major_version=`echo $min_alsa_version | \

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

alsa_min_minor_version=`echo $min_alsa_version | \

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

alsa_min_micro_version=`echo $min_alsa_version | \

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

AC_LANG_SAVE

AC_LANG_C

AC_TRY_COMPILE([

#include <alsa/asoundlib.h>

], [

/* ensure backward compatibility */

#if !defined(SND_LIB_MAJOR) && defined(SOUNDLIB_VERSION_MAJOR)

#define SND_LIB_MAJOR SOUNDLIB_VERSION_MAJOR

#endif

#if !defined(SND_LIB_MINOR) && defined(SOUNDLIB_VERSION_MINOR)

#define SND_LIB_MINOR SOUNDLIB_VERSION_MINOR

#endif

#if !defined(SND_LIB_SUBMINOR) && defined(SOUNDLIB_VERSION_SUBMINOR)

#define SND_LIB_SUBMINOR SOUNDLIB_VERSION_SUBMINOR

#endif

# if(SND_LIB_MAJOR > $alsa_min_major_version)

exit(0);

# else

# if(SND_LIB_MAJOR < $alsa_min_major_version)

# error not present

# endif

# if(SND_LIB_MINOR > $alsa_min_minor_version)

exit(0);

# else

# if(SND_LIB_MINOR < $alsa_min_minor_version)

# error not present

# endif

# if(SND_LIB_SUBMINOR < $alsa_min_micro_version)

# error not present

# endif

# endif

# endif

exit(0);

],

[AC_MSG_RESULT(found.)],

[AC_MSG_RESULT(not present.)

ifelse([$3], , [AC_MSG_ERROR(Sufficiently new version of libasound not found.)])

alsa_found=no]

)

AC_LANG_RESTORE

dnl Now that we know that we have the right version, let's see if we have the library and not just the headers.

AC_CHECK_LIB([asound], [snd_ctl_open],,

[ifelse([$3], , [AC_MSG_ERROR(No linkable libasound was found.)])

alsa_found=no]

)

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

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

LIBS=`echo $LIBS | sed 's/-lasound//g'`

LIBS=`echo $LIBS | sed 's/ //'`

LIBS="-lasound $LIBS"

fi

if test "x$alsa_found" = "xno" ; then

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

CFLAGS="$alsa_save_CFLAGS"

LDFLAGS="$alsa_save_LDFLAGS"

LIBS="$alsa_save_LIBS"

ALSA_CFLAGS=""

ALSA_LIBS=""

fi

dnl That should be it. Now just export out symbols:

AC_SUBST(ALSA_CFLAGS)

AC_SUBST(ALSA_LIBS)

])

#

# --- esd.m4 ---

#

# Configure paths for ESD

# Manish Singh 98-9-30

# stolen back from Frank Belew

# stolen from Manish Singh

# Shamelessly stolen from Owen Taylor

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

dnl Test for ESD, and define ESD_CFLAGS and ESD_LIBS

dnl

[dnl

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

dnl

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

esd_prefix="$withval", esd_prefix="")

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

esd_exec_prefix="$withval", esd_exec_prefix="")

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

, enable_esdtest=yes)

if test x$esd_exec_prefix != x ; then

esd_args="$esd_args --exec-prefix=$esd_exec_prefix"

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

ESD_CONFIG=$esd_exec_prefix/bin/esd-config

fi

fi

if test x$esd_prefix != x ; then

esd_args="$esd_args --prefix=$esd_prefix"

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

ESD_CONFIG=$esd_prefix/bin/esd-config

fi

fi

AC_PATH_PROG(ESD_CONFIG, esd-config, no)

min_esd_version=ifelse([$1], ,0.2.7,$1)

AC_MSG_CHECKING(for ESD - version >= $min_esd_version)

no_esd=""

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

no_esd=yes

else

ESD_CFLAGS=`$ESD_CONFIG $esdconf_args --cflags`

ESD_LIBS=`$ESD_CONFIG $esdconf_args --libs`

esd_major_version=`$ESD_CONFIG $esd_args --version | \

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

esd_minor_version=`$ESD_CONFIG $esd_args --version | \

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

esd_micro_version=`$ESD_CONFIG $esd_config_args --version | \

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

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

ac_save_CFLAGS="$CFLAGS"

ac_save_LIBS="$LIBS"

CFLAGS="$CFLAGS $ESD_CFLAGS"

LIBS="$LIBS $ESD_LIBS"

dnl

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

dnl checks the results of esd-config to some extent

dnl

rm -f conf.esdtest

AC_TRY_RUN([

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <esd.h>

char*

my_strdup (char *str)

{

char *new_str;

if (str)

{

new_str = malloc ((strlen (str) + 1) * sizeof(char));

strcpy (new_str, str);

}

else

new_str = NULL;

return new_str;

}

int main ()

{

int major, minor, micro;

char *tmp_version;

system ("touch conf.esdtest");

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

tmp_version = my_strdup("$min_esd_version");

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

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

exit(1);

}

if (($esd_major_version > major) ||

(($esd_major_version == major) && ($esd_minor_version > minor)) ||

(($esd_major_version == major) && ($esd_minor_version == minor) && ($esd_micro_version >= micro)))

{

return 0;

}

else

{

printf("\n*** 'esd-config --version' returned %d.%d.%d, but the minimum version\n", $esd_major_version, $esd_minor_version, $esd_micro_version);

printf("*** of ESD required is %d.%d.%d. If esd-config is correct, then it is\n", major, minor, micro);

printf("*** best to upgrade to the required version.\n");

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

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

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

return 1;

}

}

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

CFLAGS="$ac_save_CFLAGS"

LIBS="$ac_save_LIBS"

fi

fi

if test "x$no_esd" = x ; then

AC_MSG_RESULT(yes)

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

else

AC_MSG_RESULT(no)

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

echo "*** The esd-config script installed by ESD could not be found"

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

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

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

else

if test -f conf.esdtest ; then

:

else

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

CFLAGS="$CFLAGS $ESD_CFLAGS"

LIBS="$LIBS $ESD_LIBS"

AC_TRY_LINK([

#include <stdio.h>

#include <esd.h>

], [ return 0; ],

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

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

echo "*** version of ESD. If it is not finding ESD, 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 "*** The test program failed to compile or link. See the file config.log for the"

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

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

echo "*** may want to edit the esd-config script: $ESD_CONFIG" ])

CFLAGS="$ac_save_CFLAGS"

LIBS="$ac_save_LIBS"

fi

fi

ESD_CFLAGS=""

ESD_LIBS=""

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

fi

AC_SUBST(ESD_CFLAGS)

AC_SUBST(ESD_LIBS)

rm -f conf.esdtest

])

#

# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,

# 2006, 2007, 2008 Free Software Foundation, Inc.

# Written by Gordon Matzigkeit, 1996

#

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

m4_define([_LT_COPYING], [dnl

# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,

# 2006, 2007, 2008 Free Software Foundation, Inc.

# Written by Gordon Matzigkeit, 1996

#

# This file is part of GNU Libtool.

#

# GNU Libtool is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License as

# published by the Free Software Foundation; either version 2 of

# the License, or (at your option) any later version.

#

# As a special exception to the GNU General Public License,

# if you distribute this file as part of a program or library that

# is built using GNU Libtool, you may include this file under the

# same distribution terms that you use for the rest of that program.

#

# GNU Libtool is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with GNU Libtool; see the file COPYING. If not, a copy

# can be downloaded from http://www.gnu.org/licenses/gpl.html, or

# obtained by writing to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

])

# LT_PREREQ(VERSION)

# ------------------

# Complain and exit if this libtool version is less that VERSION.

m4_defun([LT_PREREQ],

[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,

[m4_default([$3],

[m4_fatal([Libtool version $1 or higher is required],

63)])],

[$2])])

# _LT_CHECK_BUILDDIR

# ------------------

# Complain if the absolute build directory name contains unusual characters

m4_defun([_LT_CHECK_BUILDDIR],

[case `pwd` in

*\ * | *\ *)

AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;

esac

])

# LT_INIT([OPTIONS])

# ------------------

AC_DEFUN([LT_INIT],

[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT

AC_BEFORE([$0], [LT_LANG])dnl

AC_BEFORE([$0], [LT_OUTPUT])dnl

AC_BEFORE([$0], [LTDL_INIT])dnl

m4_require([_LT_CHECK_BUILDDIR])dnl

dnl Autoconf doesn't catch unexpanded LT_ macros by default:

m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl

m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl

dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4

dnl unless we require an AC_DEFUNed macro:

AC_REQUIRE([LTOPTIONS_VERSION])dnl

AC_REQUIRE([LTSUGAR_VERSION])dnl

AC_REQUIRE([LTVERSION_VERSION])dnl

AC_REQUIRE([LTOBSOLETE_VERSION])dnl

m4_require([_LT_PROG_LTMAIN])dnl

dnl Parse OPTIONS

_LT_SET_OPTIONS([$0], [$1])

# This can be used to rebuild libtool when needed

# Always use our own libtool.

LIBTOOL='$(SHELL) $(top_builddir)/libtool'

AC_SUBST(LIBTOOL)dnl

# Only expand once:

m4_define([LT_INIT])

])# LT_INIT

# Old names:

AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])

AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])

dnl aclocal-1.4 backwards compatibility:

dnl AC_DEFUN([AC_PROG_LIBTOOL], [])

dnl AC_DEFUN([AM_PROG_LIBTOOL], [])

# _LT_CC_BASENAME(CC)

# -------------------

# Calculate cc_basename. Skip known compiler wrappers and cross-prefix.

m4_defun([_LT_CC_BASENAME],

[for cc_temp in $1""; do

case $cc_temp in

compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;

distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;

\-*) ;;

*) break;;

esac

done

cc_basename=`$ECHO "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`

])

# _LT_FILEUTILS_DEFAULTS

# ----------------------

# It is okay to use these file commands and assume they have been set

# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'.

m4_defun([_LT_FILEUTILS_DEFAULTS],

[: ${CP="cp -f"}

: ${MV="mv -f"}

: ${RM="rm -f"}

])# _LT_FILEUTILS_DEFAULTS

# _LT_SETUP

# ---------

m4_defun([_LT_SETUP],

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

_LT_DECL([], [host_alias], [0], [The host system])dnl

_LT_DECL([], [host], [0])dnl

_LT_DECL([], [host_os], [0])dnl

dnl

_LT_DECL([], [build_alias], [0], [The build system])dnl

_LT_DECL([], [build], [0])dnl

_LT_DECL([], [build_os], [0])dnl

dnl

AC_REQUIRE([LT_PATH_LD])dnl

AC_REQUIRE([LT_PATH_NM])dnl

dnl

test -z "$LN_S" && LN_S="ln -s"

_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl

dnl

AC_REQUIRE([LT_CMD_MAX_LEN])dnl

_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl

_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl

m4_require([_LT_FILEUTILS_DEFAULTS])dnl

m4_require([_LT_CHECK_SHELL_FEATURES])dnl

m4_require([_LT_CMD_RELOAD])dnl

m4_require([_LT_CHECK_MAGIC_METHOD])dnl

m4_require([_LT_CMD_OLD_ARCHIVE])dnl

m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl

_LT_CONFIG_LIBTOOL_INIT([

# See if we are running on zsh, and set the options which allow our

# commands through without removal of \ escapes INIT.

if test -n "\${ZSH_VERSION+set}" ; then

setopt NO_GLOB_SUBST

fi

])

if test -n "${ZSH_VERSION+set}" ; then

setopt NO_GLOB_SUBST

fi

m4_require([_LT_TAG_COMPILER])dnl

_LT_PROG_ECHO_BACKSLASH

case $host_os in

aix3*)

# AIX sometimes has problems with the GCC collect2 program. For some

# reason, if we set the COLLECT_NAMES environment variable, the problems

# vanish in a puff of smoke.

if test "X${COLLECT_NAMES+set}" != Xset; then

COLLECT_NAMES=

export COLLECT_NAMES

fi

;;

esac

# Sed substitution that helps us do robust quoting. It backslashifies

# metacharacters that are still active within double-quoted strings.

# Same as above, but do not quote variable references.

# Sed substitution to delay expansion of an escaped shell variable in a

# double_quote_subst'ed string.

delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'

# Sed substitution to delay expansion of an escaped single quote.

delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'

# Sed substitution to avoid accidental globbing in evaled expressions

no_glob_subst='s/\*/\\\*/g'

# Global variables:

can_build_shared=yes

# which needs '.lib').

libext=a

old_CC="$CC"

old_CFLAGS="$CFLAGS"

# Set sane defaults for various variables

test -z "$CC" && CC=cc

test -z "$LTCC" && LTCC=$CC

test -z "$LD" && LD=ld

test -z "$ac_objext" && ac_objext=o

case $deplibs_check_method in

file_magic*)

if test "$file_magic_cmd" = '$MAGIC_CMD'; then

fi

;;

esac

# Use C for the default configuration in the libtool script

LT_SUPPORTED_TAG([CC])

_LT_LANG_C_CONFIG

_LT_LANG_DEFAULT_CONFIG

_LT_CONFIG_COMMANDS

])# _LT_SETUP

# _LT_PROG_LTMAIN

# ---------------

# Note that this code is called both from `configure', and `config.status'

# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably,

# `config.status' has no value for ac_aux_dir unless we are using Automake,

# so we pass a copy along to make sure it has a sensible value anyway.

m4_defun([_LT_PROG_LTMAIN],

[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl

_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])

ltmain="$ac_aux_dir/ltmain.sh"

])# _LT_PROG_LTMAIN

## ------------------------------------- ##

## Accumulate code for creating libtool. ##

## ------------------------------------- ##

# So that we can recreate a full libtool script including additional

# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS

# in macros and then make a single call at the end using the `libtool'

# label.

# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])

# ----------------------------------------

# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.

m4_define([_LT_CONFIG_LIBTOOL_INIT],

[m4_ifval([$1],

[m4_append([_LT_OUTPUT_LIBTOOL_INIT],

[$1

])])])

# Initialize.

m4_define([_LT_OUTPUT_LIBTOOL_INIT])

# _LT_CONFIG_LIBTOOL([COMMANDS])

# ------------------------------

# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.

m4_define([_LT_CONFIG_LIBTOOL],

[m4_ifval([$1],

[m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],

[$1

])])])

# Initialize.

m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])

# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])

# -----------------------------------------------------

m4_defun([_LT_CONFIG_SAVE_COMMANDS],

[_LT_CONFIG_LIBTOOL([$1])

_LT_CONFIG_LIBTOOL_INIT([$2])

])

# _LT_FORMAT_COMMENT([COMMENT])

# -----------------------------

# Add leading comment marks to the start of each line, and a trailing

# full-stop to the whole comment if one is not present already.

m4_define([_LT_FORMAT_COMMENT],

[m4_ifval([$1], [

m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],

[['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])

)])

## ------------------------ ##

## FIXME: Eliminate VARNAME ##

## ------------------------ ##

# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])

# -------------------------------------------------------------------

# CONFIGNAME is the name given to the value in the libtool script.

# VARNAME is the (base) name used in the configure script.

# VALUE may be 0, 1 or 2 for a computed quote escaped value based on

# VARNAME. Any other value will be used directly.

m4_define([_LT_DECL],

[lt_if_append_uniq([lt_decl_varnames], [$2], [, ],

[lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],

[m4_ifval([$1], [$1], [$2])])

lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])

m4_ifval([$4],

[lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])

lt_dict_add_subkey([lt_decl_dict], [$2],

[tagged?], [m4_ifval([$5], [yes], [no])])])

])

# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])

# --------------------------------------------------------

m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])

# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])

# ------------------------------------------------

m4_define([lt_decl_tag_varnames],

[_lt_decl_filter([tagged?], [yes], $@)])

# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])

# ---------------------------------------------------------

m4_define([_lt_decl_filter],

[m4_case([$#],

[0], [m4_fatal([$0: too few arguments: $#])],

[1], [m4_fatal([$0: too few arguments: $#: $1])],

[2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],

[3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],

[lt_dict_filter([lt_decl_dict], $@)])[]dnl

])

# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])

# --------------------------------------------------

m4_define([lt_decl_quote_varnames],

[_lt_decl_filter([value], [1], $@)])

# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])

# ---------------------------------------------------

m4_define([lt_decl_dquote_varnames],

[_lt_decl_filter([value], [2], $@)])

# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])

# ---------------------------------------------------

m4_define([lt_decl_varnames_tagged],

[m4_assert([$# <= 2])dnl

_$0(m4_quote(m4_default([$1], [[, ]])),

m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),

m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])

m4_define([_lt_decl_varnames_tagged],

[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])

# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])

# ------------------------------------------------

m4_define([lt_decl_all_varnames],

[_$0(m4_quote(m4_default([$1], [[, ]])),

m4_if([$2], [],

m4_quote(lt_decl_varnames),

m4_quote(m4_shift($@))))[]dnl

])

m4_define([_lt_decl_all_varnames],

[lt_join($@, lt_decl_varnames_tagged([$1],

lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl

])

# _LT_CONFIG_STATUS_DECLARE([VARNAME])

# ------------------------------------

# Quote a variable value, and forward it to `config.status' so that its

# declaration there will have the same value as in `configure'. VARNAME

# must have a single quote delimited value for this to work.

m4_define([_LT_CONFIG_STATUS_DECLARE],

[$1='`$ECHO "X$][$1" | $Xsed -e "$delay_single_quote_subst"`'])

# _LT_CONFIG_STATUS_DECLARATIONS

# ------------------------------

# We delimit libtool config variables with single quotes, so when

# we write them to config.status, we have to be sure to quote all

# embedded single quotes properly. In configure, this macro expands

# each variable declared with _LT_DECL (and _LT_TAGDECL) into:

#

# <var>='`$ECHO "X$<var>" | $Xsed -e "$delay_single_quote_subst"`'

m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],

[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),

[m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])

# _LT_LIBTOOL_TAGS

# ----------------

# Output comment and list of tags supported by the script

m4_defun([_LT_LIBTOOL_TAGS],

[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl

available_tags="_LT_TAGS"dnl

])

# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])

# -----------------------------------

# Extract the dictionary values for VARNAME (optionally with TAG) and

# expand to a commented shell variable setting:

#

# # Some comment about what VAR is for.

# visible_name=$lt_internal_name

m4_define([_LT_LIBTOOL_DECLARE],

[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],

[description])))[]dnl

m4_pushdef([_libtool_name],

m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl

m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),

[0], [_libtool_name=[$]$1],

[1], [_libtool_name=$lt_[]$1],

[2], [_libtool_name=$lt_[]$1],

[_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl

m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl

])

# _LT_LIBTOOL_CONFIG_VARS

# -----------------------

# Produce commented declarations of non-tagged libtool config variables

# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'

# script. Tagged libtool config variables (even for the LIBTOOL CONFIG

# section) are produced by _LT_LIBTOOL_TAG_VARS.

m4_defun([_LT_LIBTOOL_CONFIG_VARS],

[m4_foreach([_lt_var],

m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),

[m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])

# _LT_LIBTOOL_TAG_VARS(TAG)

# -------------------------

m4_define([_LT_LIBTOOL_TAG_VARS],

[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),

[m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])

# _LT_TAGVAR(VARNAME, [TAGNAME])

# ------------------------------

m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])

# _LT_CONFIG_COMMANDS

# -------------------

# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of

# variables for single and double quote escaping we saved from calls

# to _LT_DECL, we can put quote escaped variables declarations

# into `config.status', and then the shell code to quote escape them in

# for loops in `config.status'. Finally, any additional code accumulated

# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.

m4_defun([_LT_CONFIG_COMMANDS],

[AC_PROVIDE_IFELSE([LT_OUTPUT],

dnl If the libtool generation code has been placed in $CONFIG_LT,

dnl instead of duplicating it all over again into config.status,

dnl then we will have config.status run $CONFIG_LT later, so it

dnl needs to know what name is stored there:

[AC_CONFIG_COMMANDS([libtool],

[$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],

dnl If the libtool generation code is destined for config.status,

dnl expand the accumulated commands and init code now:

[AC_CONFIG_COMMANDS([libtool],

[_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])

])#_LT_CONFIG_COMMANDS

# Initialize.

m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],

[

# The HP-UX ksh and POSIX shell print the target directory to stdout

# if CDPATH is set.

(unset CDPATH) >/dev/null 2>&1 && unset CDPATH

sed_quote_subst='$sed_quote_subst'

double_quote_subst='$double_quote_subst'

delay_variable_subst='$delay_variable_subst'

_LT_CONFIG_STATUS_DECLARATIONS

LTCC='$LTCC'

LTCFLAGS='$LTCFLAGS'

compiler='$compiler_DEFAULT'

# Quote evaled strings.

for var in lt_decl_all_varnames([[ \

]], lt_decl_quote_varnames); do

case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in

*[[\\\\\\\`\\"\\\$]]*)

eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""

*)

eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""

;;

esac

done

# Double-quote double-evaled strings.

for var in lt_decl_all_varnames([[ \

]], lt_decl_dquote_varnames); do

case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in

*[[\\\\\\\`\\"\\\$]]*)

eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""

*)

eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""

;;

esac

# Fix-up fallback echo if it was mangled by the above quoting rules.

case \$lt_ECHO in

*'\\\[$]0 --fallback-echo"')dnl "

lt_ECHO=\`\$ECHO "X\$lt_ECHO" | \$Xsed -e 's/\\\\\\\\\\\\\\\[$]0 --fallback-echo"\[$]/\[$]0 --fallback-echo"/'\`

_LT_OUTPUT_LIBTOOL_INIT

])

# LT_OUTPUT

# ---------

# This macro allows early generation of the libtool script (before

# AC_OUTPUT is called), incase it is used in configure for compilation

# tests.

AC_DEFUN([LT_OUTPUT],

[: ${CONFIG_LT=./config.lt}

AC_MSG_NOTICE([creating $CONFIG_LT])

cat >"$CONFIG_LT" <<_LTEOF

#! $SHELL

# Generated by $as_me.

# Run this file to recreate a libtool stub with the current configuration.

lt_cl_silent=false

SHELL=\${CONFIG_SHELL-$SHELL}

_LTEOF

cat >>"$CONFIG_LT" <<\_LTEOF

AS_SHELL_SANITIZE

_AS_PREPARE

exec AS_MESSAGE_FD>&1

exec AS_MESSAGE_LOG_FD>>config.log

{

echo

AS_BOX([Running $as_me.])

} >&AS_MESSAGE_LOG_FD

lt_cl_help="\

\`$as_me' creates a local libtool stub from the current configuration,

for use in further configure time tests before the real libtool is

generated.

-h, --help print this help, then exit

-V, --version print version number, then exit

-q, --quiet do not print progress messages

-d, --debug don't remove temporary files

lt_cl_version="\

m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl

m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])

configured by $[0], generated by m4_PACKAGE_STRING.

Copyright (C) 2008 Free Software Foundation, Inc.

This config.lt script is free software; the Free Software Foundation

gives unlimited permision to copy, distribute and modify it."

while test $[#] != 0

do

case $[1] in

--version | --v* | -V )

echo "$lt_cl_version"; exit 0 ;;

--help | --h* | -h )

echo "$lt_cl_help"; exit 0 ;;

--debug | --d* | -d )

debug=: ;;

--quiet | --q* | --silent | --s* | -q )

lt_cl_silent=: ;;

-*) AC_MSG_ERROR([unrecognized option: $[1]

Try \`$[0] --help' for more information.]) ;;

*) AC_MSG_ERROR([unrecognized argument: $[1]

Try \`$[0] --help' for more information.]) ;;

esac

shift

done

if $lt_cl_silent; then

exec AS_MESSAGE_FD>/dev/null

fi

_LTEOF

cat >>"$CONFIG_LT" <<_LTEOF

_LT_OUTPUT_LIBTOOL_COMMANDS_INIT

_LTEOF

cat >>"$CONFIG_LT" <<\_LTEOF

AC_MSG_NOTICE([creating $ofile])

_LT_OUTPUT_LIBTOOL_COMMANDS

AS_EXIT(0)

_LTEOF

chmod +x "$CONFIG_LT"

# configure is writing to config.log, but config.lt does its own redirection,

# appending to config.log, which fails on DOS, as config.log is still kept

# open by configure. Here we exec the FD to /dev/null, effectively closing

# config.log, so it can be properly (re)opened and appended to by config.lt.

if test "$no_create" != yes; then

lt_cl_success=:

test "$silent" = yes &&

lt_config_lt_args="$lt_config_lt_args --quiet"

exec AS_MESSAGE_LOG_FD>/dev/null

$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false

exec AS_MESSAGE_LOG_FD>>config.log

$lt_cl_success || AS_EXIT(1)

# _LT_CONFIG(TAG)

# ---------------

# If TAG is the built-in tag, create an initial libtool script with a

# default configuration from the untagged config vars. Otherwise add code

# to config.status for appending the configuration named by TAG from the

# matching tagged config vars.

m4_defun([_LT_CONFIG],

[m4_require([_LT_FILEUTILS_DEFAULTS])dnl