SV platform dependency builds

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

# Copyright (C) 1996-2013 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_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])

m4_ifndef([AC_AUTOCONF_VERSION],

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

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

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

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, 2009, 2010, 2011 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, 2009, 2010, 2011 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 57 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_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl

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

_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}])

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 "$cc_temp" | $SED "s%.*/%%; 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

AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl

AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl

_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl

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

m4_require([_LT_CMD_RELOAD])dnl

m4_require([_LT_CHECK_MAGIC_METHOD])dnl

m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl

m4_require([_LT_CMD_OLD_ARCHIVE])dnl

m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl

m4_require([_LT_WITH_SYSROOT])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

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

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

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

# Define a few sed substitution that help us do robust quoting.

m4_defun([_LT_PREPARE_SED_QUOTE_VARS],

[# Backslashify 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'

])

# _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 "$][$1" | $SED "$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 "$<var>" | $SED "$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'

# A function that is used when there is no print builtin or printf.

func_fallback_echo ()

{

  eval 'cat <<_LTECHO_EOF

\$[]1

_LTECHO_EOF'

}

# Quote evaled strings.

for var in lt_decl_all_varnames([[ \

]], lt_decl_quote_varnames); do

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

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

      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$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 \\\\""\\\\\$\$var"\\\\"\` in

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

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

      ;;

    *)

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

      ;;

    esac

done

_LT_OUTPUT_LIBTOOL_INIT

])

# _LT_GENERATED_FILE_INIT(FILE, [COMMENT])

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

# Generate a child script FILE with all initialization necessary to

# reuse the environment learned by the parent script, and make the

# file executable.  If COMMENT is supplied, it is inserted after the

# `#!' sequence but before initialization text begins.  After this

# macro, additional text can be appended to FILE to form the body of

# the child script.  The macro ends with non-zero status if the

# file could not be fully written (such as if the disk is full).

m4_ifdef([AS_INIT_GENERATED],

[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],

[m4_defun([_LT_GENERATED_FILE_INIT],

[m4_require([AS_PREPARE])]dnl

[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl

[lt_write_fail=0

cat >$1 <<_ASEOF || lt_write_fail=1

#! $SHELL

# Generated by $as_me.

$2

SHELL=\${CONFIG_SHELL-$SHELL}

export SHELL

_ASEOF

cat >>$1 <<\_ASEOF || lt_write_fail=1

AS_SHELL_SANITIZE

_AS_PREPARE

exec AS_MESSAGE_FD>&1

_ASEOF

test $lt_write_fail = 0 && chmod +x $1[]dnl

m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_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])

_LT_GENERATED_FILE_INIT(["$CONFIG_LT"],

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

cat >>"$CONFIG_LT" <<\_LTEOF

lt_cl_silent=false

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) 2011 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.

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_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 '$q' "$ltmain" >> "$cfgfile" \

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

  _LT_PROG_REPLACE_SHELLFNS

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

  [Go],			[_LT_LANG(GO)],

  [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

m4_ifndef([AC_PROG_GO], [

# NOTE: This macro has been submitted for inclusion into   #

#  GNU Autoconf as AC_PROG_GO.  When it is available in    #

#  a released version of Autoconf we should remove this    #

#  macro and use it instead.                               #

m4_defun([AC_PROG_GO],

[AC_LANG_PUSH(Go)dnl

AC_ARG_VAR([GOC],     [Go compiler command])dnl

AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl

_AC_ARG_VAR_LDFLAGS()dnl

AC_CHECK_TOOL(GOC, gccgo)

if test -z "$GOC"; then

  if test -n "$ac_tool_prefix"; then

    AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])

  fi

fi

if test -z "$GOC"; then

  AC_CHECK_PROG(GOC, gccgo, gccgo, false)

fi

])#m4_defun

])#m4_ifndef

# _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([AC_PROG_GO],

  [LT_LANG(GO)],

  [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])

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

AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])

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

dnl AC_DEFUN([AC_LIBTOOL_RC], [])

# _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 there is a non-empty error log, and "single_module"

	# appears in it, assume the flag caused a linker warning

        if test -s conftest.err && $GREP single_module conftest.err; then

	  cat conftest.err >&AS_MESSAGE_LOG_FD

	# Otherwise, if the output was created with a 0 exit code from

	# the compiler, it worked.

	elif test -f libconftest.dylib && test $_lt_result -eq 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"

    ])

    AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],

      [lt_cv_ld_force_load=no

      cat > conftest.c << _LT_EOF

int forced_loaded() { return 2;}

_LT_EOF

      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD

      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD

      echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD

      $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD

      echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD

      $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD

      cat > conftest.c << _LT_EOF

int main() { return 0;}

_LT_EOF

      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD

      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err

      _lt_result=$?

      if test -s conftest.err && $GREP force_load conftest.err; then

	cat conftest.err >&AS_MESSAGE_LOG_FD

      elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then

	lt_cv_ld_force_load=yes

      else

	cat conftest.err >&AS_MESSAGE_LOG_FD

      fi

        rm -f conftest.err libconftest.a conftest conftest.c

        rm -rf conftest.dSYM

    ])

    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" != ":" && test "$lt_cv_ld_force_load" = "no"; then

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

    else

      _lt_dsymutil=

    fi

    ;;

  esac

])

# _LT_DARWIN_LINKER_FEATURES([TAG])

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

# 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

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

    _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'

    m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],

                  [FC],  [_LT_TAGVAR(compiler_needs_object, $1)=yes])

  else

    _LT_TAGVAR(whole_archive_flag_spec, $1)=''

  fi

  _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=func_echo_all

    _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([TAGNAME])

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

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

# Store the results from the different compilers for each TAGNAME.

# Allow to override them for all tags through lt_cv_aix_libpath.

m4_defun([_LT_SYS_MODULE_PATH_AIX],

[m4_require([_LT_DECL_SED])dnl

if test "${lt_cv_aix_libpath+set}" = set; then

  aix_libpath=$lt_cv_aix_libpath

else

  AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],

  [AC_LINK_IFELSE([AC_LANG_PROGRAM],[

  lt_aix_libpath_sed='[

      /Import File Strings/,/^$/ {

	  /^0/ {

	      s/^0  *\([^ ]*\) *$/\1/

	      p

	  }

      }]'

  _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`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 "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then

    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`

  fi],[])

  if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then

    _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib"

  fi

  ])

  aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])

fi

])# _LT_SYS_MODULE_PATH_AIX

# _LT_SHELL_INIT(ARG)

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

m4_define([_LT_SHELL_INIT],

[m4_divert_text([M4SH-INIT], [$1

])])# _LT_SHELL_INIT

# _LT_PROG_ECHO_BACKSLASH

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

# Find how we can fake an echo command that does not interpret backslash.

# In particular, with Autoconf 2.60 or later we add some code to the start

# of the generated configure script which will find a shell with a builtin

# printf (which we can use as an echo command).

m4_defun([_LT_PROG_ECHO_BACKSLASH],

[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'

ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO

ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

AC_MSG_CHECKING([how to print strings])

# Test print first, because it will be a builtin if present.

if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \

   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then

  ECHO='print -r --'

elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then

  ECHO='printf %s\n'

else

  # Use this function as a fallback that always works.

  func_fallback_echo ()

  {

    eval 'cat <<_LTECHO_EOF

$[]1

_LTECHO_EOF'

  }

  ECHO='func_fallback_echo'

fi

# func_echo_all arg...

# Invoke $ECHO with all args, space-separated.

func_echo_all ()

{

    $ECHO "$*" 

}

case "$ECHO" in

  printf*) AC_MSG_RESULT([printf]) ;;

  print*) AC_MSG_RESULT([print -r]) ;;

  *) AC_MSG_RESULT([cat]) ;;

esac

m4_ifdef([_AS_DETECT_SUGGESTED],

[_AS_DETECT_SUGGESTED([

  test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (

    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'

    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO

    ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO

    PATH=/empty FPATH=/empty; export PATH FPATH

    test "X`printf %s $ECHO`" = "X$ECHO" \

      || test "X`print -r -- $ECHO`" = "X$ECHO" )])])

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

_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])

])# _LT_PROG_ECHO_BACKSLASH

# _LT_WITH_SYSROOT

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

AC_DEFUN([_LT_WITH_SYSROOT],

[AC_MSG_CHECKING([for sysroot])

AC_ARG_WITH([sysroot],

[  --with-sysroot[=DIR] Search for dependent libraries within DIR

                        (or the compiler's sysroot if not specified).],

[], [with_sysroot=no])

dnl lt_sysroot will always be passed unquoted.  We quote it here

dnl in case the user passed a directory name.

lt_sysroot=

case ${with_sysroot} in #(

 yes)

   if test "$GCC" = yes; then

     lt_sysroot=`$CC --print-sysroot 2>/dev/null`

   fi

   ;; #(

 /*)

   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`

   ;; #(

 no|'')

   ;; #(

 *)

   AC_MSG_RESULT([${with_sysroot}])

   AC_MSG_ERROR([The sysroot must be an absolute path.])

   ;;

esac

 AC_MSG_RESULT([${lt_sysroot:-no}])

_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl

[dependent libraries, and in which our libraries should be installed.])])

# _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 '$LINENO' "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*|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*)

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

	      *x86-64*)

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

		;;

	      *)

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

		;;

	    esac

	    ;;

	  powerpc64le-*)

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

	    ;;

	  powerpc64-*)

	    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"

	    ;;

	  powerpcle-*)

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

	    ;;

	  powerpc-*)

	    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

  ;;

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

        case $host in

        i?86-*-solaris*)

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

          ;;

        sparc*-*-solaris*)

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

          ;;

        esac

        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.

        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then

          LD="${LD-ld}_sol2"

        fi

        ;;

      *)

	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_PROG_AR

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

m4_defun([_LT_PROG_AR],

[AC_CHECK_TOOLS(AR, [ar], false)

: ${AR=ar}

: ${AR_FLAGS=cru}

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

_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])

AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],

  [lt_cv_ar_at_file=no

   AC_COMPILE_IFELSE([AC_LANG_PROGRAM],

     [echo conftest.$ac_objext > conftest.lst

      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'

      AC_TRY_EVAL([lt_ar_try])

      if test "$ac_status" -eq 0; then

	# Ensure the archiver fails upon bogus file names.

	rm -f conftest.$ac_objext libconftest.a

	AC_TRY_EVAL([lt_ar_try])

	if test "$ac_status" -ne 0; then

          lt_cv_ar_at_file=@

        fi

      fi

      rm -f conftest.* libconftest.a

     ])

  ])

if test "x$lt_cv_ar_at_file" = xno; then

  archiver_list_spec=

else

  archiver_list_spec=$lt_cv_ar_at_file

fi

_LT_DECL([], [archiver_list_spec], [1],

  [How to feed a file listing to the archiver])

])# _LT_PROG_AR

# _LT_CMD_OLD_ARCHIVE

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

m4_defun([_LT_CMD_OLD_ARCHIVE],

[_LT_PROG_AR

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 \$tool_oldlib"

    ;;

  *)

    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"

    ;;

  esac

  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"

fi

case $host_os in

  darwin*)

    lock_old_archive_extraction=yes ;;

  *)

    lock_old_archive_extraction=no ;;

esac

_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_DECL([], [lock_old_archive_extraction], [0],

    [Whether to use a lock for old archive extraction])

])# _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:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)

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

   ac_status=$?

   cat conftest.err >&AS_MESSAGE_LOG_FD

   echo "$as_me:$LINENO: \$? = $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 "$_lt_compiler_boilerplate" | $SED '/^$/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