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

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

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

# This file is free software; the Free Software Foundation

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

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

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

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

# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

# PARTICULAR PURPOSE.

m4_ifndef([AC_AUTOCONF_VERSION],

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

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

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

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

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

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

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

# serial 52 AC_PROG_LIBTOOL

# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)

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

# If this macro is not defined by Autoconf, define it here.

m4_ifdef([AC_PROVIDE_IFELSE],

         [],

         [m4_define([AC_PROVIDE_IFELSE],

	         [m4_ifdef([AC_PROVIDE_$1],

		           [$2], [$3])])])

# AC_PROG_LIBTOOL

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

AC_DEFUN([AC_PROG_LIBTOOL],

[AC_REQUIRE([_AC_PROG_LIBTOOL])dnl

dnl If AC_PROG_CXX has already been expanded, run AC_LIBTOOL_CXX

dnl immediately, otherwise, hook it in at the end of AC_PROG_CXX.

  AC_PROVIDE_IFELSE([AC_PROG_CXX],

    [AC_LIBTOOL_CXX],

    [define([AC_PROG_CXX], defn([AC_PROG_CXX])[AC_LIBTOOL_CXX

  ])])

dnl And a similar setup for Fortran 77 support

  AC_PROVIDE_IFELSE([AC_PROG_F77],

    [AC_LIBTOOL_F77],

    [define([AC_PROG_F77], defn([AC_PROG_F77])[AC_LIBTOOL_F77

])])

dnl Quote A][M_PROG_GCJ so that aclocal doesn't bring it in needlessly.

dnl If either AC_PROG_GCJ or A][M_PROG_GCJ have already been expanded, run

dnl AC_LIBTOOL_GCJ immediately, otherwise, hook it in at the end of both.

  AC_PROVIDE_IFELSE([AC_PROG_GCJ],

    [AC_LIBTOOL_GCJ],

    [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],

      [AC_LIBTOOL_GCJ],

      [AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],

	[AC_LIBTOOL_GCJ],

      [ifdef([AC_PROG_GCJ],

	     [define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])

       ifdef([A][M_PROG_GCJ],

	     [define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[AC_LIBTOOL_GCJ])])

       ifdef([LT_AC_PROG_GCJ],

	     [define([LT_AC_PROG_GCJ],

		defn([LT_AC_PROG_GCJ])[AC_LIBTOOL_GCJ])])])])

])])# AC_PROG_LIBTOOL

# _AC_PROG_LIBTOOL

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

AC_DEFUN([_AC_PROG_LIBTOOL],

[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl

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

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

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

# This can be used to rebuild libtool when needed

LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

# Always use our own libtool.

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

AC_SUBST(LIBTOOL)dnl

# Prevent multiple expansion

define([AC_PROG_LIBTOOL], [])

])# _AC_PROG_LIBTOOL

# AC_LIBTOOL_SETUP

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

AC_DEFUN([AC_LIBTOOL_SETUP],

[AC_PREREQ(2.50)dnl

AC_REQUIRE([AC_ENABLE_SHARED])dnl

AC_REQUIRE([AC_ENABLE_STATIC])dnl

AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

AC_REQUIRE([AC_CANONICAL_HOST])dnl

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_PROG_LD])dnl

AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl

AC_REQUIRE([AC_PROG_NM])dnl

AC_REQUIRE([AC_PROG_LN_S])dnl

AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!

AC_REQUIRE([AC_OBJEXT])dnl

AC_REQUIRE([AC_EXEEXT])dnl

dnl

AC_LIBTOOL_SYS_MAX_CMD_LEN

AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

AC_LIBTOOL_OBJDIR

AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

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

Xsed='sed -e 1s/^X//'

[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 avoid accidental globbing in evaled expressions

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

# Constants:

rm="rm -f"

# Global variables:

default_ofile=libtool

can_build_shared=yes

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

# which needs '.lib').

libext=a

ltmain="$ac_aux_dir/ltmain.sh"

ofile="$default_ofile"

with_gnu_ld="$lt_cv_prog_gnu_ld"

AC_CHECK_TOOL(AR, ar, false)

AC_CHECK_TOOL(RANLIB, ranlib, :)

AC_CHECK_TOOL(STRIP, strip, :)

old_CC="$CC"

old_CFLAGS="$CFLAGS"

# Set sane defaults for various variables

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

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

test -z "$AS" && AS=as

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

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

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

test -z "$DLLTOOL" && DLLTOOL=dlltool

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

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

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

test -z "$NM" && NM=nm

test -z "$SED" && SED=sed

test -z "$OBJDUMP" && OBJDUMP=objdump

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

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

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

# 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_CC_BASENAME([$compiler])

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

case $deplibs_check_method in

file_magic*)

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

    AC_PATH_MAGIC

  fi

  ;;

esac

_LT_REQUIRED_DARWIN_CHECKS

AC_PROVIDE_IFELSE([AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)

AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

enable_win32_dll=yes, enable_win32_dll=no)

AC_ARG_ENABLE([libtool-lock],

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

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

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

AC_ARG_WITH([pic],

    [AC_HELP_STRING([--with-pic],

	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],

    [pic_mode="$withval"],

    [pic_mode=default])

test -z "$pic_mode" && pic_mode=default

# Check if we have a version mismatch between libtool.m4 and ltmain.sh.

#

# Note:  This should be in AC_LIBTOOL_SETUP, _after_ $ltmain have been defined.

#        We also should do it _before_ AC_LIBTOOL_LANG_C_CONFIG that actually

#        calls AC_LIBTOOL_CONFIG and creates libtool.

#

_LT_VERSION_CHECK

# Use C for the default configuration in the libtool script

tagname=

AC_LIBTOOL_LANG_C_CONFIG

_LT_AC_TAGCONFIG

])# AC_LIBTOOL_SETUP

# _LT_VERSION_CHECK

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

AC_DEFUN([_LT_VERSION_CHECK],

[AC_MSG_CHECKING([for correct ltmain.sh version])

if test "x$ltmain" = "x" ; then

  AC_MSG_RESULT(no)

  AC_MSG_ERROR([

*** @<:@Gentoo@:>@ sanity check failed! ***

*** \$ltmain is not defined, please check the patch for consistency! ***

])

fi

gentoo_lt_version="1.5.26"

gentoo_ltmain_version=`sed -n '/^[[ 	]]*VERSION=/{s/^[[ 	]]*VERSION=//;p;q;}' "$ltmain"`

if test "x$gentoo_lt_version" != "x$gentoo_ltmain_version" ; then

  AC_MSG_RESULT(no)

  AC_MSG_ERROR([

*** @<:@Gentoo@:>@ sanity check failed! ***

*** libtool.m4 and ltmain.sh have a version mismatch! ***

*** (libtool.m4 = $gentoo_lt_version, ltmain.sh = $gentoo_ltmain_version) ***

Please run:

  libtoolize --copy --force

if appropriate, please contact the maintainer of this

package (or your distribution) for help.

])

else

  AC_MSG_RESULT(yes)

fi

])# _LT_VERSION_CHECK

# _LT_AC_SYS_COMPILER

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

AC_DEFUN([_LT_AC_SYS_COMPILER],

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

# _LT_CC_BASENAME(CC)

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

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

AC_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_COMPILER_BOILERPLATE

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

# Check for compiler boilerplate output or warnings with

# the simple compiler test code.

AC_DEFUN([_LT_COMPILER_BOILERPLATE],

[AC_REQUIRE([LT_AC_PROG_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.

AC_DEFUN([_LT_LINKER_BOILERPLATE],

[AC_REQUIRE([LT_AC_PROG_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

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

# Check for some things on darwin

AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS],[

  case $host_os in

    rhapsody* | darwin*)

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

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

    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.

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

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

     -dynamiclib ${wl}-single_module conftest.c

   if test -f libconftest.dylib; then

     lt_cv_apple_cc_single_mod=yes

     rm -rf libconftest.dylib*

   fi

   rm conftest.c

      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.[[0123]])

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

    darwin1.*)

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

    darwin*)

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

AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX],

[AC_REQUIRE([LT_AC_PROG_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_AC_SYS_LIBPATH_AIX

# _LT_AC_SHELL_INIT(ARG)

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

AC_DEFUN([_LT_AC_SHELL_INIT],

[ifdef([AC_DIVERSION_NOTICE],

	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

	 [AC_DIVERT_PUSH(NOTICE)])

$1

AC_DIVERT_POP

])# _LT_AC_SHELL_INIT

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

AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],

[_LT_AC_SHELL_INIT([

# Check that we are running under the correct shell.

SHELL=${CONFIG_SHELL-/bin/sh}

case X$ECHO in

X*--fallback-echo)

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

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

  ;;

esac

echo=${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 <<EOF

[$]*

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 "$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 &&

       echo_test_string=`eval $cmd` &&

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

ECHO=$echo

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

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

fi

AC_SUBST(ECHO)

])])# _LT_AC_PROG_ECHO_BACKSLASH

# _LT_AC_LOCK

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

AC_DEFUN([_LT_AC_LOCK],

[AC_ARG_ENABLE([libtool-lock],

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

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

          ;;

        sparc*-*linux*)

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

          ;;

      esac

      ;;

    esac