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

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

## Free Software Foundation, Inc.

## Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 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.

# serial 48 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_deplibs'

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

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

# Use C for the default configuration in the libtool script

tagname=

AC_LIBTOOL_LANG_C_CONFIG

_LT_AC_TAGCONFIG

])# AC_LIBTOOL_SETUP

# _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_outfile=conftest.$ac_objext

printf "$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_outfile=conftest.$ac_objext

printf "$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 conftest*

])# _LT_LINKER_BOILERPLATE

# _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_LINK_IFELSE(AC_LANG_PROGRAM,[

aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

}'`

# 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 '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }

}'`; 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-*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