Origo OS

# 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.65],,

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

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:

#

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

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.

m4_defun([_LT_COMPILER_BOILERPLATE],

[m4_require([_LT_DECL_SED])dnl

ac_outfile=conftest.$ac_objext

echo "$lt_simple_compile_test_code" >conftest.$ac_ext

eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

_lt_compiler_boilerplate=`cat conftest.err`

$RM conftest*

])# _LT_COMPILER_BOILERPLATE

# _LT_LINKER_BOILERPLATE

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

# Check for linker boilerplate output or warnings with

# the simple link test code.

m4_defun([_LT_LINKER_BOILERPLATE],

[m4_require([_LT_DECL_SED])dnl

ac_outfile=conftest.$ac_objext

echo "$lt_simple_link_test_code" >conftest.$ac_ext

eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err

_lt_linker_boilerplate=`cat conftest.err`

$RM -r conftest*

])# _LT_LINKER_BOILERPLATE

# _LT_REQUIRED_DARWIN_CHECKS

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

m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[

  case $host_os in

    rhapsody* | darwin*)

    AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])

    AC_CHECK_TOOL([NMEDIT], [nmedit], [:])

    AC_CHECK_TOOL([LIPO], [lipo], [:])

    AC_CHECK_TOOL([OTOOL], [otool], [:])

    AC_CHECK_TOOL([OTOOL64], [otool64], [:])

    _LT_DECL([], [DSYMUTIL], [1],

      [Tool to manipulate archived DWARF debug symbol files on Mac OS X])

    _LT_DECL([], [NMEDIT], [1],

      [Tool to change global to local symbols on Mac OS X])

    _LT_DECL([], [LIPO], [1],

      [Tool to manipulate fat objects and archives on Mac OS X])

    _LT_DECL([], [OTOOL], [1],

      [ldd/readelf like tool for Mach-O binaries on Mac OS X])

    _LT_DECL([], [OTOOL64], [1],

      [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])

    AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],

      [lt_cv_apple_cc_single_mod=no

      if test -z "${LT_MULTI_MODULE}"; then

	# By default we will add the -single_module flag. You can override

	# by either setting the environment variable LT_MULTI_MODULE

	# non-empty at configure time, or by adding -multi_module to the

	# link flags.

	rm -rf libconftest.dylib*

	echo "int foo(void){return 1;}" > conftest.c

	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \

-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD

	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \

	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err

        _lt_result=$?

	if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then

	  lt_cv_apple_cc_single_mod=yes

	else

	  cat conftest.err >&AS_MESSAGE_LOG_FD

	fi

	rm -rf libconftest.dylib*

	rm -f conftest.*

      fi])

    AC_CACHE_CHECK([for -exported_symbols_list linker flag],

      [lt_cv_ld_exported_symbols_list],

      [lt_cv_ld_exported_symbols_list=no

      save_LDFLAGS=$LDFLAGS

      echo "_main" > conftest.sym

      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"

      AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],

	[lt_cv_ld_exported_symbols_list=yes],

	[lt_cv_ld_exported_symbols_list=no])

	LDFLAGS="$save_LDFLAGS"

    ])

    case $host_os in

    rhapsody* | darwin1.[[012]])

      _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;

    darwin1.*)

      _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;

    darwin*) # darwin 5.x on

      # if running on 10.5 or later, the deployment target defaults

      # to the OS version, if on x86, and 10.4, the deployment

      # target defaults to 10.4. Don't you love it?

      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in

	10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)

	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;

	10.[[012]]*)

	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;

	10.*)

	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;

      esac

    ;;

  esac

    if test "$lt_cv_apple_cc_single_mod" = "yes"; then

      _lt_dar_single_mod='$single_module'

    fi

    if test "$lt_cv_ld_exported_symbols_list" = "yes"; then

      _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'

    else

      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'

    fi

    if test "$DSYMUTIL" != ":"; then

      _lt_dsymutil='~$DSYMUTIL $lib || :'

    else

      _lt_dsymutil=

    fi

    ;;

  esac

])

# _LT_DARWIN_LINKER_FEATURES

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

# Checks for linker and compiler features on darwin

m4_defun([_LT_DARWIN_LINKER_FEATURES],

[

  m4_require([_LT_REQUIRED_DARWIN_CHECKS])

  _LT_TAGVAR(archive_cmds_need_lc, $1)=no

  _LT_TAGVAR(hardcode_direct, $1)=no

  _LT_TAGVAR(hardcode_automatic, $1)=yes

  _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

  _LT_TAGVAR(whole_archive_flag_spec, $1)=''

  _LT_TAGVAR(link_all_deplibs, $1)=yes

  _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"

  case $cc_basename in

     ifort*) _lt_dar_can_shared=yes ;;

     *) _lt_dar_can_shared=$GCC ;;

  esac

  if test "$_lt_dar_can_shared" = "yes"; then

    output_verbose_link_cmd=echo

    _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"

    _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"

    _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"

    _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"

    m4_if([$1], [CXX],

[   if test "$lt_cv_apple_cc_single_mod" != "yes"; then

      _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"

      _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"

    fi

],[])

  else

  _LT_TAGVAR(ld_shlibs, $1)=no

  fi

])

# _LT_SYS_MODULE_PATH_AIX

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

# Links a minimal program and checks the executable

# for the system default hardcoded library path. In most cases,

# this is /usr/lib:/lib, but when the MPI compilers are used

# the location of the communication and MPI libs are included too.

# If we don't find anything, use the default library path according

# to the aix ld manual.

m4_defun([_LT_SYS_MODULE_PATH_AIX],

[m4_require([_LT_DECL_SED])dnl

AC_LINK_IFELSE(AC_LANG_PROGRAM,[

lt_aix_libpath_sed='

    /Import File Strings/,/^$/ {

	/^0/ {

	    s/^0  *\(.*\)$/\1/

	    p

	}

    }'

aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

# Check for a 64-bit object if we didn't find anything.

if test -z "$aix_libpath"; then

  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

fi],[])

if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi

])# _LT_SYS_MODULE_PATH_AIX

# _LT_SHELL_INIT(ARG)

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

m4_define([_LT_SHELL_INIT],

[ifdef([AC_DIVERSION_NOTICE],

	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

	 [AC_DIVERT_PUSH(NOTICE)])

$1

AC_DIVERT_POP

])# _LT_SHELL_INIT

# _LT_PROG_ECHO_BACKSLASH

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

# Add some code to the start of the generated configure script which

# will find an echo command which doesn't interpret backslashes.

m4_defun([_LT_PROG_ECHO_BACKSLASH],

[_LT_SHELL_INIT([

# Check that we are running under the correct shell.

SHELL=${CONFIG_SHELL-/bin/sh}

case X$lt_ECHO in

X*--fallback-echo)

  # Remove one level of quotation (which was required for Make).

  ECHO=`echo "$lt_ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`

  ;;

esac

ECHO=${lt_ECHO-echo}

if test "X[$]1" = X--no-reexec; then

  # Discard the --no-reexec flag, and continue.

  shift

elif test "X[$]1" = X--fallback-echo; then

  # Avoid inline document here, it may be left over

  :

elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' ; then

  # Yippee, $ECHO works!

  :

else

  # Restart under the correct shell.

  exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}

fi

if test "X[$]1" = X--fallback-echo; then

  # used as fallback echo

  shift

  cat <<_LT_EOF

[$]*

_LT_EOF

  exit 0

fi

# 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

if test -z "$lt_ECHO"; then

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

    # find a string as large as possible, as long as the shell can cope with it

    for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do

      # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...

      if { echo_test_string=`eval $cmd`; } 2>/dev/null &&

	 { test "X$echo_test_string" = "X$echo_test_string"; } 2>/dev/null

      then

        break

      fi

    done

  fi

  if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&

     echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&

     test "X$echo_testing_string" = "X$echo_test_string"; then

    :

  else

    # The Solaris, AIX, and Digital Unix default echo programs unquote

    # backslashes.  This makes it impossible to quote backslashes using

    #   echo "$something" | sed 's/\\/\\\\/g'

    #

    # So, first we look for a working echo in the user's PATH.

    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

    for dir in $PATH /usr/ucb; do

      IFS="$lt_save_ifs"

      if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&

         test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&

         echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&

         test "X$echo_testing_string" = "X$echo_test_string"; then

        ECHO="$dir/echo"

        break

      fi

    done

    IFS="$lt_save_ifs"

    if test "X$ECHO" = Xecho; then

      # We didn't find a better echo, so look for alternatives.

      if test "X`{ print -r '\t'; } 2>/dev/null`" = 'X\t' &&

         echo_testing_string=`{ print -r "$echo_test_string"; } 2>/dev/null` &&

         test "X$echo_testing_string" = "X$echo_test_string"; then

        # This shell has a builtin print -r that does the trick.

        ECHO='print -r'

      elif { test -f /bin/ksh || test -f /bin/ksh$ac_exeext; } &&

	   test "X$CONFIG_SHELL" != X/bin/ksh; then

        # If we have ksh, try running configure again with it.

        ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

        export ORIGINAL_CONFIG_SHELL

        CONFIG_SHELL=/bin/ksh

        export CONFIG_SHELL

        exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}

      else

        # Try using printf.

        ECHO='printf %s\n'

        if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&

	   echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&

	   test "X$echo_testing_string" = "X$echo_test_string"; then

	  # Cool, printf works

	  :

        elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

	     test "X$echo_testing_string" = 'X\t' &&

	     echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

	     test "X$echo_testing_string" = "X$echo_test_string"; then

	  CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL

	  export CONFIG_SHELL

	  SHELL="$CONFIG_SHELL"

	  export SHELL

	  ECHO="$CONFIG_SHELL [$]0 --fallback-echo"

        elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&

	     test "X$echo_testing_string" = 'X\t' &&

	     echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&

	     test "X$echo_testing_string" = "X$echo_test_string"; then

	  ECHO="$CONFIG_SHELL [$]0 --fallback-echo"

        else

	  # maybe with a smaller string...

	  prev=:

	  for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do

	    if { test "X$echo_test_string" = "X`eval $cmd`"; } 2>/dev/null

	    then

	      break

	    fi

	    prev="$cmd"

	  done

	  if test "$prev" != 'sed 50q "[$]0"'; then

	    echo_test_string=`eval $prev`

	    export echo_test_string

	    exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}

	  else

	    # Oops.  We lost completely, so just stick with echo.

	    ECHO=echo

	  fi

        fi

      fi

    fi

  fi

fi

# Copy echo and quote the copy suitably for passing to libtool from

# the Makefile, instead of quoting the original, which is used later.

lt_ECHO=$ECHO

if test "X$lt_ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then

   lt_ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"

fi

AC_SUBST(lt_ECHO)

])

_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])

_LT_DECL([], [ECHO], [1],

    [An echo program that does not interpret backslashes])

])# _LT_PROG_ECHO_BACKSLASH

# _LT_ENABLE_LOCK

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

m4_defun([_LT_ENABLE_LOCK],

[AC_ARG_ENABLE([libtool-lock],

  [AS_HELP_STRING([--disable-libtool-lock],

    [avoid locking (might break parallel builds)])])

test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes

# Some flags need to be propagated to the compiler or linker for good

# libtool support.

case $host in

ia64-*-hpux*)

  # Find out which ABI we are using.

  echo 'int i;' > conftest.$ac_ext

  if AC_TRY_EVAL(ac_compile); then

    case `/usr/bin/file conftest.$ac_objext` in

      *ELF-32*)

	HPUX_IA64_MODE="32"

	;;

      *ELF-64*)

	HPUX_IA64_MODE="64"

	;;

    esac

  fi

  rm -rf conftest*

  ;;

*-*-irix6*)

  # Find out which ABI we are using.

  echo '[#]line __oline__ "configure"' > conftest.$ac_ext

  if AC_TRY_EVAL(ac_compile); then

    if test "$lt_cv_prog_gnu_ld" = yes; then

      case `/usr/bin/file conftest.$ac_objext` in

	*32-bit*)

	  LD="${LD-ld} -melf32bsmip"

	  ;;

	*N32*)

	  LD="${LD-ld} -melf32bmipn32"

	  ;;

	*64-bit*)

	  LD="${LD-ld} -melf64bmip"

	;;

      esac

    else

      case `/usr/bin/file conftest.$ac_objext` in

	*32-bit*)

	  LD="${LD-ld} -32"

	  ;;

	*N32*)

	  LD="${LD-ld} -n32"

	  ;;

	*64-bit*)

	  LD="${LD-ld} -64"

	  ;;

      esac

    fi

  fi

  rm -rf conftest*

  ;;

x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \

s390*-*linux*|s390*-*tpf*|sparc*-*linux*)

  # Find out which ABI we are using.

  echo 'int i;' > conftest.$ac_ext

  if AC_TRY_EVAL(ac_compile); then

    case `/usr/bin/file conftest.o` in

      *32-bit*)

	case $host in

	  x86_64-*kfreebsd*-gnu)

	    LD="${LD-ld} -m elf_i386_fbsd"

	    ;;

	  x86_64-*linux*)

	    LD="${LD-ld} -m elf_i386"

	    ;;

	  ppc64-*linux*|powerpc64-*linux*)

	    LD="${LD-ld} -m elf32ppclinux"

	    ;;

	  s390x-*linux*)

	    LD="${LD-ld} -m elf_s390"

	    ;;

	  sparc64-*linux*)

	    LD="${LD-ld} -m elf32_sparc"

	    ;;

	esac

	;;

      *64-bit*)

	case $host in

	  x86_64-*kfreebsd*-gnu)

	    LD="${LD-ld} -m elf_x86_64_fbsd"

	    ;;

	  x86_64-*linux*)

	    LD="${LD-ld} -m elf_x86_64"

	    ;;

	  ppc*-*linux*|powerpc*-*linux*)

	    LD="${LD-ld} -m elf64ppc"

	    ;;

	  s390*-*linux*|s390*-*tpf*)

	    LD="${LD-ld} -m elf64_s390"

	    ;;

	  sparc*-*linux*)

	    LD="${LD-ld} -m elf64_sparc"

	    ;;

	esac

	;;

    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_PUSH(C)

     AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])

     AC_LANG_POP])

  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

  ;;

sparc*-*solaris*)

  # Find out which ABI we are using.

  echo 'int i;' > conftest.$ac_ext

  if AC_TRY_EVAL(ac_compile); then

    case `/usr/bin/file conftest.o` in

    *64-bit*)

      case $lt_cv_prog_gnu_ld in

      yes*) LD="${LD-ld} -m elf64_sparc" ;;

      *)

	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then

	  LD="${LD-ld} -64"

	fi

	;;

      esac

      ;;

    esac

  fi

  rm -rf conftest*

  ;;

esac

need_locks="$enable_libtool_lock"

])# _LT_ENABLE_LOCK

# _LT_CMD_OLD_ARCHIVE

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

m4_defun([_LT_CMD_OLD_ARCHIVE],

[AC_CHECK_TOOL(AR, ar, false)

test -z "$AR" && AR=ar

test -z "$AR_FLAGS" && AR_FLAGS=cru

_LT_DECL([], [AR], [1], [The archiver])

_LT_DECL([], [AR_FLAGS], [1])

AC_CHECK_TOOL(STRIP, strip, :)

test -z "$STRIP" && STRIP=:

_LT_DECL([], [STRIP], [1], [A symbol stripping program])

AC_CHECK_TOOL(RANLIB, ranlib, :)

test -z "$RANLIB" && RANLIB=:

_LT_DECL([], [RANLIB], [1],

    [Commands used to install an old-style archive])

# Determine commands to create old-style static archives.

old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'

old_postinstall_cmds='chmod 644 $oldlib'

old_postuninstall_cmds=

if test -n "$RANLIB"; then

  case $host_os in

  openbsd*)

    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"

    ;;

  *)

    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"

    ;;

  esac

  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"

fi

_LT_DECL([], [old_postinstall_cmds], [2])

_LT_DECL([], [old_postuninstall_cmds], [2])

_LT_TAGDECL([], [old_archive_cmds], [2],

    [Commands used to build an old-style archive])

])# _LT_CMD_OLD_ARCHIVE

# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])

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

# Check whether the given compiler option works

AC_DEFUN([_LT_COMPILER_OPTION],

[m4_require([_LT_FILEUTILS_DEFAULTS])dnl

m4_require([_LT_DECL_SED])dnl

AC_CACHE_CHECK([$1], [$2],

  [$2=no

   m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])

   echo "$lt_simple_compile_test_code" > conftest.$ac_ext

   lt_compiler_flag="$3"

   # Insert the option either (1) after the last *FLAGS variable, or

   # (2) before a word containing "conftest.", or (3) at the end.

   # Note that $ac_compile itself does not contain backslashes and begins

   # with a dollar sign (not a hyphen), so the echo should work correctly.

   # The option is referenced via a variable to avoid confusing sed.

   lt_compile=`echo "$ac_compile" | $SED \

   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \

   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \

   -e 's:$: $lt_compiler_flag:'`

   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

   (eval "$lt_compile" 2>conftest.err)

   ac_status=$?

   cat conftest.err >&AS_MESSAGE_LOG_FD

   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD

   if (exit $ac_status) && test -s "$ac_outfile"; then

     # The compiler can only warn and ignore the option if not recognized

     # So say no if there are warnings other than the usual output.

     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp

     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then

       $2=yes

     fi

   fi

   $RM conftest*

])

if test x"[$]$2" = xyes; then

    m4_if([$5], , :, [$5])

else

    m4_if([$6], , :, [$6])

fi

])# _LT_COMPILER_OPTION

# Old name:

AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION])

dnl aclocal-1.4 backwards compatibility:

dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], [])

# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

#                  [ACTION-SUCCESS], [ACTION-FAILURE])

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

# Check whether the given linker option works

AC_DEFUN([_LT_LINKER_OPTION],

[m4_require([_LT_FILEUTILS_DEFAULTS])dnl

m4_require([_LT_DECL_SED])dnl

AC_CACHE_CHECK([$1], [$2],

  [$2=no

   save_LDFLAGS="$LDFLAGS"

   LDFLAGS="$LDFLAGS $3"

   echo "$lt_simple_link_test_code" > conftest.$ac_ext

   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then

     # The linker can only warn and ignore the option if not recognized

     # So say no if there are warnings

     if test -s conftest.err; then

       # Append any errors to the config.log.

       cat conftest.err 1>&AS_MESSAGE_LOG_FD

       $ECHO "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp

       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2

       if diff conftest.exp conftest.er2 >/dev/null; then

         $2=yes

       fi

     else

       $2=yes

     fi

   fi

   $RM -r conftest*

   LDFLAGS="$save_LDFLAGS"

])

if test x"[$]$2" = xyes; then

    m4_if([$4], , :, [$4])

else

    m4_if([$5], , :, [$5])

fi

])# _LT_LINKER_OPTION

# Old name:

AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION])

dnl aclocal-1.4 backwards compatibility:

dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], [])

# LT_CMD_MAX_LEN

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

AC_DEFUN([LT_CMD_MAX_LEN],

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

# find the maximum length of command line arguments

AC_MSG_CHECKING([the maximum length of command line arguments])

AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl

  i=0

  teststring="ABCD"

  case $build_os in

  msdosdjgpp*)

    # On DJGPP, this test can blow up pretty badly due to problems in libc

    # (any single argument exceeding 2000 bytes causes a buffer overrun

    # during glob expansion).  Even if it were fixed, the result of this

    # check would be larger than it should be.

    lt_cv_sys_max_cmd_len=12288;    # 12K is about right

    ;;

  gnu*)

    # Under GNU Hurd, this test is not required because there is

    # no limit to the length of command line arguments.

    # Libtool will interpret -1 as no limit whatsoever

    lt_cv_sys_max_cmd_len=-1;

    ;;

  cygwin* | mingw* | cegcc*)

    # On Win9x/ME, this test blows up -- it succeeds, but takes

    # about 5 minutes as the teststring grows exponentially.

    # Worse, since 9x/ME are not pre-emptively multitasking,

    # you end up with a "frozen" computer, even though with patience

    # the test eventually succeeds (with a max line length of 256k).

    # Instead, let's just punt: use the minimum linelength reported by

    # all of the supported platforms: 8192 (on NT/2K/XP).

    lt_cv_sys_max_cmd_len=8192;

    ;;

  amigaos*)

    # On AmigaOS with pdksh, this test takes hours, literally.

    # So we just punt and use a minimum line length of 8192.

    lt_cv_sys_max_cmd_len=8192;

    ;;

  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)

    # This has been around since 386BSD, at least.  Likely further.

    if test -x /sbin/sysctl; then

      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`

    elif test -x /usr/sbin/sysctl; then

      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`

    else

      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs

    fi

    # And add a safety zone

    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`

    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`

    ;;

  interix*)

    # We know the value 262144 and hardcode it with a safety zone (like BSD)

    lt_cv_sys_max_cmd_len=196608

    ;;

  osf*)

    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure

    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not

    # nice to cause kernel panics so lets avoid the loop below.

    # First set a reasonable default.

    lt_cv_sys_max_cmd_len=16384

    #

    if test -x /sbin/sysconfig; then