# generated automatically by aclocal 1.11.1 -*- Autoconf -*-

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

# 2005, 2006, 2007, 2008, 2009  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.

m4_ifndef([AC_AUTOCONF_VERSION],

  [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl

m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.63],,

[m4_warning([this file was generated for autoconf 2.63.

You have another version of autoconf.  It may work, but is not guaranteed to.

If you have problems, you may need to regenerate the build system entirely.

To do so, use the procedure documented by the package, typically `autoreconf'.])])

# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-

#

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

])

# serial 56 LT_INIT

# 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

LIBTOOL_DEPS="$ltmain"

# Always use our own libtool.

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

AC_SUBST(LIBTOOL)dnl

_LT_SETUP

# 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

AC_REQUIRE([AC_CANONICAL_BUILD])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([AC_PROG_CC])dnl

AC_REQUIRE([LT_PATH_LD])dnl

AC_REQUIRE([LT_PATH_NM])dnl

dnl

AC_REQUIRE([AC_PROG_LN_S])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

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

_LT_CHECK_OBJDIR

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.

sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'

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

double_quote_subst='s/\([["`\\]]\)/\\\1/g'

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

ofile=libtool

can_build_shared=yes

# All known linkers require a `.a' archive for static linking (except MSVC,

# which needs '.lib').

libext=a

with_gnu_ld="$lt_cv_prog_gnu_ld"

old_CC="$CC"

old_CFLAGS="$CFLAGS"

# Set sane defaults for various variables

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

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

test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS

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

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

_LT_CC_BASENAME([$compiler])

# Only perform the check for file, if the check method requires it

test -z "$MAGIC_CMD" && MAGIC_CMD=file

case $deplibs_check_method in

file_magic*)

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

    _LT_PATH_MAGIC

  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

# 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], [[!?.]$], [], [.])

)])

# _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:

#

#    ='`$ECHO "X$" | $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

done

# 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"/'\`

  ;;

esac

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

Usage: $[0] [[OPTIONS]]

  -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

Report bugs to <bug-libtool@gnu.org>."

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)

fi

])# LT_OUTPUT

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

_LT_CONFIG_SAVE_COMMANDS([

  m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl

  m4_if(_LT_TAG, [C], [

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

    # commands through without removal of \ escapes.

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

      setopt NO_GLOB_SUBST

    fi

    cfgfile="${ofile}T"

    trap "$RM \"$cfgfile\"; exit 1" 1 2 15

    $RM "$cfgfile"

    cat <<_LT_EOF >> "$cfgfile"

#! $SHELL

# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.

# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION

# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:

# NOTE: Changes made to this file will be lost: look at ltmain.sh.

#

_LT_COPYING

_LT_LIBTOOL_TAGS

# ### BEGIN LIBTOOL CONFIG

_LT_LIBTOOL_CONFIG_VARS

_LT_LIBTOOL_TAG_VARS

# ### END LIBTOOL CONFIG

_LT_EOF

  case $host_os in

  aix3*)

    cat <<\_LT_EOF >> "$cfgfile"

# 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

_LT_EOF

    ;;

  esac

  _LT_PROG_LTMAIN

  # We use sed instead of cat because bash on DJGPP gets confused if

  # if finds mixed CR/LF and LF-only lines.  Since sed operates in

  # text mode, it properly converts lines to CR/LF.  This bash problem

  # is reportedly fixed, but why not run on old versions too?

  sed '/^# Generated shell functions inserted here/q' "$ltmain" >> "$cfgfile" \

    || (rm -f "$cfgfile"; exit 1)

  _LT_PROG_XSI_SHELLFNS

  sed -n '/^# Generated shell functions inserted here/,$p' "$ltmain" >> "$cfgfile" \

    || (rm -f "$cfgfile"; exit 1)

  mv -f "$cfgfile" "$ofile" ||

    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")

  chmod +x "$ofile"

],

[cat <<_LT_EOF >> "$ofile"

dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded

dnl in a comment (ie after a #).

# ### BEGIN LIBTOOL TAG CONFIG: $1

_LT_LIBTOOL_TAG_VARS(_LT_TAG)

# ### END LIBTOOL TAG CONFIG: $1

_LT_EOF

])dnl /m4_if

],

[m4_if([$1], [], [

    PACKAGE='$PACKAGE'

    VERSION='$VERSION'

    TIMESTAMP='$TIMESTAMP'

    RM='$RM'

    ofile='$ofile'], [])

])dnl /_LT_CONFIG_SAVE_COMMANDS

])# _LT_CONFIG

# LT_SUPPORTED_TAG(TAG)

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

# Trace this macro to discover what tags are supported by the libtool

# --tag option, using:

#    autoconf --trace 'LT_SUPPORTED_TAG:$1'

AC_DEFUN([LT_SUPPORTED_TAG], [])

# C support is built-in for now

m4_define([_LT_LANG_C_enabled], [])

m4_define([_LT_TAGS], [])

# LT_LANG(LANG)

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

# Enable libtool support for the given language if not already enabled.

AC_DEFUN([LT_LANG],

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

m4_case([$1],

  [C],			[_LT_LANG(C)],

  [C++],		[_LT_LANG(CXX)],

  [Java],		[_LT_LANG(GCJ)],

  [Fortran 77],		[_LT_LANG(F77)],

  [Fortran],		[_LT_LANG(FC)],

  [Windows Resource],	[_LT_LANG(RC)],

  [m4_ifdef([_LT_LANG_]$1[_CONFIG],

    [_LT_LANG($1)],

    [m4_fatal([$0: unsupported language: "$1"])])])dnl

])# LT_LANG

# _LT_LANG(LANGNAME)

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

m4_defun([_LT_LANG],

[m4_ifdef([_LT_LANG_]$1[_enabled], [],

  [LT_SUPPORTED_TAG([$1])dnl

  m4_append([_LT_TAGS], [$1 ])dnl

  m4_define([_LT_LANG_]$1[_enabled], [])dnl

  _LT_LANG_$1_CONFIG($1)])dnl

])# _LT_LANG

# _LT_LANG_DEFAULT_CONFIG

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

m4_defun([_LT_LANG_DEFAULT_CONFIG],

[AC_PROVIDE_IFELSE([AC_PROG_CXX],

  [LT_LANG(CXX)],

  [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])

AC_PROVIDE_IFELSE([AC_PROG_F77],

  [LT_LANG(F77)],

  [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])

AC_PROVIDE_IFELSE([AC_PROG_FC],

  [LT_LANG(FC)],

  [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])

dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal

dnl pulling things in needlessly.

AC_PROVIDE_IFELSE([AC_PROG_GCJ],

  [LT_LANG(GCJ)],

  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],

    [LT_LANG(GCJ)],

    [AC_PROVIDE_IFELSE([LT_PROG_GCJ],

      [LT_LANG(GCJ)],

      [m4_ifdef([AC_PROG_GCJ],

	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])

       m4_ifdef([A][M_PROG_GCJ],

	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])

       m4_ifdef([LT_PROG_GCJ],

	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])

AC_PROVIDE_IFELSE([LT_PROG_RC],

  [LT_LANG(RC)],

  [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])

])# _LT_LANG_DEFAULT_CONFIG

# Obsolete macros:

AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])

AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])

AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])

AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])

dnl aclocal-1.4 backwards compatibility:

dnl AC_DEFUN([AC_LIBTOOL_CXX], [])

dnl AC_DEFUN([AC_LIBTOOL_F77], [])

dnl AC_DEFUN([AC_LIBTOOL_FC], [])

dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])

# _LT_TAG_COMPILER

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

m4_defun([_LT_TAG_COMPILER],

[AC_REQUIRE([AC_PROG_CC])dnl

_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl

_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl

_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl

_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl

# If no C compiler was specified, use CC.

LTCC=${LTCC-"$CC"}

# If no C compiler flags were specified, use CFLAGS.

LTCFLAGS=${LTCFLAGS-"$CFLAGS"}

# Allow CC to be a program name with arguments.

compiler=$CC

])# _LT_TAG_COMPILER

# _LT_COMPILER_BOILERPLATE

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

# Check for compiler boilerplate output or warnings with

# the simple compiler test code.