Difference for ./aclocal.m4 from version 1.11 to 1.12

version 1.11

version 1.12

Line 1

# aclocal.m4 generated automatically by aclocal 1.6.3 -*- Autoconf -*-

dnl aclocal.m4 generated automatically by aclocal 1.4-p6

# Free Software Foundation, Inc.

dnl This file is free software; the Free Software Foundation

# This file is free software; the Free Software Foundation

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

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

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

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

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

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

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

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

dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A

# even the implied warranty of MERCHANTABILITY or FITNESS FOR A

dnl PARTICULAR PURPOSE.

# PARTICULAR PURPOSE.

AC_DEFUN([CF_CHECK_PYTHON],

Line 67

Line 66

AC_SUBST(PY_INCLUDES)

])

# Do all the work for Automake. -*- Autoconf -*-

# lib-prefix.m4 serial 3 (gettext-0.12.2)

dnl This file is free software, distributed under the terms of the GNU

dnl General Public License. As a special exception to the GNU General

dnl Public License, this file may be distributed as part of a program

dnl that contains a configuration script generated by Autoconf, under

dnl the same distribution terms as the rest of that program.

dnl From Bruno Haible.

dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and

dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't

dnl require excessive bracketing.

ifdef([AC_HELP_STRING],

[AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],

[AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])

dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed

dnl to access previously installed libraries. The basic assumption is that

dnl a user will want packages to use other packages he previously installed

dnl with the same --prefix option.

dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate

dnl libraries, but is otherwise very convenient.

AC_DEFUN([AC_LIB_PREFIX],

[

AC_BEFORE([$0], [AC_LIB_LINKFLAGS])

AC_REQUIRE([AC_PROG_CC])

AC_REQUIRE([AC_CANONICAL_HOST])

AC_REQUIRE([AC_LIB_PREPARE_PREFIX])

dnl By default, look in $includedir and $libdir.

use_additional=yes

AC_LIB_WITH_FINAL_PREFIX([

eval additional_includedir=\"$includedir\"

eval additional_libdir=\"$libdir\"

])

AC_LIB_ARG_WITH([lib-prefix],

[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib

--without-lib-prefix don't search for libraries in includedir and libdir],

[

if test "X$withval" = "Xno"; then

use_additional=no

else

if test "X$withval" = "X"; then

AC_LIB_WITH_FINAL_PREFIX([

eval additional_includedir=\"$includedir\"

eval additional_libdir=\"$libdir\"

])

else

additional_includedir="$withval/include"

additional_libdir="$withval/lib"

])

if test $use_additional = yes; then

dnl Potentially add $additional_includedir to $CPPFLAGS.

dnl But don't add it

dnl 1. if it's the standard /usr/include,

dnl 2. if it's already present in $CPPFLAGS,

dnl 3. if it's /usr/local/include and we are using GCC on Linux,

dnl 4. if it doesn't exist as a directory.

if test "X$additional_includedir" != "X/usr/include"; then

haveit=

for x in $CPPFLAGS; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X-I$additional_includedir"; then

haveit=yes

break

done

if test -z "$haveit"; then

if test "X$additional_includedir" = "X/usr/local/include"; then

if test -n "$GCC"; then

case $host_os in

linux*) haveit=yes;;

esac

if test -z "$haveit"; then

if test -d "$additional_includedir"; then

dnl Really add $additional_includedir to $CPPFLAGS.

CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"

dnl Potentially add $additional_libdir to $LDFLAGS.

dnl But don't add it

dnl 1. if it's the standard /usr/lib,

dnl 2. if it's already present in $LDFLAGS,

dnl 3. if it's /usr/local/lib and we are using GCC on Linux,

dnl 4. if it doesn't exist as a directory.

if test "X$additional_libdir" != "X/usr/lib"; then

haveit=

for x in $LDFLAGS; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X-L$additional_libdir"; then

haveit=yes

break

done

if test -z "$haveit"; then

if test "X$additional_libdir" = "X/usr/local/lib"; then

if test -n "$GCC"; then

case $host_os in

linux*) haveit=yes;;

esac

if test -z "$haveit"; then

if test -d "$additional_libdir"; then

dnl Really add $additional_libdir to $LDFLAGS.

LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"

])

# This macro actually does too much some checks are only needed if

dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,

# your package does certain things. But this isn't really a big deal.

dnl acl_final_exec_prefix, containing the values to which $prefix and

dnl $exec_prefix will expand at the end of the configure script.

AC_DEFUN([AC_LIB_PREPARE_PREFIX],

[

dnl Unfortunately, prefix and exec_prefix get only finally determined

dnl at the end of configure.

if test "X$prefix" = "XNONE"; then

acl_final_prefix="$ac_default_prefix"

else

acl_final_prefix="$prefix"

if test "X$exec_prefix" = "XNONE"; then

acl_final_exec_prefix='${prefix}'

else

acl_final_exec_prefix="$exec_prefix"

acl_save_prefix="$prefix"

prefix="$acl_final_prefix"

eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"

prefix="$acl_save_prefix"

])

dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the

# Free Software Foundation, Inc.

dnl variables prefix and exec_prefix bound to the values they will have

dnl at the end of the configure script.

AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],

[

acl_save_prefix="$prefix"

prefix="$acl_final_prefix"

acl_save_exec_prefix="$exec_prefix"

exec_prefix="$acl_final_exec_prefix"

exec_prefix="$acl_save_exec_prefix"

prefix="$acl_save_prefix"

])

# This program is free software; you can redistribute it and/or modify

# lib-link.m4 serial 4 (gettext-0.12)

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2, or (at your option)

dnl This file is free software, distributed under the terms of the GNU

# any later version.

dnl General Public License. As a special exception to the GNU General

dnl Public License, this file may be distributed as part of a program

dnl that contains a configuration script generated by Autoconf, under

dnl the same distribution terms as the rest of that program.

dnl From Bruno Haible.

dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and

dnl the libraries corresponding to explicit and implicit dependencies.

dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and

dnl augments the CPPFLAGS variable.

AC_DEFUN([AC_LIB_LINKFLAGS],

[

AC_REQUIRE([AC_LIB_PREPARE_PREFIX])

AC_REQUIRE([AC_LIB_RPATH])

define([Name],[translit([$1],[./-], [___])])

define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],

[ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])

AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [

AC_LIB_LINKFLAGS_BODY([$1], [$2])

ac_cv_lib[]Name[]_libs="$LIB[]NAME"

ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"

ac_cv_lib[]Name[]_cppflags="$INC[]NAME"

])

LIB[]NAME="$ac_cv_lib[]Name[]_libs"

LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"

INC[]NAME="$ac_cv_lib[]Name[]_cppflags"

AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)

AC_SUBST([LIB]NAME)

AC_SUBST([LTLIB]NAME)

dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the

dnl results of this search when this library appears as a dependency.

HAVE_LIB[]NAME=yes

undefine([Name])

undefine([NAME])

])

dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode)

dnl searches for libname and the libraries corresponding to explicit and

dnl implicit dependencies, together with the specified include files and

dnl the ability to compile and link the specified testcode. If found, it

dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and

dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and

dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs

dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.

AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],

[

AC_REQUIRE([AC_LIB_PREPARE_PREFIX])

AC_REQUIRE([AC_LIB_RPATH])

define([Name],[translit([$1],[./-], [___])])

define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],

[ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])

dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME

dnl accordingly.

AC_LIB_LINKFLAGS_BODY([$1], [$2])

dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,

dnl because if the user has installed lib[]Name and not disabled its use

dnl via --without-lib[]Name-prefix, he wants to use it.

ac_save_CPPFLAGS="$CPPFLAGS"

AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)

AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [

ac_save_LIBS="$LIBS"

LIBS="$LIBS $LIB[]NAME"

AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])

LIBS="$ac_save_LIBS"

])

if test "$ac_cv_lib[]Name" = yes; then

HAVE_LIB[]NAME=yes

AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])

AC_MSG_CHECKING([how to link with lib[]$1])

AC_MSG_RESULT([$LIB[]NAME])

else

HAVE_LIB[]NAME=no

dnl If $LIB[]NAME didn't lead to a usable library, we don't need

dnl $INC[]NAME either.

CPPFLAGS="$ac_save_CPPFLAGS"

LIB[]NAME=

LTLIB[]NAME=

AC_SUBST([HAVE_LIB]NAME)

AC_SUBST([LIB]NAME)

AC_SUBST([LTLIB]NAME)

undefine([Name])

undefine([NAME])

])

dnl Determine the platform dependent parameters needed to use rpath:

dnl libext, shlibext, hardcode_libdir_flag_spec, hardcode_libdir_separator,

dnl hardcode_direct, hardcode_minus_L.

AC_DEFUN([AC_LIB_RPATH],

[

AC_REQUIRE([AC_PROG_CC]) dnl we use $CC, $GCC, $LDFLAGS

AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD, $with_gnu_ld

AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host

AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir

AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [

CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \

${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh

. ./conftest.sh

rm -f ./conftest.sh

acl_cv_rpath=done

])

wl="$acl_cv_wl"

libext="$acl_cv_libext"

shlibext="$acl_cv_shlibext"

hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"

hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"

hardcode_direct="$acl_cv_hardcode_direct"

hardcode_minus_L="$acl_cv_hardcode_minus_L"

dnl Determine whether the user wants rpath handling at all.

AC_ARG_ENABLE(rpath,

[ --disable-rpath do not hardcode runtime library paths],

:, enable_rpath=yes)

])

dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and

dnl the libraries corresponding to explicit and implicit dependencies.

dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.

AC_DEFUN([AC_LIB_LINKFLAGS_BODY],

[

define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],

[ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])

dnl By default, look in $includedir and $libdir.

use_additional=yes

AC_LIB_WITH_FINAL_PREFIX([

eval additional_includedir=\"$includedir\"

eval additional_libdir=\"$libdir\"

])

AC_LIB_ARG_WITH([lib$1-prefix],

[ --with-lib$1-prefix[=DIR] search for lib$1 in DIR/include and DIR/lib

--without-lib$1-prefix don't search for lib$1 in includedir and libdir],

[

if test "X$withval" = "Xno"; then

use_additional=no

else

if test "X$withval" = "X"; then

AC_LIB_WITH_FINAL_PREFIX([

eval additional_includedir=\"$includedir\"

eval additional_libdir=\"$libdir\"

])

else

additional_includedir="$withval/include"

additional_libdir="$withval/lib"

])

dnl Search the library and its dependencies in $additional_libdir and

dnl $LDFLAGS. Using breadth-first-seach.

LIB[]NAME=

LTLIB[]NAME=

INC[]NAME=

rpathdirs=

ltrpathdirs=

names_already_handled=

names_next_round='$1 $2'

while test -n "$names_next_round"; do

names_this_round="$names_next_round"

names_next_round=

for name in $names_this_round; do

already_handled=

for n in $names_already_handled; do

if test "$n" = "$name"; then

already_handled=yes

break

done

if test -z "$already_handled"; then

names_already_handled="$names_already_handled $name"

dnl See if it was already located by an earlier AC_LIB_LINKFLAGS

dnl or AC_LIB_HAVE_LINKFLAGS call.

uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`

eval value=\"\$HAVE_LIB$uppername\"

if test -n "$value"; then

if test "$value" = yes; then

eval value=\"\$LIB$uppername\"

test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"

eval value=\"\$LTLIB$uppername\"

test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"

else

dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined

dnl that this library doesn't exist. So just drop it.

else

dnl Search the library lib$name in $additional_libdir and $LDFLAGS

dnl and the already constructed $LIBNAME/$LTLIBNAME.

found_dir=

found_la=

found_so=

found_a=

if test $use_additional = yes; then

if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then

found_dir="$additional_libdir"

found_so="$additional_libdir/lib$name.$shlibext"

if test -f "$additional_libdir/lib$name.la"; then

found_la="$additional_libdir/lib$name.la"

else

if test -f "$additional_libdir/lib$name.$libext"; then

found_dir="$additional_libdir"

found_a="$additional_libdir/lib$name.$libext"

if test -f "$additional_libdir/lib$name.la"; then

found_la="$additional_libdir/lib$name.la"

if test "X$found_dir" = "X"; then

for x in $LDFLAGS $LTLIB[]NAME; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

case "$x" in

-L*)

dir=`echo "X$x" | sed -e 's/^X-L//'`

if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then

found_dir="$dir"

found_so="$dir/lib$name.$shlibext"

if test -f "$dir/lib$name.la"; then

found_la="$dir/lib$name.la"

else

if test -f "$dir/lib$name.$libext"; then

found_dir="$dir"

found_a="$dir/lib$name.$libext"

if test -f "$dir/lib$name.la"; then

found_la="$dir/lib$name.la"

;;

esac

if test "X$found_dir" != "X"; then

break

done

if test "X$found_dir" != "X"; then

dnl Found the library.

LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"

if test "X$found_so" != "X"; then

dnl Linking with a shared library. We attempt to hardcode its

dnl directory into the executable's runpath, unless it's the

dnl standard /usr/lib.

if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then

dnl No hardcoding is needed.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

else

dnl Use an explicit option to hardcode DIR into the resulting

dnl binary.

dnl Potentially add DIR to ltrpathdirs.

dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.

haveit=

for x in $ltrpathdirs; do

if test "X$x" = "X$found_dir"; then

haveit=yes

break

done

if test -z "$haveit"; then

ltrpathdirs="$ltrpathdirs $found_dir"

dnl The hardcoding into $LIBNAME is system dependent.

if test "$hardcode_direct" = yes; then

dnl Using DIR/libNAME.so during linking hardcodes DIR into the

dnl resulting binary.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

else

if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then

dnl Use an explicit option to hardcode DIR into the resulting

dnl binary.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

dnl Potentially add DIR to rpathdirs.

dnl The rpathdirs will be appended to $LIBNAME at the end.

haveit=

for x in $rpathdirs; do

if test "X$x" = "X$found_dir"; then

haveit=yes

break

done

if test -z "$haveit"; then

rpathdirs="$rpathdirs $found_dir"

else

dnl Rely on "-L$found_dir".

dnl But don't add it if it's already contained in the LDFLAGS

dnl or the already constructed $LIBNAME

haveit=

for x in $LDFLAGS $LIB[]NAME; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X-L$found_dir"; then

haveit=yes

break

done

if test -z "$haveit"; then

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"

if test "$hardcode_minus_L" != no; then

dnl FIXME: Not sure whether we should use

dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"

dnl here.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

else

dnl We cannot use $hardcode_runpath_var and LD_RUN_PATH

dnl here, because this doesn't fit in flags passed to the

dnl compiler. So give up. No hardcoding. This affects only

dnl very old systems.

dnl FIXME: Not sure whether we should use

dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"

dnl here.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"

else

if test "X$found_a" != "X"; then

dnl Linking with a static library.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"

else

dnl We shouldn't come here, but anyway it's good to have a

dnl fallback.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"

dnl Assume the include files are nearby.

additional_includedir=

case "$found_dir" in

*/lib | */lib/)

basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'`

additional_includedir="$basedir/include"

;;

esac

if test "X$additional_includedir" != "X"; then

dnl Potentially add $additional_includedir to $INCNAME.

dnl But don't add it

dnl 1. if it's the standard /usr/include,

dnl 2. if it's /usr/local/include and we are using GCC on Linux,

dnl 3. if it's already present in $CPPFLAGS or the already

dnl constructed $INCNAME,

dnl 4. if it doesn't exist as a directory.

if test "X$additional_includedir" != "X/usr/include"; then

haveit=

if test "X$additional_includedir" = "X/usr/local/include"; then

if test -n "$GCC"; then

case $host_os in

linux*) haveit=yes;;

esac

if test -z "$haveit"; then

for x in $CPPFLAGS $INC[]NAME; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X-I$additional_includedir"; then

haveit=yes

break

done

if test -z "$haveit"; then

if test -d "$additional_includedir"; then

dnl Really add $additional_includedir to $INCNAME.

INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"

dnl Look for dependencies.

if test -n "$found_la"; then

dnl Read the .la file. It defines the variables

dnl dlname, library_names, old_library, dependency_libs, current,

dnl age, revision, installed, dlopen, dlpreopen, libdir.

save_libdir="$libdir"

case "$found_la" in

*/* | *\\*) . "$found_la" ;;

*) . "./$found_la" ;;

esac

libdir="$save_libdir"

dnl We use only dependency_libs.

for dep in $dependency_libs; do

case "$dep" in

-L*)

additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`

dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.

dnl But don't add it

dnl 1. if it's the standard /usr/lib,

dnl 2. if it's /usr/local/lib and we are using GCC on Linux,

dnl 3. if it's already present in $LDFLAGS or the already

dnl constructed $LIBNAME,

dnl 4. if it doesn't exist as a directory.

if test "X$additional_libdir" != "X/usr/lib"; then

haveit=

if test "X$additional_libdir" = "X/usr/local/lib"; then

if test -n "$GCC"; then

case $host_os in

linux*) haveit=yes;;

esac

if test -z "$haveit"; then

haveit=

for x in $LDFLAGS $LIB[]NAME; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X-L$additional_libdir"; then

haveit=yes

break

done

if test -z "$haveit"; then

if test -d "$additional_libdir"; then

dnl Really add $additional_libdir to $LIBNAME.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"

haveit=

for x in $LDFLAGS $LTLIB[]NAME; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X-L$additional_libdir"; then

haveit=yes

break

done

if test -z "$haveit"; then

if test -d "$additional_libdir"; then

dnl Really add $additional_libdir to $LTLIBNAME.

LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"

;;

-R*)

dir=`echo "X$dep" | sed -e 's/^X-R//'`

if test "$enable_rpath" != no; then

dnl Potentially add DIR to rpathdirs.

dnl The rpathdirs will be appended to $LIBNAME at the end.

haveit=

for x in $rpathdirs; do

if test "X$x" = "X$dir"; then

haveit=yes

break

done

if test -z "$haveit"; then

rpathdirs="$rpathdirs $dir"

dnl Potentially add DIR to ltrpathdirs.

dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.

haveit=

for x in $ltrpathdirs; do

if test "X$x" = "X$dir"; then

haveit=yes

break

done

if test -z "$haveit"; then

ltrpathdirs="$ltrpathdirs $dir"

;;

-l*)

dnl Handle this in the next round.

names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`

;;

*.la)

dnl Handle this in the next round. Throw away the .la's

dnl directory; it is already contained in a preceding -L

dnl option.

names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`

;;

dnl Most likely an immediate library name.

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"

LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"

;;

esac

done

else

dnl Didn't find the library; assume it is in the system directories

dnl known to the linker and runtime loader. (All the system

dnl directories known to the linker should also be known to the

dnl runtime loader, otherwise the system is severely misconfigured.)

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"

LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"

done

if test "X$rpathdirs" != "X"; then

if test -n "$hardcode_libdir_separator"; then

dnl Weird platform: only the last -rpath option counts, the user must

dnl pass all path elements in one option. We can arrange that for a

dnl single library, but not when more than one $LIBNAMEs are used.

alldirs=

for found_dir in $rpathdirs; do

alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir"

done

dnl Note: hardcode_libdir_flag_spec uses $libdir and $wl.

acl_save_libdir="$libdir"

libdir="$alldirs"

eval flag=\"$hardcode_libdir_flag_spec\"

libdir="$acl_save_libdir"

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"

else

dnl The -rpath options are cumulative.

for found_dir in $rpathdirs; do

acl_save_libdir="$libdir"

libdir="$found_dir"

eval flag=\"$hardcode_libdir_flag_spec\"

libdir="$acl_save_libdir"

LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"

done

if test "X$ltrpathdirs" != "X"; then

dnl When using libtool, the option that works for both libraries and

dnl executables is -R. The -R options are cumulative.

for found_dir in $ltrpathdirs; do

LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"

done

])

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

dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

dnl unless already present in VAR.

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes

# GNU General Public License for more details.

dnl contains two or three consecutive elements that belong together.

AC_DEFUN([AC_LIB_APPENDTOVAR],

[

for element in [$2]; do

haveit=

for x in $[$1]; do

AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

if test "X$x" = "X$element"; then

haveit=yes

break

done

if test -z "$haveit"; then

[$1]="${[$1]}${[$1]:+ }$element"

done

])

# You should have received a copy of the GNU General Public License

# lib-ld.m4 serial 2 (gettext-0.12)

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

dnl This file is free software, distributed under the terms of the GNU

# 02111-1307, USA.

dnl General Public License. As a special exception to the GNU General

dnl Public License, this file may be distributed as part of a program

dnl that contains a configuration script generated by Autoconf, under

dnl the same distribution terms as the rest of that program.

dnl Subroutines of libtool.m4,

dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision

dnl with libtool.m4.

dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no.

AC_DEFUN([AC_LIB_PROG_LD_GNU],

[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld,

[# I'd rather use --version here, but apparently some GNU ld's only accept -v.

if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then

acl_cv_prog_gnu_ld=yes

else

acl_cv_prog_gnu_ld=no

fi])

with_gnu_ld=$acl_cv_prog_gnu_ld

])

dnl From libtool-1.4. Sets the variable LD.

AC_DEFUN([AC_LIB_PROG_LD],

[AC_ARG_WITH(gnu-ld,

[ --with-gnu-ld assume the C compiler uses GNU ld [default=no]],

test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_CANONICAL_HOST])dnl

# Prepare PATH_SEPARATOR.

# The user is always right.

if test "${PATH_SEPARATOR+set}" != set; then

echo "#! /bin/sh" >conf$$.sh

echo "exit 0" >>conf$$.sh

chmod +x conf$$.sh

if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then

PATH_SEPARATOR=';'

else

PATH_SEPARATOR=:

rm -f conf$$.sh

ac_prog=ld

if test "$GCC" = yes; then

# Check if gcc -print-prog-name=ld gives a path.

AC_MSG_CHECKING([for ld used by GCC])

case $host in

*-*-mingw*)

# gcc leaves a trailing carriage return which upsets mingw

ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;

ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

esac

case $ac_prog in

# Accept absolute paths.

[[\\/]* | [A-Za-z]:[\\/]*)]

[re_direlt='/[^/][^/]*/\.\./']

# Canonicalize the path of ld

ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`

while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do

ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`

done

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

;;

"")

# If it fails, then pretend we aren't using GCC.

ac_prog=ld

;;

# If it is relative, then search for the first ld in PATH.

with_gnu_ld=unknown

;;

esac

elif test "$with_gnu_ld" = yes; then

AC_MSG_CHECKING([for GNU ld])

else

AC_MSG_CHECKING([for non-GNU ld])

AC_CACHE_VAL(acl_cv_path_LD,

[if test -z "$LD"; then

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"

for ac_dir in $PATH; do

test -z "$ac_dir" && ac_dir=.

if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then

acl_cv_path_LD="$ac_dir/$ac_prog"

# Check to see if the program is GNU ld. I'd rather use --version,

# but apparently some GNU ld's only accept -v.

# Break only if it was the GNU/non-GNU ld that we prefer.

if "$acl_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then

test "$with_gnu_ld" != no && break

else

test "$with_gnu_ld" != yes && break

done

IFS="$ac_save_ifs"

else

acl_cv_path_LD="$LD" # Let the user override the test with a path.

fi])

LD="$acl_cv_path_LD"

if test -n "$LD"; then

AC_MSG_RESULT($LD)

else

AC_MSG_RESULT(no)

test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])

AC_LIB_PROG_LD_GNU

])

# Do all the work for Automake. This macro actually does too much --

# some checks are only needed if your package does certain things.

# But this isn't really a big deal.

# serial 1

# serial 8

dnl Usage:

dnl AM_INIT_AUTOMAKE(package,version, [no-define])

# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be

# written in clear, in which case automake, when reading aclocal.m4,

# will think it sees a *use*, and therefore will trigger all it's

# C support machinery. Also note that it means that autoscan, seeing

# CC etc. in the Makefile, will ask for an AC_PROG_CC use...

AC_PREREQ([2.52])

# Autoconf 2.50 wants to disallow AM_ names. We explicitly allow

# the ones we care about.

m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl

# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])

# AM_INIT_AUTOMAKE([OPTIONS])

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

# The call with PACKAGE and VERSION arguments is the old style

# call (pre autoconf-2.50), which is being phased out. PACKAGE

# and VERSION should now be passed to AC_INIT and removed from

# the call to AM_INIT_AUTOMAKE.

# We support both call styles for the transition. After

# the next Automake release, Autoconf can make the AC_INIT

# arguments mandatory, and then we can depend on a new Autoconf

# release and drop the old call support.

AC_DEFUN([AM_INIT_AUTOMAKE],

[AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl

AC_REQUIRE([AC_PROG_INSTALL])dnl

AC_REQUIRE([AC_PROG_INSTALL])

# test to see if srcdir already configured

PACKAGE=[$1]

if test "`cd $srcdir && pwd`" != "`pwd`" &&

AC_SUBST(PACKAGE)

test -f $srcdir/config.status; then

VERSION=[$2]

AC_SUBST(VERSION)

dnl test to see if srcdir already configured

if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then

AC_MSG_ERROR([source directory already configured; run "make distclean" there first])

ifelse([$3],,

# Define the identity of the package.

AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])

dnl Distinguish between old-style and new-style calls.

AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))

m4_ifval([$2],

AC_REQUIRE([AM_SANITY_CHECK])

[m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl

AC_REQUIRE([AC_ARG_PROGRAM])

AC_SUBST([PACKAGE], [$1])dnl

dnl FIXME This is truly gross.

AC_SUBST([VERSION], [$2])],

missing_dir=`cd $ac_aux_dir && pwd`

[_AM_SET_OPTIONS([$1])dnl

AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version}, $missing_dir)

AC_SUBST([PACKAGE], [AC_PACKAGE_TARNAME])dnl

AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)

AC_SUBST([VERSION], [AC_PACKAGE_VERSION])])dnl

AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version}, $missing_dir)

AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)

_AM_IF_OPTION([no-define],,

AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)

[AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])

AC_REQUIRE([AC_PROG_MAKE_SET])])

AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package])])dnl

# Some tools Automake needs.

AC_REQUIRE([AM_SANITY_CHECK])dnl

AC_REQUIRE([AC_ARG_PROGRAM])dnl

AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})

AM_MISSING_PROG(AUTOCONF, autoconf)

AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})

AM_MISSING_PROG(AUTOHEADER, autoheader)

AM_MISSING_PROG(MAKEINFO, makeinfo)

AM_MISSING_PROG(AMTAR, tar)

AM_PROG_INSTALL_SH

AM_PROG_INSTALL_STRIP

# We need awk for the "check" target. The system "awk" is bad on

# some platforms.

AC_REQUIRE([AC_PROG_AWK])dnl

AC_REQUIRE([AC_PROG_MAKE_SET])dnl

_AM_IF_OPTION([no-dependencies],,

[AC_PROVIDE_IFELSE([AC_PROG_][CC],

[_AM_DEPENDENCIES(CC)],

[define([AC_PROG_][CC],

defn([AC_PROG_][CC])[_AM_DEPENDENCIES(CC)])])dnl

AC_PROVIDE_IFELSE([AC_PROG_][CXX],

[_AM_DEPENDENCIES(CXX)],

[define([AC_PROG_][CXX],

defn([AC_PROG_][CXX])[_AM_DEPENDENCIES(CXX)])])dnl

])

Line 187

Line 939

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

# Automake X.Y traces this macro to ensure aclocal.m4 has been

# generated from the m4 files accompanying Automake X.Y.

AC_DEFUN([AM_AUTOMAKE_VERSION],[am__api_version="1.6"])

AC_DEFUN([AM_AUTOMAKE_VERSION],[am__api_version="1.4"])

# AM_SET_CURRENT_AUTOMAKE_VERSION

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

# Call AM_AUTOMAKE_VERSION so it can be traced.

# This function is AC_REQUIREd by AC_INIT_AUTOMAKE.

AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],

[AM_AUTOMAKE_VERSION([1.6.3])])

[AM_AUTOMAKE_VERSION([1.4-p6])])

# Helper functions for option handling. -*- Autoconf -*-

# Check to make sure that the build environment is sane.

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

# serial 2

# _AM_MANGLE_OPTION(NAME)

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

AC_DEFUN([_AM_MANGLE_OPTION],

[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])

# _AM_SET_OPTION(NAME)

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

# Set option NAME. Presently that only means defining a flag for this option.

AC_DEFUN([_AM_SET_OPTION],

[m4_define(_AM_MANGLE_OPTION([$1]), 1)])

# _AM_SET_OPTIONS(OPTIONS)

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

# OPTIONS is a space-separated list of Automake options.

AC_DEFUN([_AM_SET_OPTIONS],

[AC_FOREACH([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])

# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])

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

# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.

AC_DEFUN([_AM_IF_OPTION],

[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])

# Check to make sure that the build environment is sane.

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

# serial 3

# AM_SANITY_CHECK

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

AC_DEFUN([AM_SANITY_CHECK],

[AC_MSG_CHECKING([whether build environment is sane])

# Just in case

sleep 1

echo timestamp > conftest.file

echo timestamp > conftestfile

# Do `set' in a subshell so we don't clobber the current shell's

# arguments. Must try -L first in case configure is actually a

# symlink; some systems play weird games with the mod time of symlinks

# (eg FreeBSD returns the mod time of the symlink's containing

# directory).

if (

set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`

set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`

if test "$[*]" = "X"; then

if test "[$]*" = "X"; then

# -L didn't work.

set X `ls -t $srcdir/configure conftest.file`

set X `ls -t $srcdir/configure conftestfile`

rm -f conftest.file

if test "[$]*" != "X $srcdir/configure conftestfile" \

if test "$[*]" != "X $srcdir/configure conftest.file" \

&& test "[$]*" != "X conftestfile $srcdir/configure"; then

&& test "$[*]" != "X conftest.file $srcdir/configure"; then

# If neither matched, then we have a broken ls. This can happen

# if, for instance, CONFIG_SHELL is bash and it inherits a

Line 293

Line 979

alias in your environment])

test "$[2]" = conftest.file

test "[$]2" = conftestfile

)

then

# Ok.

Line 302

Line 988

AC_MSG_ERROR([newly created file is older than distributed files!

Check your system clock])

rm -f conftest*

AC_MSG_RESULT(yes)])

# -*- Autoconf -*-

dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)

dnl The program must properly implement --version.

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

# serial 3

# AM_MISSING_PROG(NAME, PROGRAM)

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

AC_DEFUN([AM_MISSING_PROG],

[AC_REQUIRE([AM_MISSING_HAS_RUN])

[AC_MSG_CHECKING(for working $2)

$1=${$1-"${am_missing_run}$2"}

# Run test in a subshell; some versions of sh will print an error if

AC_SUBST($1)])

# an executable is not found, even if stderr is redirected.

# Redirect stdin to placate older versions of autoconf. Sigh.

if ($2 --version) < /dev/null > /dev/null 2>&1; then

# AM_MISSING_HAS_RUN

$1=$2

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

AC_MSG_RESULT(found)

# Define MISSING if not defined so far and test if it supports --run.

# If it does, set am_missing_run to use it, otherwise, to nothing.

AC_DEFUN([AM_MISSING_HAS_RUN],

[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"

# Use eval to expand $SHELL

if eval "$MISSING --run true"; then

am_missing_run="$MISSING --run "

else

am_missing_run=

$1="$3/missing $2"

AC_MSG_WARN([`missing' script is too old or missing])

AC_MSG_RESULT(missing)

])

AC_SUBST($1)])

# AM_AUX_DIR_EXPAND

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets

# Like AC_CONFIG_HEADER, but automatically create stamp file.

# $ac_aux_dir to `$srcdir/foo'. In other projects, it is set to

# `$srcdir', `$srcdir/..', or `$srcdir/../..'.

# Of course, Automake must honor this variable whenever it calls a

# tool from the auxiliary directory. The problem is that $srcdir (and

# therefore $ac_aux_dir as well) can be either absolute or relative,

# depending on how configure is run. This is pretty annoying, since

# it makes $ac_aux_dir quite unusable in subdirectories: in the top

# source directory, any form will work fine, but in subdirectories a

# relative path needs to be adjusted first.

# $ac_aux_dir/missing

# fails when called from a subdirectory if $ac_aux_dir is relative

# $top_srcdir/$ac_aux_dir/missing

# fails if $ac_aux_dir is absolute,

# fails when called from a subdirectory in a VPATH build with

# a relative $ac_aux_dir

# The reason of the latter failure is that $top_srcdir and $ac_aux_dir

# are both prefixed by $srcdir. In an in-source build this is usually

# harmless because $srcdir is `.', but things will broke when you

# start a VPATH build or use an absolute $srcdir.

# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,

# iff we strip the leading $srcdir from $ac_aux_dir. That would be:

# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*$.*$"`

# and then we would define $MISSING as

# MISSING="\${SHELL} $am_aux_dir/missing"

# This will work as long as MISSING is not called from configure, because

# unfortunately $(top_srcdir) has no meaning in configure.

# However there are other variables, like CC, which are often used in

# configure, and could therefore not use this "fixed" $ac_aux_dir.

# Another solution, used here, is to always expand $ac_aux_dir to an

# absolute PATH. The drawback is that using absolute paths prevent a

# configured tree to be moved without reconfiguration.

# Rely on autoconf to set up CDPATH properly.

AC_DEFUN([AM_CONFIG_HEADER],

AC_PREREQ([2.50])

[AC_PREREQ([2.12])

AC_CONFIG_HEADER([$1])

dnl When config.status generates a header, we must update the stamp-h file.

dnl This file resides in the same directory as the config header

dnl that is generated. We must strip everything past the first ":",

dnl and everything past the last "/".

AC_OUTPUT_COMMANDS(changequote(<<,>>)dnl

ifelse(patsubst(<<$1>>, <<[^ ]>>, <<>>), <<>>,

<<test -z "<<$>>CONFIG_HEADERS" || echo timestamp > patsubst(<<$1>>, <<^$[^:]*/$?.*>>, <<\1>>)stamp-h<<>>dnl>>,

<<am_indx=1

for am_file in <<$1>>; do

case " <<$>>CONFIG_HEADERS " in

*" <<$>>am_file "*<<)>>

echo timestamp > `echo <<$>>am_file | sed -e 's%:.*%%' -e 's%[^/]*$%%'`stamp-h$am_indx

;;

esac

am_indx=`expr "<<$>>am_indx" + 1`

done<<>>dnl>>)

changequote([,]))])

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

# serial 47 AC_PROG_LIBTOOL

# Debian $Rev: 149 $

# 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_DEFUN([AM_AUX_DIR_EXPAND], [

# expand $ac_aux_dir to an absolute path

am_aux_dir=`cd $ac_aux_dir && pwd`

])

# AM_PROG_INSTALL_SH

# AC_PROG_LIBTOOL

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

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

# Define $install_sh.

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"

# This program is free software; you can redistribute it and/or modify

# Always use our own libtool.

# it under the terms of the GNU General Public License as published by

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

# the Free Software Foundation; either version 2, or (at your option)

AC_SUBST(LIBTOOL)dnl

# any later version.

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

# Prevent multiple expansion

# but WITHOUT ANY WARRANTY; without even the implied warranty of

define([AC_PROG_LIBTOOL], [])

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

])# _AC_PROG_LIBTOOL

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

AC_DEFUN([AM_PROG_INSTALL_SH],

# AC_LIBTOOL_SETUP

[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl

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

install_sh=${install_sh-"$am_aux_dir/install-sh"}

AC_DEFUN([AC_LIBTOOL_SETUP],

AC_SUBST(install_sh)])

[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

# AM_PROG_INSTALL_STRIP

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

# This program is free software; you can redistribute it and/or modify

AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

# it under the terms of the GNU General Public License as published by

_LT_AC_PROG_ECHO_BACKSLASH

# the Free Software Foundation; either version 2, or (at your option)

# any later version.

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

case $host_os in

# but WITHOUT ANY WARRANTY; without even the implied warranty of

aix3*)

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# AIX sometimes has problems with the GCC collect2 program. For some

# GNU General Public License for more details.

# 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

;;

esac

# You should have received a copy of the GNU General Public License

# Sed substitution that helps us do robust quoting. It backslashifies

# along with this program; if not, write to the Free Software

# metacharacters that are still active within double-quoted strings.

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

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

# 02111-1307, USA.

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

# One issue with vendor `install' (even GNU) is that you can't

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

# specify the program used to strip binaries. This is especially

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

# annoying in cross-compiling environments, where the build's strip

# is unlikely to handle the host's binaries.

# Fortunately install-sh will honor a STRIPPROG variable, so we

# always use install-sh in `make install-strip', and initialize

# STRIPPROG with the value of the STRIP variable (set by the user).

AC_DEFUN([AM_PROG_INSTALL_STRIP],

[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl

# Installed binaries are usually stripped using `strip' when the user

# run `make install-strip'. However `strip' might not be the right

# tool to use in cross-compilation environments, therefore Automake

# will honor the `STRIP' environment variable to overrule this program.

dnl Don't test for $cross_compiling = yes, because it might be `maybe'.

if test "$cross_compiling" != no; then

AC_CHECK_TOOL([STRIP], [strip], :)

INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"

AC_SUBST([INSTALL_STRIP_PROGRAM])])

# serial 4 -*- Autoconf -*-

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

# This program is free software; you can redistribute it and/or modify

# Constants:

# it under the terms of the GNU General Public License as published by

rm="rm -f"

# the Free Software Foundation; either version 2, or (at your option)

# any later version.

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

# Global variables:

# but WITHOUT ANY WARRANTY; without even the implied warranty of

default_ofile=libtool

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

can_build_shared=yes

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

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

# along with this program; if not, write to the Free Software

# which needs '.lib').

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

libext=a

# 02111-1307, USA.

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

# There are a few dirty hacks below to avoid letting `AC_PROG_CC' be

old_CC="$CC"

# written in clear, in which case automake, when reading aclocal.m4,

old_CFLAGS="$CFLAGS"

# will think it sees a *use*, and therefore will trigger all it's

# C support machinery. Also note that it means that autoscan, seeing

# CC etc. in the Makefile, will ask for an AC_PROG_CC use...

# 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 "$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=

# _AM_DEPENDENCIES(NAME)

if test -n "$RANLIB"; then

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

case $host_os in

# See how the compiler implements dependency checking.

openbsd*)

# NAME is "CC", "CXX", "GCJ", or "OBJC".

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

# We try a few techniques and use that to set a single cache variable.

;;

# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was

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

# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular

# dependency, and given that the user is not expected to run this macro,

# just rely on AC_PROG_CC.

AC_DEFUN([_AM_DEPENDENCIES],

[AC_REQUIRE([AM_SET_DEPDIR])dnl

AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl

AC_REQUIRE([AM_MAKE_INCLUDE])dnl

AC_REQUIRE([AM_DEP_TRACK])dnl

ifelse([$1], CC, [depcc="$CC" am_compiler_list=],

[$1], CXX, [depcc="$CXX" am_compiler_list=],

[$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],

[$1], GCJ, [depcc="$GCJ" am_compiler_list='gcc3 gcc'],

[depcc="$$1" am_compiler_list=])

AC_CACHE_CHECK([dependency style of $depcc],

[am_cv_$1_dependencies_compiler_type],

[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

# We make a subdir and do the tests there. Otherwise we can end up

# making bogus files that we don't know about and never remove. For

# instance it was reported that on HP-UX the gcc test will end up

# making a dummy file named `D' -- because `-MD' means `put the output

# in D'.

mkdir conftest.dir

# Copy depcomp to subdir because otherwise we won't find it if we're

# using a relative directory.

cp "$am_depcomp" conftest.dir

cd conftest.dir

am_cv_$1_dependencies_compiler_type=none

if test "$am_compiler_list" = ""; then

am_compiler_list=`sed -n ['s/^#*$[a-zA-Z0-9]*$)$/\1/p'] < ./depcomp`

for depmode in $am_compiler_list; do

# We need to recreate these files for each test, as the compiler may

# overwrite some of them when testing with obscure command lines.

# This happens at least with the AIX C compiler.

echo '#include "conftest.h"' > conftest.c

echo 'int i;' > conftest.h

echo "${am__include} ${am__quote}conftest.Po${am__quote}" > confmf

case $depmode in

nosideeffect)

# after this tag, mechanisms are not by side-effect, so they'll

# only be used when explicitly requested

if test "x$enable_dependency_tracking" = xyes; then

continue

else

break

;;

none) break ;;

esac

# We check with `-c' and `-o' for the sake of the "dashmstdout"

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

# mode. It turns out that the SunPro C++ compiler does not properly

# handle `-M -o', and we need to detect this.

if depmode=$depmode \

source=conftest.c object=conftest.o \

depfile=conftest.Po tmpdepfile=conftest.TPo \

$SHELL ./depcomp $depcc -c conftest.c -o conftest.o >/dev/null 2>&1 &&

grep conftest.h conftest.Po > /dev/null 2>&1 &&

${MAKE-make} -s -f confmf > /dev/null 2>&1; then

am_cv_$1_dependencies_compiler_type=$depmode

break

done

cd ..

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

rm -rf conftest.dir

case $deplibs_check_method in

else

file_magic*)

am_cv_$1_dependencies_compiler_type=none

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

AC_PATH_MAGIC

])

;;

AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])

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)

# AM_SET_DEPDIR

AC_ARG_ENABLE([libtool-lock],

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

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

# Choose a directory name for dependency files.

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

# This macro is AC_REQUIREd in _AM_DEPENDENCIES

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

AC_DEFUN([AM_SET_DEPDIR],

[rm -f .deps 2>/dev/null

mkdir .deps 2>/dev/null

if test -d .deps; then

DEPDIR=.deps

else

# MS-DOS does not allow filenames that begin with a dot.

DEPDIR=_deps

rmdir .deps 2>/dev/null

AC_SUBST([DEPDIR])

])

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

# AM_DEP_TRACK

# Use C for the default configuration in the libtool script

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

tagname=

AC_DEFUN([AM_DEP_TRACK],

AC_LIBTOOL_LANG_C_CONFIG

[AC_ARG_ENABLE(dependency-tracking,

_LT_AC_TAGCONFIG

[ --disable-dependency-tracking Speeds up one-time builds

])# AC_LIBTOOL_SETUP

--enable-dependency-tracking Do not reject slow dependency extractors])

if test "x$enable_dependency_tracking" != xno; then

am_depcomp="$ac_aux_dir/depcomp"

AMDEPBACKSLASH='\'

AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])

AC_SUBST([AMDEPBACKSLASH])

])

# Generate code to set up dependency tracking. -*- Autoconf -*-

# _LT_AC_SYS_COMPILER

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

AC_DEFUN([_LT_AC_SYS_COMPILER],

[AC_REQUIRE([AC_PROG_CC])dnl

# This program is free software; you can redistribute it and/or modify

# If no C compiler was specified, use CC.

# it under the terms of the GNU General Public License as published by

LTCC=${LTCC-"$CC"}

# the Free Software Foundation; either version 2, or (at your option)

# any later version.

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

# Allow CC to be a program name with arguments.

# but WITHOUT ANY WARRANTY; without even the implied warranty of

compiler=$CC

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

])# _LT_AC_SYS_COMPILER

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

#serial 2

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

# _AM_OUTPUT_DEPENDENCY_COMMANDS

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

AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],

[for mf in $CONFIG_FILES; do

# Strip MF so we end up with the name of the file.

mf=`echo "$mf" | sed -e 's/:.*$//'`

# Check whether this is an Automake generated Makefile or not.

# We used to match only the files named `Makefile.in', but

# some people rename them; so instead we look at the file content.

# Grep'ing the first line is not enough: some people post-process

# each Makefile.in and add a new line on top of each file to say so.

# So let's grep whole file.

if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then

dirpart=`AS_DIRNAME("$mf")`

else

continue

grep '^DEP_FILES *= *[[^ @%:@]]' < "$mf" > /dev/null || continue

# Extract the definition of DEP_FILES from the Makefile without

# running `make'.

DEPDIR=`sed -n -e '/^DEPDIR = / s///p' < "$mf"`

test -z "$DEPDIR" && continue

# When using ansi2knr, U may be empty or an underscore; expand it

U=`sed -n -e '/^U = / s///p' < "$mf"`

test -d "$dirpart/$DEPDIR" || mkdir "$dirpart/$DEPDIR"

# We invoke sed twice because it is the simplest approach to

# changing $(DEPDIR) to its actual value in the expansion.

for file in `sed -n -e '

/^DEP_FILES = .*\\\\$/ {

s/^DEP_FILES = //

:loop

s/\\\\$//

/\\\\$/ b loop

}

/^DEP_FILES = / s/^DEP_FILES = //p' < "$mf" | \

sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do

# Make sure the directory exists.

test -f "$dirpart/$file" && continue

fdir=`AS_DIRNAME(["$file"])`

AS_MKDIR_P([$dirpart/$fdir])

# echo "creating $dirpart/$file"

echo '# dummy' > "$dirpart/$file"

done

])# _AM_OUTPUT_DEPENDENCY_COMMANDS

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

AC_DIVERT_POP

])# _LT_AC_SHELL_INIT

# AM_OUTPUT_DEPENDENCY_COMMANDS

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

# This macro should only be invoked once -- use via AC_REQUIRE.

# This code is only required when automatic dependency tracking

# is enabled. FIXME. This creates each `.P' file that we will

# need in order to bootstrap the dependency handling code.

AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],

[AC_CONFIG_COMMANDS([depfiles],

[test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],

[AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])

])

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

# serial 2

# AM_MAKE_INCLUDE()

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

# Check to see how make treats includes.

AC_DEFUN([AM_MAKE_INCLUDE],

[am_make=${MAKE-make}

cat > confinc << 'END'

doit:

@echo done

END

# If we don't find an include directive, just comment out the code.

AC_MSG_CHECKING([for style of include used by $am_make])

am__include="#"

am__quote=

_am_result=none

# First try GNU make style include.

echo "include confinc" > confmf

# We grep out `Entering directory' and `Leaving directory'

# messages which can occur if `w' ends up in MAKEFLAGS.

# In particular we don't look at `^make:' because GNU make might

# be invoked under some other name (usually "gmake"), in which

# case it prints its new name instead of `make'.

if test "`$am_make -s -f confmf 2> /dev/null | fgrep -v 'ing directory'`" = "done"; then

am__include=include

am__quote=

_am_result=GNU

# Now try BSD make style include.

if test "$am__include" = "#"; then

echo '.include "confinc"' > confmf

if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then

am__include=.include

am__quote="\""

_am_result=BSD

AC_SUBST(am__include)

AC_SUBST(am__quote)

AC_MSG_RESULT($_am_result)

rm -f confinc confmf

])

# AM_CONDITIONAL -*- Autoconf -*-

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

# serial 5

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

AC_PREREQ(2.52)

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

# AM_CONDITIONAL(NAME, SHELL-CONDITION)

echo=${ECHO-echo}

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

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

# Define a conditional.

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

AC_DEFUN([AM_CONDITIONAL],

shift

[ifelse([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],

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

[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl

# Avoid inline document here, it may be left over

AC_SUBST([$1_TRUE])

AC_SUBST([$1_FALSE])

elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then

if $2; then

# Yippee, $echo works!

$1_TRUE=

$1_FALSE='#'

else

$1_TRUE='#'

# Restart under the correct shell.

$1_FALSE=

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

AC_CONFIG_COMMANDS_PRE(

[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then

AC_MSG_ERROR([conditional \"$1\" was never defined.

Usually this means the macro was only invoked conditionally.])

fi])])

# Like AC_CONFIG_HEADER, but automatically create stamp file. -*- Autoconf -*-

# This program 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, or (at your option)

# any later version.

# This program 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 this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

# 02111-1307, USA.

AC_PREREQ([2.52])

# serial 6

# When config.status generates a header, we must update the stamp-h file.

# This file resides in the same directory as the config header

# that is generated. We must strip everything past the first ":",

# and everything past the last "/".

# _AM_DIRNAME(PATH)

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

# Like AS_DIRNAME, only do it during macro expansion

AC_DEFUN([_AM_DIRNAME],

[m4_if(regexp([$1], [^.*[^/]//*[^/][^/]*/*$]), -1,

m4_if(regexp([$1], [^//$[^/]\|$$]), -1,

m4_if(regexp([$1], [^/.*]), -1,

[.],

patsubst([$1], [^$/$.*], [\1])),

patsubst([$1], [^$//$$[^/].*\|$$], [\1])),

patsubst([$1], [^$.*[^/]$//*[^/][^/]*/*$], [\1]))[]dnl

])# _AM_DIRNAME

# The stamp files are numbered to have different names.

# We could number them on a directory basis, but that's additional

# complications, let's have a unique counter.

m4_define([_AM_STAMP_Count], [0])

# _AM_STAMP(HEADER)

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

# The name of the stamp file for HEADER.

AC_DEFUN([_AM_STAMP],

[m4_define([_AM_STAMP_Count], m4_incr(_AM_STAMP_Count))dnl

AS_ESCAPE(_AM_DIRNAME(patsubst([$1],

[:.*])))/stamp-h[]_AM_STAMP_Count])

# _AM_CONFIG_HEADER(HEADER[:SOURCES], COMMANDS, INIT-COMMANDS)

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

# We used to try to get a real timestamp in stamp-h. But the fear is that

# that will cause unnecessary cvs conflicts.

AC_DEFUN([_AM_CONFIG_HEADER],

[# Add the stamp file to the list of files AC keeps track of,

# along with our hook.

AC_CONFIG_HEADERS([$1],

[# update the timestamp

echo 'timestamp for $1' >"_AM_STAMP([$1])"

$2],

[$3])

])# _AM_CONFIG_HEADER

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

# used as fallback echo

shift

cat <<EOF

[$]*

EOF

exit 0

# AM_CONFIG_HEADER(HEADER[:SOURCES]..., COMMANDS, INIT-COMMANDS)

# The HP-UX ksh and POSIX shell print the target directory to stdout

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

# if CDPATH is set.

AC_DEFUN([AM_CONFIG_HEADER],

if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi

[AC_FOREACH([_AM_File], [$1], [_AM_CONFIG_HEADER(_AM_File, [$2], [$3])])

])# AM_CONFIG_HEADER

# libtool.m4 - Configure libtool for the host system. -*-Shell-script-*-

# serial 46 AC_PROG_LIBTOOL

AC_DEFUN([AC_PROG_LIBTOOL],

if test -z "$ECHO"; then

[AC_REQUIRE([AC_LIBTOOL_SETUP])dnl

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

done

# This can be used to rebuild libtool when needed

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

LIBTOOL_DEPS="$ac_aux_dir/ltmain.sh"

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.

# Always use our own libtool.

lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

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

for dir in $PATH /usr/ucb; do

AC_SUBST(LIBTOOL)dnl

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

done

IFS="$lt_save_ifs"

# Prevent multiple expansion

if test "X$echo" = Xecho; then

define([AC_PROG_LIBTOOL], [])

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

AC_DEFUN([AC_LIBTOOL_SETUP],

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

[AC_PREREQ(2.13)dnl

if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null

AC_REQUIRE([AC_ENABLE_SHARED])dnl

then

AC_REQUIRE([AC_ENABLE_STATIC])dnl

break

AC_REQUIRE([AC_ENABLE_FAST_INSTALL])dnl

AC_REQUIRE([AC_CANONICAL_HOST])dnl

prev="$cmd"

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

done

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([LT_AC_PROG_SED])dnl

AC_REQUIRE([AC_PROG_LN_S])dnl

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

AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl

echo_test_string=`eval $prev`

AC_REQUIRE([AC_OBJEXT])dnl

export echo_test_string

AC_REQUIRE([AC_EXEEXT])dnl

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

dnl

else

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

echo=echo

_LT_AC_PROG_ECHO_BACKSLASH

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

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

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

case $deplibs_check_method in

ECHO=$echo

file_magic*)

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

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

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

AC_PATH_MAGIC

;;

esac

AC_CHECK_TOOL(RANLIB, ranlib, :)

AC_SUBST(ECHO)

AC_CHECK_TOOL(STRIP, strip, :)

])])# _LT_AC_PROG_ECHO_BACKSLASH

ifdef([AC_PROVIDE_AC_LIBTOOL_DLOPEN], enable_dlopen=yes, enable_dlopen=no)

ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],

enable_win32_dll=yes, enable_win32_dll=no)

AC_ARG_ENABLE(libtool-lock,

# _LT_AC_LOCK

[ --disable-libtool-lock avoid locking (might break parallel builds)])

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

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

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} -32"

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

;;

*N32*)

LD="${LD-ld} -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

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

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

*32-bit*)

case $host in

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

rm -rf conftest*

;;

Line 975

Line 1548

SAVE_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS -belf"

AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,

[AC_LANG_SAVE

[AC_LANG_PUSH(C)

AC_LANG_C

AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])

AC_LANG_RESTORE])

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"

;;

AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],

ifdef([AC_PROVIDE_AC_LIBTOOL_WIN32_DLL],

[*-*-cygwin* | *-*-mingw* | *-*-pw32*)

AC_CHECK_TOOL(DLLTOOL, dlltool, false)

AC_CHECK_TOOL(AS, as, false)

AC_CHECK_TOOL(OBJDUMP, objdump, false)

# recent cygwin and mingw systems supply a stub DllMain which the user

# can override, but on older systems we have to supply one

AC_CACHE_CHECK([if libtool should supply DllMain function], lt_cv_need_dllmain,

[AC_TRY_LINK([],

[extern int __attribute__((__stdcall__)) DllMain(void*, int, void*);

DllMain (0, 0, 0);],

[lt_cv_need_dllmain=no],[lt_cv_need_dllmain=yes])])

case $host/$CC in

*-*-cygwin*/gcc*-mno-cygwin*|*-*-mingw*)

# old mingw systems require "-dll" to link a DLL, while more recent ones

# require "-mdll"

SAVE_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS -mdll"

AC_CACHE_CHECK([how to link DLLs], lt_cv_cc_dll_switch,

[AC_TRY_LINK([], [], [lt_cv_cc_dll_switch=-mdll],[lt_cv_cc_dll_switch=-dll])])

CFLAGS="$SAVE_CFLAGS" ;;

*-*-cygwin* | *-*-pw32*)

# cygwin systems need to pass --dll to the linker, and not link

# crt.o which will require a WinMain@16 definition.

lt_cv_cc_dll_switch="-Wl,--dll -nostartfiles" ;;

esac

;;

])

esac

_LT_AC_LTCONFIG_HACK

need_locks="$enable_libtool_lock"

])

])# _LT_AC_LOCK

# AC_LIBTOOL_HEADER_ASSERT

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

AC_DEFUN([AC_LIBTOOL_HEADER_ASSERT],

[AC_CACHE_CHECK([whether $CC supports assert without backlinking],

[lt_cv_func_assert_works],

[case $host in

*-*-solaris*)

if test "$GCC" = yes && test "$with_gnu_ld" != yes; then

case `$CC --version 2>/dev/null` in

[[12]].*) lt_cv_func_assert_works=no ;;

*) lt_cv_func_assert_works=yes ;;

esac

;;

esac])

if test "x$lt_cv_func_assert_works" = xyes; then

# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

AC_CHECK_HEADERS(assert.h)

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

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

# Check whether the given compiler option works

AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],

[AC_REQUIRE([LT_AC_PROG_SED])

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

[$2=no

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

printf "$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}? :&$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

if test ! -s conftest.err; then

$2=yes

])# AC_LIBTOOL_HEADER_ASSERT

$rm conftest*

# _LT_AC_CHECK_DLFCN

])

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

AC_DEFUN([_LT_AC_CHECK_DLFCN],

[AC_CHECK_HEADERS(dlfcn.h)

])# _LT_AC_CHECK_DLFCN

# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

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

AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],

[AC_REQUIRE([AC_CANONICAL_HOST])

AC_REQUIRE([AC_PROG_NM])

AC_REQUIRE([AC_OBJEXT])

# Check for command to grab the raw symbol name followed by C symbol from nm.

AC_MSG_CHECKING([command to parse $NM output])

AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [dnl

# These are sane defaults that work on at least a few old systems.

# [They come from Ultrix. What could be older than Ultrix?!! ;)]

# Character class describing NM global symbol codes.

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

symcode='[[BCDEGRST]]'

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

else

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

])# AC_LIBTOOL_COMPILER_OPTION

# Regexp to match symbols that can be accessed directly from C.

sympat='$[[_A-Za-z]][[_A-Za-z0-9]]*$'

# Transform the above into a raw symbol and a C symbol.

# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,

symxfrm='\1 \2\3 \3'

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

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

# Check whether the given compiler option works

AC_DEFUN([AC_LIBTOOL_LINKER_OPTION],

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

[$2=no

save_LDFLAGS="$LDFLAGS"

LDFLAGS="$LDFLAGS $3"

printf "$lt_simple_link_test_code" > conftest.$ac_ext

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

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

else

$2=yes

$rm conftest*

LDFLAGS="$save_LDFLAGS"

])

# Transform an extracted symbol line into a proper C declaration

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

lt_cv_global_symbol_to_cdecl="sed -n -e 's/^. .* $.*$$/extern char \1;/p'"

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

else

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

])# AC_LIBTOOL_LINKER_OPTION

# Transform an extracted symbol line into symbol name and symbol address

lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: $[[^ ]]*$ $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode $[[^ ]]*$ $[[^ ]]*$$/ {\"\2\", (lt_ptr) \&\2},/p'"

# Define system-specific variables.

# AC_LIBTOOL_SYS_MAX_CMD_LEN

case $host_os in

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

aix*)

AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],

symcode='[[BCDT]]'

[# find the maximum length of command line arguments

;;

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

cygwin* | mingw* | pw32*)

AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl

symcode='[[ABCDGISTW]]'

i=0

;;

testring="ABCD"

hpux*) # Its linker distinguishes data from code symbols

lt_cv_global_symbol_to_cdecl="sed -n -e 's/^T .* $.*$$/extern char \1();/p' -e 's/^$symcode* .* $.*$$/extern char \1;/p'"

case $build_os in

lt_cv_global_symbol_to_c_name_address="sed -n -e 's/^: $[[^ ]]*$ $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* $[[^ ]]*$ $[[^ ]]*$$/ {\"\2\", (lt_ptr) \&\2},/p'"

msdosdjgpp*)

;;

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

irix* | nonstopux*)

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

symcode='[[BCDEGRST]]'

# 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

;;

osf*)

symcode='[[BCDEGQRST]]'

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;

;;

solaris* | sysv5*)

symcode='[[BDT]]'

cygwin* | mingw*)

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

;;

sysv4)

symcode='[[DFNSTU]]'

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;

;;

esac

# Handle CRLF in mingw tool chain

opt_cr=

# If test is not a shell built-in, we'll probably end up computing a

case $host_os in

# maximum length that is only half of the actual maximum length, but

mingw*)

# we can't tell.

opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp

while (test "X"`$CONFIG_SHELL [$]0 --fallback-echo "X$testring" 2>/dev/null` \

= "XX$testring") >/dev/null 2>&1 &&

new_result=`expr "X$testring" : ".*" 2>&1` &&

lt_cv_sys_max_cmd_len=$new_result &&

test $i != 17 # 1/2 MB should be enough

i=`expr $i + 1`

testring=$testring$testring

done

testring=

# Add a significant safety factor because C++ compilers can tack on massive

# amounts of additional arguments before passing them to the linker.

# It appears as though 1/2 is a usable value.

lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`

;;

esac

])

# If we're using GNU nm, then use its standard symbol codes.

if test -n $lt_cv_sys_max_cmd_len ; then

if $NM -V 2>&1 | egrep '(GNU|with BFD)' > /dev/null; then

AC_MSG_RESULT($lt_cv_sys_max_cmd_len)

symcode='[[ABCDGISTW]]'

else

AC_MSG_RESULT(none)

])# AC_LIBTOOL_SYS_MAX_CMD_LEN

# Try without a prefix undercore, then with it.

for ac_symprfx in "" "_"; do

# Write the raw and C identifiers.

# _LT_AC_CHECK_DLFCN

lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]$$symcode$symcode*$[[ ]][[ ]]*$$ac_symprfx$$sympat$opt_cr$/$symxfrm/p'"

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

AC_DEFUN([_LT_AC_CHECK_DLFCN],

[AC_CHECK_HEADERS(dlfcn.h)dnl

])# _LT_AC_CHECK_DLFCN

# Check to see that the pipe works correctly.

pipe_works=no

rm -f conftest*

cat > conftest.$ac_ext <<EOF

#ifdef __cplusplus

extern "C" {

#endif

char nm_test_var;

void nm_test_func(){}

#ifdef __cplusplus

}

#endif

int main(){nm_test_var='a';nm_test_func();return(0);}

EOF

if AC_TRY_EVAL(ac_compile); then

# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,

# Now try to grab the symbols.

# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)

nlist=conftest.nm

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

if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then

AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],

# Try sorting and uniquifying the output.

[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

if sort "$nlist" | uniq > "$nlist"T; then

if test "$cross_compiling" = yes; then :

mv -f "$nlist"T "$nlist"

[$4]

else

rm -f "$nlist"T

lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

lt_status=$lt_dlunknown

cat > conftest.$ac_ext <<EOF

[#line __oline__ "configure"

#include "confdefs.h"

# Make sure that we snagged all the symbols we need.

#if HAVE_DLFCN_H

if egrep ' nm_test_var$' "$nlist" >/dev/null; then

#include <dlfcn.h>

if egrep ' nm_test_func$' "$nlist" >/dev/null; then

cat <<EOF > conftest.$ac_ext

#ifdef __cplusplus

extern "C" {

#endif

EOF

#include <stdio.h>

# Now generate the symbol file.

eval "$lt_cv_global_symbol_to_cdecl"' < "$nlist" >> conftest.$ac_ext'

cat <<EOF >> conftest.$ac_ext

#ifdef RTLD_GLOBAL

#if defined (__STDC__) && __STDC__

# define LT_DLGLOBAL RTLD_GLOBAL

# define lt_ptr void *

#else

# define lt_ptr char *

# ifdef DL_GLOBAL

# define const

# define LT_DLGLOBAL DL_GLOBAL

# else

# define LT_DLGLOBAL 0

# endif

#endif

/* The mapping between symbol names and symbols. */

/* We may have to define LT_DLLAZY_OR_NOW in the command line if we

const struct {

find out it does not work in some platform. */

const char *name;

#ifndef LT_DLLAZY_OR_NOW

lt_ptr address;

# ifdef RTLD_LAZY

}

# define LT_DLLAZY_OR_NOW RTLD_LAZY

lt_preloaded_symbols[[]] =

# else

{

# ifdef DL_LAZY

EOF

# define LT_DLLAZY_OR_NOW DL_LAZY

sed "s/^$symcode$symcode* $.*$ $.*$$/ {\"\2\", (lt_ptr) \&\2},/" < "$nlist" >> conftest.$ac_ext

# else

cat <<\EOF >> conftest.$ac_ext

# ifdef RTLD_NOW

{0, (lt_ptr) 0}

# define LT_DLLAZY_OR_NOW RTLD_NOW

};

# else

# ifdef DL_NOW

# define LT_DLLAZY_OR_NOW DL_NOW

# else

# define LT_DLLAZY_OR_NOW 0

# endif

#endif

#ifdef __cplusplus

}

extern "C" void exit (int);

#endif

void fnord() { int i=42;}

int main ()

{

void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

int status = $lt_dlunknown;

if (self)

{

if (dlsym (self,"fnord")) status = $lt_dlno_uscore;

else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

/* dlclose (self); */

}

exit (status);

}]

EOF

# Now try linking the two files.

if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then

mv conftest.$ac_objext conftstm.$ac_objext

(./conftest; exit; ) 2>/dev/null

save_LIBS="$LIBS"

lt_status=$?

save_CFLAGS="$CFLAGS"

case x$lt_status in

LIBS="conftstm.$ac_objext"

x$lt_dlno_uscore) $1 ;;

CFLAGS="$CFLAGS$no_builtin_flag"

x$lt_dlneed_uscore) $2 ;;

if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext; then

x$lt_unknown|x*) $3 ;;

pipe_works=yes

esac

else :

# compilation failed

LIBS="$save_LIBS"

CFLAGS="$save_CFLAGS"

else

echo "cannot find nm_test_func in $nlist" >&AC_FD_CC

else

rm -fr conftest*

echo "cannot find nm_test_var in $nlist" >&AC_FD_CC

])# _LT_AC_TRY_DLOPEN_SELF

else

echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AC_FD_CC

else

echo "$progname: failed program was:" >&AC_FD_CC

cat conftest.$ac_ext >&5

rm -f conftest* conftst*

# Do not use the global_symbol_pipe unless it works.

if test "$pipe_works" = yes; then

# AC_LIBTOOL_DLOPEN_SELF

break

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

AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],

[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

if test "x$enable_dlopen" != xyes; then

enable_dlopen=unknown

enable_dlopen_self=unknown

enable_dlopen_self_static=unknown

else

lt_cv_sys_global_symbol_pipe=

lt_cv_dlopen=no

lt_cv_dlopen_libs=

done

case $host_os in

beos*)

lt_cv_dlopen="load_add_on"

lt_cv_dlopen_libs=

lt_cv_dlopen_self=yes

;;

mingw* | pw32*)

lt_cv_dlopen="LoadLibrary"

lt_cv_dlopen_libs=

;;

cygwin*)

lt_cv_dlopen="dlopen"

lt_cv_dlopen_libs=

;;

darwin*)

# if libdl is installed we need to link against it

AC_CHECK_LIB([dl], [dlopen],

[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[

lt_cv_dlopen="dyld"

lt_cv_dlopen_libs=

lt_cv_dlopen_self=yes

])

global_symbol_pipe="$lt_cv_sys_global_symbol_pipe"

;;

if test -z "$lt_cv_sys_global_symbol_pipe"; then

global_symbol_to_cdecl=

global_symbol_to_c_name_address=

else

global_symbol_to_cdecl="$lt_cv_global_symbol_to_cdecl"

global_symbol_to_c_name_address="$lt_cv_global_symbol_to_c_name_address"

if test -z "$global_symbol_pipe$global_symbol_to_cdec$global_symbol_to_c_name_address";

then

AC_MSG_RESULT(failed)

else

AC_MSG_RESULT(ok)

]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE

# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

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

AC_CHECK_FUNC([shl_load],

AC_DEFUN([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],

[lt_cv_dlopen="shl_load"],

[# Find the correct PATH separator. Usually this is `:', but

[AC_CHECK_LIB([dld], [shl_load],

# DJGPP uses `;' like DOS.

[lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],

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

[AC_CHECK_FUNC([dlopen],

UNAME=${UNAME-`uname 2>/dev/null`}

[lt_cv_dlopen="dlopen"],

case X$UNAME in

[AC_CHECK_LIB([dl], [dlopen],

*-DOS) lt_cv_sys_path_separator=';' ;;

[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],

*) lt_cv_sys_path_separator=':' ;;

[AC_CHECK_LIB([svld], [dlopen],

[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],

[AC_CHECK_LIB([dld], [dld_link],

[lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])

])

;;

esac

PATH_SEPARATOR=$lt_cv_sys_path_separator

if test "x$lt_cv_dlopen" != xno; then

enable_dlopen=yes

else

enable_dlopen=no

])# _LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

# _LT_AC_PROG_ECHO_BACKSLASH

case $lt_cv_dlopen in

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

dlopen)

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

save_CPPFLAGS="$CPPFLAGS"

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

test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH],

[ifdef([AC_DIVERSION_NOTICE], [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],

[AC_DIVERT_PUSH(NOTICE)])

_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR

# Check that we are running under the correct shell.

save_LDFLAGS="$LDFLAGS"

SHELL=${CONFIG_SHELL-/bin/sh}

eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

case X$ECHO in

save_LIBS="$LIBS"

X*--fallback-echo)

LIBS="$lt_cv_dlopen_libs $LIBS"

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

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

AC_CACHE_CHECK([whether a program can dlopen itself],

lt_cv_dlopen_self, [dnl

_LT_AC_TRY_DLOPEN_SELF(

lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,

lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)

])

if test "x$lt_cv_dlopen_self" = xyes; then

LDFLAGS="$LDFLAGS $link_static_flag"

AC_CACHE_CHECK([whether a statically linked program can dlopen itself],

lt_cv_dlopen_self_static, [dnl

_LT_AC_TRY_DLOPEN_SELF(

lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,

lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross)

])

CPPFLAGS="$save_CPPFLAGS"

LDFLAGS="$save_LDFLAGS"

LIBS="$save_LIBS"

;;

esac

echo=${ECHO-echo}

case $lt_cv_dlopen_self in

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

yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

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

*) enable_dlopen_self=unknown ;;

shift

esac

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+"[$]@"}

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

case $lt_cv_dlopen_self_static in

# used as fallback echo

yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

shift

*) enable_dlopen_self_static=unknown ;;

cat <<EOF

esac

EOF

exit 0

])# AC_LIBTOOL_DLOPEN_SELF

# The HP-UX ksh and POSIX shell print the target directory to stdout

# if CDPATH is set.

if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi

if test -z "$ECHO"; then

# AC_LIBTOOL_PROG_CC_C_O([TAGNAME])

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

# Check to see if options -c and -o are simultaneously supported by compiler

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

AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],

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

[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl

if (echo_test_string="`eval $cmd`") 2>/dev/null &&

AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],

echo_test_string="`eval $cmd`" &&

[_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],

(test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null

[_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no

$rm -r conftest 2>/dev/null

mkdir conftest

cd conftest

mkdir out

printf "$lt_simple_compile_test_code" > conftest.$ac_ext

# According to Tom Tromey, Ian Lance Taylor reported there are C compilers

# that will create temporary files in the current directory regardless of

# the output directory. Thus, making CWD read-only will cause this test

# to fail, enabling locking or at least warning the user not to do parallel

# builds.

chmod -w .

lt_compiler_flag="-o out/conftest2.$ac_objext"

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

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

-e 's:.*FLAGS}? :&$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>out/conftest.err)

ac_status=$?

cat out/conftest.err >&AS_MESSAGE_LOG_FD

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

if (exit $ac_status) && test -s out/conftest2.$ac_objext

then

break

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

# So say no if there are warnings

if test ! -s out/conftest.err; then

_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes

done

chmod u+w .

$rm conftest*

# SGI C++ compiler will create directory out/ii_files/ for

# template instantiation

test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files

$rm out/* && rmdir out

cd ..

rmdir conftest

$rm conftest*

])

])# AC_LIBTOOL_PROG_CC_C_O

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

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

# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])

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

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

# Check to see if we can do hard links to lock some files if needed

AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS],

[AC_REQUIRE([_LT_AC_LOCK])dnl

hard_links="nottested"

if test "$_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then

# do not overwrite the value of need_locks provided by the user

AC_MSG_CHECKING([if we can lock with hard links])

hard_links=yes

$rm conftest*

ln conftest.a conftest.b 2>/dev/null && hard_links=no

touch conftest.a

ln conftest.a conftest.b 2>&5 || hard_links=no

ln conftest.a conftest.b 2>/dev/null && hard_links=no

AC_MSG_RESULT([$hard_links])

if test "$hard_links" = no; then

AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])

need_locks=warn

else

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

need_locks=no

# backslashes. This makes it impossible to quote backslashes using

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

])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS

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

IFS="${IFS= }"; save_ifs="$IFS"; IFS=$PATH_SEPARATOR

for dir in $PATH /usr/ucb; do

# AC_LIBTOOL_OBJDIR

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

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

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

AC_DEFUN([AC_LIBTOOL_OBJDIR],

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

[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],

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

[rm -f .libs 2>/dev/null

echo="$dir/echo"

mkdir .libs 2>/dev/null

break

if test -d .libs; then

lt_cv_objdir=.libs

else

# MS-DOS does not allow filenames that begin with a dot.

lt_cv_objdir=_libs

done

rmdir .libs 2>/dev/null])

IFS="$save_ifs"

objdir=$lt_cv_objdir

])# AC_LIBTOOL_OBJDIR

if test "X$echo" = Xecho; then

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

# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])

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

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

echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&

# Check hardcoding attributes.

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

AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],

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

[AC_MSG_CHECKING([how to hardcode library paths into programs])

echo='print -r'

_LT_AC_TAGVAR(hardcode_action, $1)=

elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&

if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \

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

test -n "$_LT_AC_TAGVAR(runpath_var $1)" || \

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

test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)"="Xyes" ; then

ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}

export ORIGINAL_CONFIG_SHELL

# We can hardcode non-existant directories.

CONFIG_SHELL=/bin/ksh

if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&

export CONFIG_SHELL

# If the only mechanism to avoid hardcoding is shlibpath_var, we

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

# have to relink, otherwise we might link with an installed library

# when we should be linking with a yet-to-be-installed one

## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no &&

test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then

# Linking always hardcodes the temporary library directory.

_LT_AC_TAGVAR(hardcode_action, $1)=relink

else

# Try using printf.

# We can link without hardcoding, and we can hardcode nonexisting dirs.

echo='printf %s\n'

_LT_AC_TAGVAR(hardcode_action, $1)=immediate

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

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.

# We cannot hardcode anything, or else we can only hardcode existing

echo=echo

# directories.

_LT_AC_TAGVAR(hardcode_action, $1)=unsupported

AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])

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

if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink; then

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

# Fast installation is not supported

ECHO=$echo

enable_fast_install=no

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

elif test "$shlibpath_overrides_runpath" = yes ||

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

test "$enable_shared" = no; then

# Fast installation is not necessary

enable_fast_install=needless

])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH

AC_SUBST(ECHO)

AC_DIVERT_POP

])# _LT_AC_PROG_ECHO_BACKSLASH

# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,

# AC_LIBTOOL_SYS_LIB_STRIP

# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)

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

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

AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],

AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],

[striplib=

[if test "$cross_compiling" = yes; then :

old_striplib=

[$4]

AC_MSG_CHECKING([whether stripping libraries is possible])

if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then

test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"

test -z "$striplib" && striplib="$STRIP --strip-unneeded"

AC_MSG_RESULT([yes])

else

AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

# FIXME - insert some real tests, host_os isn't really good enough

lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2

case $host_os in

lt_status=$lt_dlunknown

darwin*)

cat > conftest.$ac_ext <<EOF

if test -n "$STRIP" ; then

[#line __oline__ "configure"

striplib="$STRIP -x"

#include "confdefs.h"

AC_MSG_RESULT([yes])

else

#if HAVE_DLFCN_H

AC_MSG_RESULT([no])

#include <dlfcn.h>

#endif

;;

#include <stdio.h>

AC_MSG_RESULT([no])

;;

esac

])# AC_LIBTOOL_SYS_LIB_STRIP

#ifdef RTLD_GLOBAL

# define LT_DLGLOBAL RTLD_GLOBAL

#else

# ifdef DL_GLOBAL

# define LT_DLGLOBAL DL_GLOBAL

# else

# define LT_DLGLOBAL 0

# endif

#endif

/* We may have to define LT_DLLAZY_OR_NOW in the command line if we

# AC_LIBTOOL_SYS_DYNAMIC_LINKER

find out it does not work in some platform. */

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

#ifndef LT_DLLAZY_OR_NOW

# PORTME Fill in your ld.so characteristics

# ifdef RTLD_LAZY

AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],

# define LT_DLLAZY_OR_NOW RTLD_LAZY

[AC_MSG_CHECKING([dynamic linker characteristics])

# else

library_names_spec=

# ifdef DL_LAZY

libname_spec='lib$name'

# define LT_DLLAZY_OR_NOW DL_LAZY

soname_spec=

# else

shrext=".so"

# ifdef RTLD_NOW

postinstall_cmds=

# define LT_DLLAZY_OR_NOW RTLD_NOW

postuninstall_cmds=

# else

finish_cmds=

# ifdef DL_NOW

finish_eval=

# define LT_DLLAZY_OR_NOW DL_NOW

shlibpath_var=

# else

shlibpath_overrides_runpath=unknown

# define LT_DLLAZY_OR_NOW 0

version_type=none

# endif

dynamic_linker="$host_os ld.so"

# endif

sys_lib_dlsearch_path_spec="/lib /usr/lib"

# endif

if test "$GCC" = yes; then

# endif

sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

#endif

if echo "$sys_lib_search_path_spec" | grep ';' >/dev/null ; then

# if the path contains ";" then we assume it to be the separator

# otherwise default to the standard path separator (i.e. ":") - it is

# assumed that no part of a normal pathname contains ";" but that should

# okay in the real world where ";" in dirpaths is itself problematic.

sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

else

sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`

else

sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

need_lib_prefix=unknown

hardcode_into_libs=no

#ifdef __cplusplus

# when you set need_version to no, make sure it does not cause -set_version

extern "C" void exit (int);

# flags to be left without arguments

#endif

need_version=unknown

void fnord() { int i=42;}

case $host_os in

int main ()

aix3*)

{

version_type=linux

void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);

library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'

int status = $lt_dlunknown;

shlibpath_var=LIBPATH

if (self)

# AIX 3 has no versioning support, so we append a major version to the name.

{

soname_spec='${libname}${release}${shared_ext}$major'

if (dlsym (self,"fnord")) status = $lt_dlno_uscore;

;;

else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;

/* dlclose (self); */

}

exit (status);

aix4* | aix5*)

}]

version_type=linux

EOF

need_lib_prefix=no

if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then

need_version=no

(./conftest; exit; ) 2>/dev/null

hardcode_into_libs=yes

lt_status=$?

if test "$host_cpu" = ia64; then

case x$lt_status in

# AIX 5 supports IA64

x$lt_dlno_uscore) $1 ;;

library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'

x$lt_dlneed_uscore) $2 ;;

shlibpath_var=LD_LIBRARY_PATH

x$lt_unknown|x*) $3 ;;

else

# With GCC up to 2.95.x, collect2 would create an import file

# for dependence libraries. The import file would start with

# the line `#! .'. This would cause the generated library to

# depend on `.', always an invalid library. This was fixed in

# development snapshots of GCC prior to 3.0.

case $host_os in

aix4 | aix4.[[01]] | aix4.[[01]].*)

if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

echo ' yes '

echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

else

can_build_shared=no

;;

esac

else :

# AIX (on Power*) has no versioning support, so currently we can not hardcode correct

# compilation failed

# soname into executable. Probably we can add versioning support to

# collect2, so additional links can be useful in future.

if test "$aix_use_runtimelinking" = yes; then

# If using run time linking (on AIX 4.2 or later) use lib<name>.so

# instead of lib<name>.a to let people know that these are not

# typical AIX shared libraries.

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

else

# We preserve .a as extension for shared libraries through AIX4.2

# and later when we are not doing run time linking.

library_names_spec='${libname}${release}.a $libname.a'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LIBPATH

rm -fr conftest*

;;

])# _LT_AC_TRY_DLOPEN_SELF

# AC_LIBTOOL_DLOPEN_SELF

amigaos*)

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

library_names_spec='$libname.ixlibrary $libname.a'

AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],

# Create ${libname}_ixlibrary.a entries in /sys/libs.

[if test "x$enable_dlopen" != xyes; then

finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/$[[^/]]*$\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'

enable_dlopen=unknown

;;

enable_dlopen_self=unknown

enable_dlopen_self_static=unknown

else

lt_cv_dlopen=no

lt_cv_dlopen_libs=

case $host_os in

beos*)

lt_cv_dlopen="load_add_on"

library_names_spec='${libname}${shared_ext}'

lt_cv_dlopen_libs=

dynamic_linker="$host_os ld.so"

lt_cv_dlopen_self=yes

shlibpath_var=LIBRARY_PATH

;;

bsdi4*)

version_type=linux

need_version=no

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

shlibpath_var=LD_LIBRARY_PATH

sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

# the default ld.so.conf also contains /usr/contrib/lib and

# /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

# libtool to hard-code these into programs

;;

cygwin* | mingw* | pw32*)

lt_cv_dlopen="LoadLibrary"

version_type=windows

lt_cv_dlopen_libs=

shrext=".dll"

need_version=no

need_lib_prefix=no

case $GCC,$host_os in

yes,cygwin* | yes,mingw* | yes,pw32*)

library_names_spec='$libname.dll.a'

# DLL is installed to $(libdir)/../bin by postinstall_cmds

postinstall_cmds='base_file=`basename \${file}`~

dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~

dldir=$destdir/`dirname \$dlpath`~

test -d \$dldir || mkdir -p \$dldir~

$install_prog $dir/$dlname \$dldir/$dlname'

postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~

dlpath=$dir/\$dldll~

$rm \$dlpath'

shlibpath_overrides_runpath=yes

case $host_os in

cygwin*)

# Cygwin DLLs use 'cyg' prefix rather than 'lib'

soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"

;;

mingw*)

# MinGW DLLs use traditional 'lib' prefix

soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'

sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`

if echo "$sys_lib_search_path_spec" | [grep ';[c-zC-Z]:/' >/dev/null]; then

# It is most probably a Windows format PATH printed by

# mingw gcc, but we are running on Cygwin. Gcc prints its search

# path with ; separators, and with drive letters. We can handle the

# drive letters (cygwin fileutils understands them), so leave them,

# especially as we might pass files found there to a mingw objdump,

# which wouldn't understand a cygwinified path. Ahh.

sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`

else

sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`

;;

pw32*)

# pw32 DLLs use 'pw' prefix rather than 'lib'

library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'

;;

esac

;;

AC_CHECK_FUNC([shl_load],

library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'

[lt_cv_dlopen="shl_load"],

[AC_CHECK_LIB([dld], [shl_load],

[lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],

[AC_CHECK_FUNC([dlopen],

[lt_cv_dlopen="dlopen"],

[AC_CHECK_LIB([dl], [dlopen],

[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],

[AC_CHECK_LIB([svld], [dlopen],

[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],

[AC_CHECK_LIB([dld], [dld_link],

[lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])

])

;;

esac

dynamic_linker='Win32 ld.exe'

# FIXME: first we should search . and the directory the executable is in

shlibpath_var=PATH

;;

if test "x$lt_cv_dlopen" != xno; then

darwin* | rhapsody*)

enable_dlopen=yes

dynamic_linker="$host_os dyld"

version_type=darwin

need_lib_prefix=no

need_version=no

library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'

soname_spec='${libname}${release}${major}$shared_ext'

shlibpath_overrides_runpath=yes

shlibpath_var=DYLD_LIBRARY_PATH

shrext='$(test .$module = .yes && echo .so || echo .dylib)'

# Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.

if test "$GCC" = yes; then

else

enable_dlopen=no

sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'

sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'

;;

case $lt_cv_dlopen in

dgux*)

dlopen)

version_type=linux

save_CPPFLAGS="$CPPFLAGS"

need_lib_prefix=no

AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl

need_version=no

test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'

soname_spec='${libname}${release}${shared_ext}$major'

save_LDFLAGS="$LDFLAGS"

shlibpath_var=LD_LIBRARY_PATH

eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"

;;

save_LIBS="$LIBS"

LIBS="$lt_cv_dlopen_libs $LIBS"

AC_CACHE_CHECK([whether a program can dlopen itself],

lt_cv_dlopen_self, [dnl

_LT_AC_TRY_DLOPEN_SELF(

lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,

lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)

])

if test "x$lt_cv_dlopen_self" = xyes; then

freebsd1*)

LDFLAGS="$LDFLAGS $link_static_flag"

dynamic_linker=no

AC_CACHE_CHECK([whether a statically linked program can dlopen itself],

;;

lt_cv_dlopen_self_static, [dnl

_LT_AC_TRY_DLOPEN_SELF(

lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,

lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross)

])

CPPFLAGS="$save_CPPFLAGS"

kfreebsd*-gnu)

LDFLAGS="$save_LDFLAGS"

version_type=linux

LIBS="$save_LIBS"

need_lib_prefix=no

need_version=no

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=no

hardcode_into_libs=yes

dynamic_linker='GNU ld.so'

;;

esac

case $lt_cv_dlopen_self in

freebsd*)

yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;

objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`

*) enable_dlopen_self=unknown ;;

version_type=freebsd-$objformat

case $version_type in

freebsd-elf*)

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'

need_version=no

need_lib_prefix=no

;;

freebsd-*)

library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'

need_version=yes

;;

esac

shlibpath_var=LD_LIBRARY_PATH

case $lt_cv_dlopen_self_static in

case $host_os in

yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;

freebsd2*)

*) enable_dlopen_self_static=unknown ;;

shlibpath_overrides_runpath=yes

;;

freebsd3.[01]* | freebsdelf3.[01]*)

shlibpath_overrides_runpath=yes

hardcode_into_libs=yes

;;

*) # from 3.2 on

shlibpath_overrides_runpath=no

hardcode_into_libs=yes

;;

esac

;;

])# AC_LIBTOOL_DLOPEN_SELF

AC_DEFUN([_LT_AC_LTCONFIG_HACK],

[AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])dnl

# Sed substitution that helps us do robust quoting. It backslashifies

# metacharacters that are still active within double-quoted strings.

Xsed='sed -e s/^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'

# Constants:

rm="rm -f"

# Global variables:

default_ofile=libtool

can_build_shared=yes

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

# which needs '.lib').

libext=a

ltmain="$ac_aux_dir/ltmain.sh"

ofile="$default_ofile"

with_gnu_ld="$lt_cv_prog_gnu_ld"

need_locks="$enable_libtool_lock"

old_CC="$CC"

old_CFLAGS="$CFLAGS"

# Set sane defaults for various variables

gnu*)

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

version_type=linux

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

need_lib_prefix=no

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

need_version=no

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

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'

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

soname_spec='${libname}${release}${shared_ext}$major'

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

shlibpath_var=LD_LIBRARY_PATH

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

hardcode_into_libs=yes

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

;;

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

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

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

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

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

if test x"$host" != x"$build"; then

hpux9* | hpux10* | hpux11*)

ac_tool_prefix=${host_alias}-

# Give a soname corresponding to the major version so that dld.sl refuses to

# link against other versions.

version_type=sunos

need_lib_prefix=no

need_version=no

case "$host_cpu" in

ia64*)

shrext='.so'

hardcode_into_libs=yes

dynamic_linker="$host_os dld.so"

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

if test "X$HPUX_IA64_MODE" = X32; then

sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"

else

ac_tool_prefix=

sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"

sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

# Transform linux* to *-*-linux-gnu*, to support old configure scripts.

;;

case $host_os in

hppa*64*)

linux-gnu*) ;;

shrext='.sl'

linux*) host=`echo $host | sed 's/^$.*-.*-linux$$.*$$/\1-gnu\2/'`

hardcode_into_libs=yes

dynamic_linker="$host_os dld.sl"

shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH

shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"

sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec

;;

shrext='.sl'

dynamic_linker="$host_os dld.sl"

shlibpath_var=SHLIB_PATH

shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

;;

esac

# HP-UX runs *really* slowly unless shared libraries are mode 555.

postinstall_cmds='chmod 555 $lib'

;;

irix5* | irix6* | nonstopux*)

case $host_os in

aix3*)

nonstopux*) version_type=nonstopux ;;

# AIX sometimes has problems with the GCC collect2 program. For some

# reason, if we set the COLLECT_NAMES environment variable, the problems

if test "$lt_cv_prog_gnu_ld" = yes; then

# vanish in a puff of smoke.

version_type=linux

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

else

COLLECT_NAMES=

version_type=irix

export COLLECT_NAMES

fi ;;

;;

esac

need_lib_prefix=no

# Determine commands to create old-style static archives.

need_version=no

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

soname_spec='${libname}${release}${shared_ext}$major'

old_postinstall_cmds='chmod 644 $oldlib'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'

old_postuninstall_cmds=

if test -n "$RANLIB"; then

case $host_os in

openbsd*)

irix5* | nonstopux*)

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

libsuff= shlibsuff=

;;

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

case $LD in # libtool.m4 will add one of these switches to LD

*-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")

libsuff= shlibsuff= libmagic=32-bit;;

*-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")

libsuff=32 shlibsuff=N32 libmagic=N32;;

*-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")

libsuff=64 shlibsuff=64 libmagic=64-bit;;

*) libsuff= shlibsuff= libmagic=never-match;;

esac

;;

esac

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

shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

shlibpath_overrides_runpath=no

sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

hardcode_into_libs=yes

;;

# Allow CC to be a program name with arguments.

# No shared lib support for Linux oldld, aout, or coff.

set dummy $CC

linux*oldld* | linux*aout* | linux*coff*)

compiler="[$]2"

dynamic_linker=no

;;

AC_MSG_CHECKING([for objdir])

# This must be Linux ELF.

rm -f .libs 2>/dev/null

linux*)

mkdir .libs 2>/dev/null

version_type=linux

if test -d .libs; then

need_lib_prefix=no

objdir=.libs

need_version=no

else

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

# MS-DOS does not allow filenames that begin with a dot.

soname_spec='${libname}${release}${shared_ext}$major'

objdir=_libs

finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=no

# This implies no fast_install, which is unacceptable.

# Some rework will be needed to allow for fast_install

# before this can be enabled.

hardcode_into_libs=yes

# Append ld.so.conf contents to the search path

if test -f /etc/ld.so.conf; then

ld_extra=`$SED -e 's/[:,\t]/ /g;s/=[^=]*$//;s/=[^= ]* / /g' /etc/ld.so.conf`

sys_lib_dlsearch_path_spec="/lib /usr/lib $ld_extra"

rmdir .libs 2>/dev/null

AC_MSG_RESULT($objdir)

# We used to test for /lib/ld.so.1 and disable shared libraries on

# powerpc, because MkLinux only supported shared libraries with the

# GNU dynamic linker. Since this was broken with cross compilers,

# most powerpc-linux boxes support dynamic linking these days and

# people can always --disable-shared, the test was removed, and we

# assume the GNU/Linux dynamic linker is in use.

dynamic_linker='GNU/Linux ld.so'

;;

AC_ARG_WITH(pic,

knetbsd*-gnu)

[ --with-pic try to use only PIC/non-PIC objects [default=use both]],

version_type=linux

pic_mode="$withval", pic_mode=default)

need_lib_prefix=no

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

need_version=no

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=no

hardcode_into_libs=yes

dynamic_linker='GNU ld.so'

;;

# We assume here that the value for lt_cv_prog_cc_pic will not be cached

netbsd*)

# in isolation, and that seeing it set (from the cache) indicates that

version_type=sunos

# the associated values are set (in the cache) correctly too.

need_lib_prefix=no

AC_MSG_CHECKING([for $compiler option to produce PIC])

need_version=no

AC_CACHE_VAL(lt_cv_prog_cc_pic,

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

[ lt_cv_prog_cc_pic=

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

lt_cv_prog_cc_shlib=

finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

lt_cv_prog_cc_wl=

dynamic_linker='NetBSD (a.out) ld.so'

lt_cv_prog_cc_static=

else

lt_cv_prog_cc_no_builtin=

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} ${libname}${shared_ext}'

lt_cv_prog_cc_can_build_shared=$can_build_shared

soname_spec='${libname}${release}${shared_ext}$major'

dynamic_linker='NetBSD ld.elf_so'

if test "$GCC" = yes; then

lt_cv_prog_cc_wl='-Wl,'

shlibpath_var=LD_LIBRARY_PATH

lt_cv_prog_cc_static='-static'

shlibpath_overrides_runpath=yes

hardcode_into_libs=yes

case $host_os in

aix*)

# Below there is a dirty hack to force normal static linking with -ldl

# The problem is because libdl dynamically linked with both libc and

# libC (AIX C++ library), which obviously doesn't included in libraries

# list by gcc. This cause undefined symbols with -static flags.

# This hack allows C programs to be linked with "-static -ldl", but

# not sure about C++ programs.

lt_cv_prog_cc_static="$lt_cv_prog_cc_static ${lt_cv_prog_cc_wl}-lC"

;;

amigaos*)

# FIXME: we need at least 68020 code to build shared libraries, but

# adding the `-m68020' flag to GCC prevents building anything better,

# like `-m68040'.

lt_cv_prog_cc_pic='-m68020 -resident32 -malways-restore-a4'

;;

beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)

# PIC is the default for these OSes.

;;

darwin* | rhapsody*)

# PIC is the default on this platform

newsos6)

# Common symbols not allowed in MH_DYLIB files

version_type=linux

lt_cv_prog_cc_pic='-fno-common'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

;;

cygwin* | mingw* | pw32* | os2*)

# This hack is so that the source file can tell whether it is being

nto-qnx*)

# built for inclusion in a dll (and should export symbols for example).

version_type=linux

lt_cv_prog_cc_pic='-DDLL_EXPORT'

need_lib_prefix=no

need_version=no

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

;;

sysv4*MP*)

if test -d /usr/nec; then

openbsd*)

lt_cv_prog_cc_pic=-Kconform_pic

version_type=sunos

need_lib_prefix=no

need_version=yes

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'

shlibpath_var=LD_LIBRARY_PATH

if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

case $host_os in

openbsd2.[[89]] | openbsd2.[[89]].*)

shlibpath_overrides_runpath=no

;;

lt_cv_prog_cc_pic='-fPIC'

shlibpath_overrides_runpath=yes

;;

esac

else

# PORTME Check for PIC flags for the system compiler.

shlibpath_overrides_runpath=yes

case $host_os in

aix3* | aix4* | aix5*)

lt_cv_prog_cc_wl='-Wl,'

# All AIX code is PIC.

if test "$host_cpu" = ia64; then

# AIX 5 now supports IA64 processor

lt_cv_prog_cc_static='-Bstatic'

else

lt_cv_prog_cc_static='-bnso -bI:/lib/syscalls.exp'

;;

hpux9* | hpux10* | hpux11*)

os2*)

# Is there a better lt_cv_prog_cc_static that works with the bundled CC?

libname_spec='$name'

lt_cv_prog_cc_wl='-Wl,'

shrext=".dll"

lt_cv_prog_cc_static="${lt_cv_prog_cc_wl}-a ${lt_cv_prog_cc_wl}archive"

need_lib_prefix=no

lt_cv_prog_cc_pic='+Z'

library_names_spec='$libname${shared_ext} $libname.a'

;;

dynamic_linker='OS/2 ld.exe'

shlibpath_var=LIBPATH

irix5* | irix6* | nonstopux*)

lt_cv_prog_cc_wl='-Wl,'

lt_cv_prog_cc_static='-non_shared'

# PIC (with -KPIC) is the default.

;;

cygwin* | mingw* | pw32* | os2*)

# This hack is so that the source file can tell whether it is being

# built for inclusion in a dll (and should export symbols for example).

lt_cv_prog_cc_pic='-DDLL_EXPORT'

;;

newsos6)

lt_cv_prog_cc_pic='-KPIC'

lt_cv_prog_cc_static='-Bstatic'

;;

osf3* | osf4* | osf5*)

# All OSF/1 code is PIC.

version_type=osf

lt_cv_prog_cc_wl='-Wl,'

need_lib_prefix=no

lt_cv_prog_cc_static='-non_shared'

need_version=no

soname_spec='${libname}${release}${shared_ext}$major'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

shlibpath_var=LD_LIBRARY_PATH

sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"

sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"

;;

sco3.2v5*)

lt_cv_prog_cc_pic='-Kpic'

version_type=osf

lt_cv_prog_cc_static='-dn'

soname_spec='${libname}${release}${shared_ext}$major'

lt_cv_prog_cc_shlib='-belf'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

shlibpath_var=LD_LIBRARY_PATH

;;

solaris*)

lt_cv_prog_cc_pic='-KPIC'

version_type=linux

lt_cv_prog_cc_static='-Bstatic'

need_lib_prefix=no

lt_cv_prog_cc_wl='-Wl,'

need_version=no

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

hardcode_into_libs=yes

# ldd complains unless libraries are executable

postinstall_cmds='chmod +x $lib'

;;

sunos4*)

lt_cv_prog_cc_pic='-PIC'

version_type=sunos

lt_cv_prog_cc_static='-Bstatic'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'

lt_cv_prog_cc_wl='-Qoption ld '

finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'

shlibpath_var=LD_LIBRARY_PATH

shlibpath_overrides_runpath=yes

if test "$with_gnu_ld" = yes; then

need_lib_prefix=no

need_version=yes

;;

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

lt_cv_prog_cc_pic='-KPIC'

version_type=linux

lt_cv_prog_cc_static='-Bstatic'

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

lt_cv_prog_cc_wl='-Wl,'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LD_LIBRARY_PATH

case $host_vendor in

sni)

shlibpath_overrides_runpath=no

need_lib_prefix=no

export_dynamic_flag_spec='${wl}-Blargedynsym'

runpath_var=LD_RUN_PATH

;;

siemens)

uts4*)

need_lib_prefix=no

lt_cv_prog_cc_pic='-pic'

;;

lt_cv_prog_cc_static='-Bstatic'

motorola)

need_lib_prefix=no

need_version=no

shlibpath_overrides_runpath=no

sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'

;;

esac

;;

sysv4*MP*)

if test -d /usr/nec ;then

lt_cv_prog_cc_pic='-Kconform_pic'

version_type=linux

lt_cv_prog_cc_static='-Bstatic'

library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'

soname_spec='$libname${shared_ext}.$major'

shlibpath_var=LD_LIBRARY_PATH

;;

uts4*)

lt_cv_prog_cc_can_build_shared=no

version_type=linux

library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'

soname_spec='${libname}${release}${shared_ext}$major'

shlibpath_var=LD_LIBRARY_PATH

;;

esac

])

if test -z "$lt_cv_prog_cc_pic"; then

AC_MSG_RESULT([none])

else

AC_MSG_RESULT([$lt_cv_prog_cc_pic])

# Check to make sure the pic_flag actually works.

AC_MSG_CHECKING([if $compiler PIC flag $lt_cv_prog_cc_pic works])

AC_CACHE_VAL(lt_cv_prog_cc_pic_works, [dnl

save_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS $lt_cv_prog_cc_pic -DPIC"

AC_TRY_COMPILE([], [], [dnl

case $host_os in

hpux9* | hpux10* | hpux11*)

# On HP-UX, both CC and GCC only warn that PIC is supported... then

# they create non-PIC objects. So, if there were any warnings, we

# assume that PIC is not supported.

if test -s conftest.err; then

lt_cv_prog_cc_pic_works=no

else

lt_cv_prog_cc_pic_works=yes

;;

lt_cv_prog_cc_pic_works=yes

dynamic_linker=no

;;

esac

], [dnl

AC_MSG_RESULT([$dynamic_linker])

lt_cv_prog_cc_pic_works=no

test "$dynamic_linker" = no && can_build_shared=no

])

])# AC_LIBTOOL_SYS_DYNAMIC_LINKER

CFLAGS="$save_CFLAGS"

])

if test "X$lt_cv_prog_cc_pic_works" = Xno; then

lt_cv_prog_cc_pic=

lt_cv_prog_cc_can_build_shared=no

else

lt_cv_prog_cc_pic=" $lt_cv_prog_cc_pic"

AC_MSG_RESULT([$lt_cv_prog_cc_pic_works])

# _LT_AC_TAGCONFIG

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

AC_DEFUN([_LT_AC_TAGCONFIG],

[AC_ARG_WITH([tags],

[AC_HELP_STRING([--with-tags@<:@=TAGS@:>@],

[include additional configurations @<:@automatic@:>@])],

[tagnames="$withval"])

if test -f "$ltmain" && test -n "$tagnames"; then

if test ! -f "${ofile}"; then

AC_MSG_WARN([output file `$ofile' does not exist])

# Check for any special shared library compilation flags.

if test -z "$LTCC"; then

if test -n "$lt_cv_prog_cc_shlib"; then

eval "`$SHELL ${ofile} --config | grep '^LTCC='`"

AC_MSG_WARN([\`$CC' requires \`$lt_cv_prog_cc_shlib' to build shared libraries])

if test -z "$LTCC"; then

if echo "$old_CC $old_CFLAGS " | egrep -e "[[ ]]$lt_cv_prog_cc_shlib[[ ]]" >/dev/null; then :

AC_MSG_WARN([output file `$ofile' does not look like a libtool script])

else

AC_MSG_WARN([add \`$lt_cv_prog_cc_shlib' to the CC or CFLAGS env variable and reconfigure])

AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile'])

lt_cv_prog_cc_can_build_shared=no

AC_MSG_CHECKING([if $compiler static flag $lt_cv_prog_cc_static works])

# Extract list of available tagged configurations in $ofile.

AC_CACHE_VAL([lt_cv_prog_cc_static_works], [dnl

# Note that this assumes the entire list is on one line.

lt_cv_prog_cc_static_works=no

available_tags=`grep "^available_tags=" "${ofile}" | $SED -e 's/available_tags=$.*$$/\1/' -e 's/\"//g'`

save_LDFLAGS="$LDFLAGS"

LDFLAGS="$LDFLAGS $lt_cv_prog_cc_static"

AC_TRY_LINK([], [], [lt_cv_prog_cc_static_works=yes])

LDFLAGS="$save_LDFLAGS"

])

# Belt *and* braces to stop my trousers falling down:

test "X$lt_cv_prog_cc_static_works" = Xno && lt_cv_prog_cc_static=

AC_MSG_RESULT([$lt_cv_prog_cc_static_works])

pic_flag="$lt_cv_prog_cc_pic"

special_shlib_compile_flags="$lt_cv_prog_cc_shlib"

wl="$lt_cv_prog_cc_wl"

link_static_flag="$lt_cv_prog_cc_static"

no_builtin_flag="$lt_cv_prog_cc_no_builtin"

can_build_shared="$lt_cv_prog_cc_can_build_shared"

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

for tagname in $tagnames; do

IFS="$lt_save_ifs"

# Check whether tagname contains only valid characters

case `$echo "X$tagname" | $Xsed -e 's:[[-_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,/]]::g'` in

"") ;;

*) AC_MSG_ERROR([invalid tag name: $tagname])

;;

esac

# Check to see if options -o and -c are simultaneously supported by compiler

if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "${ofile}" > /dev/null

AC_MSG_CHECKING([if $compiler supports -c -o file.$ac_objext])

then

AC_CACHE_VAL([lt_cv_compiler_c_o], [

AC_MSG_ERROR([tag name \"$tagname\" already exists])

$rm -r conftest 2>/dev/null

mkdir conftest

cd conftest

echo "int some_variable = 0;" > conftest.$ac_ext

mkdir out

# According to Tom Tromey, Ian Lance Taylor reported there are C compilers

# that will create temporary files in the current directory regardless of

# the output directory. Thus, making CWD read-only will cause this test

# to fail, enabling locking or at least warning the user not to do parallel

# builds.

chmod -w .

save_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS -o out/conftest2.$ac_objext"

compiler_c_o=no

if { (eval echo configure:__oline__: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then

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

# So say no if there are warnings

if test -s out/conftest.err; then

lt_cv_compiler_c_o=no

else

lt_cv_compiler_c_o=yes

else

# Append any errors to the config.log.

cat out/conftest.err 1>&AC_FD_CC

lt_cv_compiler_c_o=no

CFLAGS="$save_CFLAGS"

chmod u+w .

$rm conftest* out/*

rmdir out

cd ..

rmdir conftest

$rm -r conftest 2>/dev/null

])

compiler_c_o=$lt_cv_compiler_c_o

AC_MSG_RESULT([$compiler_c_o])

if test x"$compiler_c_o" = x"yes"; then

# Update the list of available tags.

# Check to see if we can write to a .lo

if test -n "$tagname"; then

AC_MSG_CHECKING([if $compiler supports -c -o file.lo])

echo appending configuration tag \"$tagname\" to $ofile

AC_CACHE_VAL([lt_cv_compiler_o_lo], [

lt_cv_compiler_o_lo=no

case $tagname in

save_CFLAGS="$CFLAGS"

CXX)

CFLAGS="$CFLAGS -c -o conftest.lo"

if test -n "$CXX" && test "X$CXX" != "Xno"; then

save_objext="$ac_objext"

AC_LIBTOOL_LANG_CXX_CONFIG

ac_objext=lo

AC_TRY_COMPILE([], [int some_variable = 0;], [dnl

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

# So say no if there are warnings

if test -s conftest.err; then

lt_cv_compiler_o_lo=no

else

lt_cv_compiler_o_lo=yes

tagname=""

])

;;

ac_objext="$save_objext"

CFLAGS="$save_CFLAGS"

F77)

])

if test -n "$F77" && test "X$F77" != "Xno"; then

compiler_o_lo=$lt_cv_compiler_o_lo

AC_LIBTOOL_LANG_F77_CONFIG

AC_MSG_RESULT([$compiler_o_lo])

else

compiler_o_lo=no

tagname=""

;;

# Check to see if we can do hard links to lock some files if needed

GCJ)

hard_links="nottested"

if test -n "$GCJ" && test "X$GCJ" != "Xno"; then

if test "$compiler_c_o" = no && test "$need_locks" != no; then

AC_LIBTOOL_LANG_GCJ_CONFIG

# do not overwrite the value of need_locks provided by the user

AC_MSG_CHECKING([if we can lock with hard links])

hard_links=yes

$rm conftest*

ln conftest.a conftest.b 2>/dev/null && hard_links=no

touch conftest.a

ln conftest.a conftest.b 2>&5 || hard_links=no

ln conftest.a conftest.b 2>/dev/null && hard_links=no

AC_MSG_RESULT([$hard_links])

if test "$hard_links" = no; then

AC_MSG_WARN([\`$CC' does not support \`-c -o', so \`make -j' may be unsafe])

need_locks=warn

else

need_locks=no

tagname=""

;;

if test "$GCC" = yes; then

RC)

# Check to see if options -fno-rtti -fno-exceptions are supported by compiler

AC_LIBTOOL_LANG_RC_CONFIG

AC_MSG_CHECKING([if $compiler supports -fno-rtti -fno-exceptions])

;;

echo "int some_variable = 0;" > conftest.$ac_ext

save_CFLAGS="$CFLAGS"

CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -c conftest.$ac_ext"

AC_MSG_ERROR([Unsupported tag name: $tagname])

compiler_rtti_exceptions=no

;;

AC_TRY_COMPILE([], [int some_variable = 0;], [dnl

esac

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

# So say no if there are warnings

# Append the new tag name to the list of available tags.

if test -s conftest.err; then

if test -n "$tagname" ; then

compiler_rtti_exceptions=no

available_tags="$available_tags $tagname"

else

compiler_rtti_exceptions=yes

])

CFLAGS="$save_CFLAGS"

done

AC_MSG_RESULT([$compiler_rtti_exceptions])

IFS="$lt_save_ifs"

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

# Now substitute the updated list of available tags.

no_builtin_flag=' -fno-builtin -fno-rtti -fno-exceptions'

if eval "sed -e 's/^available_tags=.*\$/available_tags=\"$available_tags\"/' \"$ofile\" > \"${ofile}T\""; then

mv "${ofile}T" "$ofile"

chmod +x "$ofile"

else

no_builtin_flag=' -fno-builtin'

rm -f "${ofile}T"

AC_MSG_ERROR([unable to update list of available tagged configurations.])

])# _LT_AC_TAGCONFIG

# See if the linker supports building shared libraries.

AC_MSG_CHECKING([whether the linker ($LD) supports shared libraries])

allow_undefined_flag=

# AC_LIBTOOL_DLOPEN

no_undefined_flag=

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

need_lib_prefix=unknown

# enable checks for dlopen support

need_version=unknown

AC_DEFUN([AC_LIBTOOL_DLOPEN],

# when you set need_version to no, make sure it does not cause -set_version

[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])

# flags to be left without arguments

])# AC_LIBTOOL_DLOPEN

archive_cmds=

archive_expsym_cmds=

old_archive_from_new_cmds=

old_archive_from_expsyms_cmds=

export_dynamic_flag_spec=

whole_archive_flag_spec=

thread_safe_flag_spec=

hardcode_into_libs=no

hardcode_libdir_flag_spec=

hardcode_libdir_separator=

hardcode_direct=no

hardcode_minus_L=no

hardcode_shlibpath_var=unsupported

runpath_var=

link_all_deplibs=unknown

always_export_symbols=no

export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | sed '\''s/.* //'\'' | sort | uniq > $export_symbols'

# include_expsyms should be a list of space-separated symbols to be *always*

# included in the symbol list

include_expsyms=

# exclude_expsyms can be an egrep regular expression of symbols to exclude

# it will be wrapped by ` (' and `)$', so one must not match beginning or

# end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',

# as well as any symbol that contains `d'.

exclude_expsyms="_GLOBAL_OFFSET_TABLE_"

# Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out

# platforms (ab)use it in PIC code, but their linkers get confused if

# the symbol is explicitly referenced. Since portable code cannot

# rely on this symbol name, it's probably fine to never include it in

# preloaded symbol tables.

extract_expsyms_cmds=

case $host_os in

cygwin* | mingw* | pw32*)

# FIXME: the MSVC++ port hasn't been tested in a loooong time

# When not using gcc, we currently assume that we are using

# Microsoft Visual C++.

if test "$GCC" != yes; then

with_gnu_ld=no

;;

openbsd*)

with_gnu_ld=no

;;

esac

ld_shlibs=yes

# AC_LIBTOOL_WIN32_DLL

if test "$with_gnu_ld" = yes; then

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

# If archive_cmds runs LD, not CC, wlarc should be empty

# declare package support for building win32 dll's

wlarc='${wl}'

AC_DEFUN([AC_LIBTOOL_WIN32_DLL],

[AC_BEFORE([$0], [AC_LIBTOOL_SETUP])

])# AC_LIBTOOL_WIN32_DLL

# See if GNU ld supports shared libraries.

case $host_os in

aix3* | aix4* | aix5*)

# On AIX, the GNU linker is very broken

# Note:Check GNU linker on AIX 5-IA64 when/if it becomes available.

ld_shlibs=no

cat <<EOF 1>&2

*** Warning: the GNU linker, at least up to release 2.9.1, is reported

*** to be unable to reliably create shared libraries on AIX.

*** Therefore, libtool is disabling shared libraries support. If you

*** really care for shared libraries, you may want to modify your PATH

*** so that a non-GNU linker is found, and then restart.

EOF

# AC_ENABLE_SHARED([DEFAULT])

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

# implement the --enable-shared flag

# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.

AC_DEFUN([AC_ENABLE_SHARED],

[define([AC_ENABLE_SHARED_DEFAULT], ifelse($1, no, no, yes))dnl

AC_ARG_ENABLE([shared],

[AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],

[build shared libraries @<:@default=]AC_ENABLE_SHARED_DEFAULT[@:>@])],

[p=${PACKAGE-default}

case $enableval in

yes) enable_shared=yes ;;

no) enable_shared=no ;;

enable_shared=no

# Look at the argument we got. We use all the common list separators.

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

for pkg in $enableval; do

IFS="$lt_save_ifs"

if test "X$pkg" = "X$p"; then

enable_shared=yes

done

IFS="$lt_save_ifs"

;;

esac],

[enable_shared=]AC_ENABLE_SHARED_DEFAULT)

])# AC_ENABLE_SHARED

amigaos*)

archive_cmds='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'

hardcode_libdir_flag_spec='-L$libdir'

hardcode_minus_L=yes

# Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports

# AC_DISABLE_SHARED

# that the semantics of dynamic libraries on AmigaOS, at least up

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

# to version 4, is to share data among multiple programs linked

#- set the default shared flag to --disable-shared

# with the same dynamic library. Since this doesn't match the

AC_DEFUN([AC_DISABLE_SHARED],

# behavior of shared libraries on other platforms, we can use

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

# them.

AC_ENABLE_SHARED(no)

ld_shlibs=no

])# AC_DISABLE_SHARED

;;

beos*)

if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

# AC_ENABLE_STATIC([DEFAULT])

allow_undefined_flag=unsupported

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

# Joseph Beckenbach <jrb3@best.com> says some releases of gcc

# implement the --enable-static flag

# support --undefined. This deserves some investigation. FIXME

# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.

archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

AC_DEFUN([AC_ENABLE_STATIC],

else

[define([AC_ENABLE_STATIC_DEFAULT], ifelse($1, no, no, yes))dnl

ld_shlibs=no

AC_ARG_ENABLE([static],

[AC_HELP_STRING([--enable-static@<:@=PKGS@:>@],

[build static libraries @<:@default=]AC_ENABLE_STATIC_DEFAULT[@:>@])],

[p=${PACKAGE-default}

case $enableval in

yes) enable_static=yes ;;

no) enable_static=no ;;

enable_static=no

# Look at the argument we got. We use all the common list separators.

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

for pkg in $enableval; do

IFS="$lt_save_ifs"

if test "X$pkg" = "X$p"; then

enable_static=yes

done

IFS="$lt_save_ifs"

;;

esac],

[enable_static=]AC_ENABLE_STATIC_DEFAULT)

])# AC_ENABLE_STATIC

cygwin* | mingw* | pw32*)

# hardcode_libdir_flag_spec is actually meaningless, as there is

# no search path for DLLs.

hardcode_libdir_flag_spec='-L$libdir'

allow_undefined_flag=unsupported

always_export_symbols=yes

extract_expsyms_cmds='test -f $output_objdir/impgen.c || \

sed -e "/^# \/\* impgen\.c starts here \*\//,/^# \/\* impgen.c ends here \*\// { s/^# //;s/^# *$//; p; }" -e d < $''0 > $output_objdir/impgen.c~

test -f $output_objdir/impgen.exe || (cd $output_objdir && \

if test "x$HOST_CC" != "x" ; then $HOST_CC -o impgen impgen.c ; \

else $CC -o impgen impgen.c ; fi)~

$output_objdir/impgen $dir/$soroot > $output_objdir/$soname-def'

old_archive_from_expsyms_cmds='$DLLTOOL --as=$AS --dllname $soname --def $output_objdir/$soname-def --output-lib $output_objdir/$newlib'

# cygwin and mingw dlls have different entry points and sets of symbols

# to exclude.

# FIXME: what about values for MSVC?

dll_entry=__cygwin_dll_entry@12

dll_exclude_symbols=DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12~

case $host_os in

mingw*)

# mingw values

dll_entry=_DllMainCRTStartup@12

dll_exclude_symbols=DllMain@12,DllMainCRTStartup@12,DllEntryPoint@12~

;;

esac

# mingw and cygwin differ, and it's simplest to just exclude the union

# AC_DISABLE_STATIC

# of the two symbol sets.

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

dll_exclude_symbols=DllMain@12,_cygwin_dll_entry@12,_cygwin_noncygwin_dll_entry@12,DllMainCRTStartup@12,DllEntryPoint@12

# set the default static flag to --disable-static

AC_DEFUN([AC_DISABLE_STATIC],

# recent cygwin and mingw systems supply a stub DllMain which the user

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

# can override, but on older systems we have to supply one (in ltdll.c)

AC_ENABLE_STATIC(no)

if test "x$lt_cv_need_dllmain" = "xyes"; then

])# AC_DISABLE_STATIC

ltdll_obj='$output_objdir/$soname-ltdll.'"$ac_objext "

ltdll_cmds='test -f $output_objdir/$soname-ltdll.c || sed -e "/^# \/\* ltdll\.c starts here \*\//,/^# \/\* ltdll.c ends here \*\// { s/^# //; p; }" -e d < $''0 > $output_objdir/$soname-ltdll.c~

test -f $output_objdir/$soname-ltdll.$ac_objext || (cd $output_objdir && $CC -c $soname-ltdll.c)~'

else

ltdll_obj=

ltdll_cmds=

# Extract the symbol export list from an `--export-all' def file,

# then regenerate the def file from the symbol export list, so that

# the compiled dll only exports the symbol export list.

# Be careful not to strip the DATA tag left be newer dlltools.

export_symbols_cmds="$ltdll_cmds"'

$DLLTOOL --export-all --exclude-symbols '$dll_exclude_symbols' --output-def $output_objdir/$soname-def '$ltdll_obj'$libobjs $convenience~

sed -e "1,/EXPORTS/d" -e "s/ @ [[0-9]]*//" -e "s/ *;.*$//" < $output_objdir/$soname-def > $export_symbols'

# If the export-symbols file already is a .def file (1st line

# is EXPORTS), use it as is.

# If DATA tags from a recent dlltool are present, honour them!

archive_expsym_cmds='if test "x`sed 1q $export_symbols`" = xEXPORTS; then

cp $export_symbols $output_objdir/$soname-def;

else

echo EXPORTS > $output_objdir/$soname-def;

_lt_hint=1;

cat $export_symbols | while read symbol; do

set dummy \$symbol;

case \[$]# in

2) echo " \[$]2 @ \$_lt_hint ; " >> $output_objdir/$soname-def;;

4) echo " \[$]2 \[$]3 \[$]4 ; " >> $output_objdir/$soname-def; _lt_hint=`expr \$_lt_hint - 1`;;

*) echo " \[$]2 @ \$_lt_hint \[$]3 ; " >> $output_objdir/$soname-def;;

esac;

_lt_hint=`expr 1 + \$_lt_hint`;

done;

fi~

'"$ltdll_cmds"'

$CC -Wl,--base-file,$output_objdir/$soname-base '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~

$DLLTOOL --as=$AS --dllname $soname --exclude-symbols '$dll_exclude_symbols' --def $output_objdir/$soname-def --base-file $output_objdir/$soname-base --output-exp $output_objdir/$soname-exp~

$CC -Wl,--base-file,$output_objdir/$soname-base $output_objdir/$soname-exp '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags~

$DLLTOOL --as=$AS --dllname $soname --exclude-symbols '$dll_exclude_symbols' --def $output_objdir/$soname-def --base-file $output_objdir/$soname-base --output-exp $output_objdir/$soname-exp --output-lib $output_objdir/$libname.dll.a~

$CC $output_objdir/$soname-exp '$lt_cv_cc_dll_switch' -Wl,-e,'$dll_entry' -o $output_objdir/$soname '$ltdll_obj'$libobjs $deplibs $compiler_flags'

;;

netbsd*)

# AC_ENABLE_FAST_INSTALL([DEFAULT])

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

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

archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'

# implement the --enable-fast-install flag

wlarc=

# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.

else

AC_DEFUN([AC_ENABLE_FAST_INSTALL],

archive_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

[define([AC_ENABLE_FAST_INSTALL_DEFAULT], ifelse($1, no, no, yes))dnl

archive_expsym_cmds='$CC -shared -nodefaultlibs $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

AC_ARG_ENABLE([fast-install],

[AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],

[optimize for fast installation @<:@default=]AC_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],

[p=${PACKAGE-default}

case $enableval in

yes) enable_fast_install=yes ;;

no) enable_fast_install=no ;;

enable_fast_install=no

# Look at the argument we got. We use all the common list separators.

lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"

for pkg in $enableval; do

IFS="$lt_save_ifs"

if test "X$pkg" = "X$p"; then

enable_fast_install=yes

done

IFS="$lt_save_ifs"

;;

esac],

[enable_fast_install=]AC_ENABLE_FAST_INSTALL_DEFAULT)

])# AC_ENABLE_FAST_INSTALL

solaris* | sysv5*)

if $LD -v 2>&1 | egrep 'BFD 2\.8' > /dev/null; then

# AC_DISABLE_FAST_INSTALL

ld_shlibs=no

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

# set the default to --disable-fast-install

AC_DEFUN([AC_DISABLE_FAST_INSTALL],

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

AC_ENABLE_FAST_INSTALL(no)

])# AC_DISABLE_FAST_INSTALL

# AC_LIBTOOL_PICMODE([MODE])

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

# implement the --with-pic flag

# MODE is either `yes' or `no'. If omitted, it defaults to `both'.

AC_DEFUN([AC_LIBTOOL_PICMODE],

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

pic_mode=ifelse($#,1,$1,default)

])# AC_LIBTOOL_PICMODE

# AC_PROG_EGREP

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

# This is predefined starting with Autoconf 2.54, so this conditional

# definition can be removed once we require Autoconf 2.54 or later.

m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP],

[AC_CACHE_CHECK([for egrep], [ac_cv_prog_egrep],

[if echo a | (grep -E '(a|b)') >/dev/null 2>&1

then ac_cv_prog_egrep='grep -E'

else ac_cv_prog_egrep='egrep'

fi])

EGREP=$ac_cv_prog_egrep

AC_SUBST([EGREP])

])])

# AC_PATH_TOOL_PREFIX

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

# find a file program which can recognise shared library

AC_DEFUN([AC_PATH_TOOL_PREFIX],

[AC_REQUIRE([AC_PROG_EGREP])dnl

AC_MSG_CHECKING([for $1])

AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,

[case $MAGIC_CMD in

[[\\/*] | ?:[\\/]*])

lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.

;;

lt_save_MAGIC_CMD="$MAGIC_CMD"

lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

dnl $ac_dummy forces splitting on constant user-supplied paths.

dnl POSIX.2 word splitting is done only on the output of word expansions,

dnl not every word. This closes a longstanding sh security hole.

ac_dummy="ifelse([$2], , $PATH, [$2])"

for ac_dir in $ac_dummy; do

IFS="$lt_save_ifs"

test -z "$ac_dir" && ac_dir=.

if test -f $ac_dir/$1; then

lt_cv_path_MAGIC_CMD="$ac_dir/$1"

if test -n "$file_magic_test_file"; then

case $deplibs_check_method in

"file_magic "*)

file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic $.*$\"`"

MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |

$EGREP "$file_magic_regex" > /dev/null; then

else

cat <<EOF 1>&2

*** Warning: The releases 2.8.* of the GNU linker cannot reliably

*** Warning: the command libtool uses to detect shared libraries,

*** create shared libraries on Solaris systems. Therefore, libtool

*** $file_magic_cmd, produces output that libtool cannot recognize.

*** is disabling shared libraries support. We urge you to upgrade GNU

*** The result is that libtool may fail to recognize shared libraries

*** binutils to release 2.9.1 or newer. Another option is to modify

*** as such. This will affect the creation of libtool libraries that

*** your PATH or compiler configuration so that the native linker is

*** depend on shared libraries, but programs linked with such libtool

*** used, and then restart.

*** libraries will work regardless of this problem. Nevertheless, you

*** may want to report the problem to your system manager and/or to

*** bug-libtool@gnu.org

EOF

elif $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

fi ;;

archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

esac

archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

else

ld_shlibs=no

break

done

IFS="$lt_save_ifs"

MAGIC_CMD="$lt_save_MAGIC_CMD"

;;

esac])

MAGIC_CMD="$lt_cv_path_MAGIC_CMD"

if test -n "$MAGIC_CMD"; then

AC_MSG_RESULT($MAGIC_CMD)

else

AC_MSG_RESULT(no)

])# AC_PATH_TOOL_PREFIX

sunos4*)

archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'

wlarc=

hardcode_direct=yes

hardcode_shlibpath_var=no

;;

# AC_PATH_MAGIC

if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then

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

archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'

# find a file program which can recognise a shared library

archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

AC_DEFUN([AC_PATH_MAGIC],

[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)

if test -z "$lt_cv_path_MAGIC_CMD"; then

if test -n "$ac_tool_prefix"; then

AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)

else

ld_shlibs=no

MAGIC_CMD=:

;;

esac

])# AC_PATH_MAGIC

if test "$ld_shlibs" = yes; then

runpath_var=LD_RUN_PATH

# AC_PROG_LD

hardcode_libdir_flag_spec='${wl}--rpath ${wl}$libdir'

# ----------

export_dynamic_flag_spec='${wl}--export-dynamic'

# find the pathname to the GNU or non-GNU linker

case $host_os in

AC_DEFUN([AC_PROG_LD],

cygwin* | mingw* | pw32*)

[AC_ARG_WITH([gnu-ld],

# dlltool doesn't understand --whole-archive et. al.

[AC_HELP_STRING([--with-gnu-ld],

whole_archive_flag_spec=

[assume the C compiler uses GNU ld @<:@default=no@:>@])],

[test "$withval" = no || with_gnu_ld=yes],

[with_gnu_ld=no])

AC_REQUIRE([LT_AC_PROG_SED])dnl

AC_REQUIRE([AC_PROG_CC])dnl

AC_REQUIRE([AC_CANONICAL_HOST])dnl

AC_REQUIRE([AC_CANONICAL_BUILD])dnl

ac_prog=ld

if test "$GCC" = yes; then

# Check if gcc -print-prog-name=ld gives a path.

AC_MSG_CHECKING([for ld used by $CC])

case $host in

*-*-mingw*)

# gcc leaves a trailing carriage return which upsets mingw

ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;

ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;

esac

case $ac_prog in

# Accept absolute paths.

[[\\/]]* | ?:[[\\/]]*)

re_direlt='/[[^/]][[^/]]*/\.\./'

# Canonicalize the pathname of ld

ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`

while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do

ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`

done

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

;;

"")

# If it fails, then pretend we aren't using GCC.

ac_prog=ld

;;

# ancient GNU ld didn't support --whole-archive et. al.

# If it is relative, then search for the first ld in PATH.

if $LD --help 2>&1 | egrep 'no-whole-archive' > /dev/null; then

with_gnu_ld=unknown

whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

;;

esac

elif test "$with_gnu_ld" = yes; then

AC_MSG_CHECKING([for GNU ld])

else

whole_archive_flag_spec=

AC_MSG_CHECKING([for non-GNU ld])

AC_CACHE_VAL(lt_cv_path_LD,

[if test -z "$LD"; then

lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

for ac_dir in $PATH; do

IFS="$lt_save_ifs"

test -z "$ac_dir" && ac_dir=.

if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then

lt_cv_path_LD="$ac_dir/$ac_prog"

# Check to see if the program is GNU ld. I'd rather use --version,

# but apparently some GNU ld's only accept -v.

# Break only if it was the GNU/non-GNU ld that we prefer.

case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in

*GNU* | *'with BFD'*)

test "$with_gnu_ld" != no && break

;;

test "$with_gnu_ld" != yes && break

;;

esac

done

IFS="$lt_save_ifs"

else

# PORTME fill in a description of your system's linker (not GNU ld)

lt_cv_path_LD="$LD" # Let the user override the test with a path.

case $host_os in

fi])

aix3*)

LD="$lt_cv_path_LD"

allow_undefined_flag=unsupported

if test -n "$LD"; then

always_export_symbols=yes

AC_MSG_RESULT($LD)

archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'

else

# Note: this linker hardcodes the directories in LIBPATH if there

AC_MSG_RESULT(no)

# are no directories specified by -L.

hardcode_minus_L=yes

if test "$GCC" = yes && test -z "$link_static_flag"; then

# Neither direct hardcoding nor static linking is supported with a

# broken collect2.

hardcode_direct=unsupported

;;

test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])

AC_PROG_LD_GNU

])# AC_PROG_LD

aix4* | aix5*)

if test "$host_cpu" = ia64; then

# On IA64, the linker does run time linking by default, so we don't

# have to do anything special.

aix_use_runtimelinking=no

exp_sym_flag='-Bexport'

no_entry_flag=""

else

aix_use_runtimelinking=no

# Test if we are trying to use run time linking or normal

# AC_PROG_LD_GNU

# AIX style linking. If -brtl is somewhere in LDFLAGS, we

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

# need to do runtime linking.

AC_DEFUN([AC_PROG_LD_GNU],

case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)

[AC_REQUIRE([AC_PROG_EGREP])dnl

for ld_flag in $LDFLAGS; do

AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,

case $ld_flag in

[# I'd rather use --version here, but apparently some GNU ld's only accept -v.

*-brtl*)

case `$LD -v 2>&1 </dev/null` in

aix_use_runtimelinking=yes

*GNU* | *'with BFD'*)

break

lt_cv_prog_gnu_ld=yes

;;

lt_cv_prog_gnu_ld=no

;;

esac])

with_gnu_ld=$lt_cv_prog_gnu_ld

])# AC_PROG_LD_GNU

# AC_PROG_LD_RELOAD_FLAG

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

# find reload flag for linker

# -- PORTME Some linkers may need a different reload flag.

AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],

[AC_CACHE_CHECK([for $LD option to reload object files],

lt_cv_ld_reload_flag,

[lt_cv_ld_reload_flag='-r'])

reload_flag=$lt_cv_ld_reload_flag

case $reload_flag in

"" | " "*) ;;

*) reload_flag=" $reload_flag" ;;

esac

done

reload_cmds='$LD$reload_flag -o $output$reload_objs'

esac

])# AC_PROG_LD_RELOAD_FLAG

exp_sym_flag='-bexport'

no_entry_flag='-bnoentry'

# When large executables or shared objects are built, AIX ld can

# AC_DEPLIBS_CHECK_METHOD

# have problems creating the table of contents. If linking a library

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

# or program results in "error TOC overflow" add -mminimal-toc to

# how to check for library dependencies

# CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not

# -- PORTME fill in with the dynamic library characteristics

# enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.

AC_DEFUN([AC_DEPLIBS_CHECK_METHOD],

[AC_CACHE_CHECK([how to recognise dependent libraries],

lt_cv_deplibs_check_method,

[lt_cv_file_magic_cmd='$MAGIC_CMD'

lt_cv_file_magic_test_file=

lt_cv_deplibs_check_method='unknown'

# Need to set the preceding variable on all platforms that support

# interlibrary dependencies.

# 'none' -- dependencies not supported.

# `unknown' -- same as none, but documents that we really don't know.

# 'pass_all' -- all dependencies passed with no checks.

# 'test_compile' -- check by making test program.

# 'file_magic [[regex]]' -- check by looking for files in library path

# which responds to the $file_magic_cmd with a given extended regex.

# If you have `file' or equivalent on your system and you're not sure

# whether `pass_all' will *always* work, you probably want this one.

hardcode_direct=yes

case $host_os in

archive_cmds=''

aix4* | aix5*)

hardcode_libdir_separator=':'

lt_cv_deplibs_check_method=pass_all

if test "$GCC" = yes; then

;;

case $host_os in aix4.[[012]]|aix4.[[012]].*)

collect2name=`${CC} -print-prog-name=collect2`

if test -f "$collect2name" && \

strings "$collect2name" | grep resolve_lib_name >/dev/null

then

# We have reworked collect2

hardcode_direct=yes

else

# We have old collect2

hardcode_direct=unsupported

# It fails to find uninstalled libraries when the uninstalled

# path is not listed in the libpath. Setting hardcode_minus_L

# to unsupported forces relinking

hardcode_minus_L=yes

hardcode_libdir_flag_spec='-L$libdir'

hardcode_libdir_separator=

esac

shared_flag='-shared'

beos*)

else

lt_cv_deplibs_check_method=pass_all

# not using gcc

;;

if test "$host_cpu" = ia64; then

shared_flag='${wl}-G'

else

if test "$aix_use_runtimelinking" = yes; then

shared_flag='${wl}-G'

else

shared_flag='${wl}-bM:SRE'

# It seems that -bexpall can do strange things, so it is better to

bsdi4*)

# generate a list of symbols to export.

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'

always_export_symbols=yes

lt_cv_file_magic_cmd='/usr/bin/file -L'

if test "$aix_use_runtimelinking" = yes; then

lt_cv_file_magic_test_file=/shlib/libc.so

# Warning - without using the other runtime loading flags (-brtl),

# -berok will link without error, but may produce a broken library.

allow_undefined_flag='-berok'

hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:/usr/lib:/lib'

archive_expsym_cmds="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"

else

if test "$host_cpu" = ia64; then

hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'

allow_undefined_flag="-z nodefs"

archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname ${wl}-h$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"

else

hardcode_libdir_flag_spec='${wl}-bnolibpath ${wl}-blibpath:$libdir:/usr/lib:/lib'

# Warning - without using the other run time loading flags,

# -berok will link without error, but may produce a broken library.

allow_undefined_flag='${wl}-berok'

# This is a bit strange, but is similar to how AIX traditionally builds

# it's shared libraries.

archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"' ~$AR -crlo $objdir/$libname$release.a $objdir/$soname'

;;

amigaos*)

cygwin*)

# win32_libid is a shell function defined in ltmain.sh

hardcode_libdir_flag_spec='-L$libdir'

lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'

hardcode_minus_L=yes

lt_cv_file_magic_cmd='win32_libid'

# see comment about different semantics on the GNU ld section

ld_shlibs=no

;;

cygwin* | mingw* | pw32*)

mingw* | pw32*)

# When not using gcc, we currently assume that we are using

# Base MSYS/MinGW do not provide the 'file' command needed by

# Microsoft Visual C++.

# win32_libid shell function, so use a weaker test based on 'objdump'.

# hardcode_libdir_flag_spec is actually meaningless, as there is

lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'

# no search path for DLLs.

lt_cv_file_magic_cmd='$OBJDUMP -f'

hardcode_libdir_flag_spec=' '

allow_undefined_flag=unsupported

# Tell ltmain to make .lib files, not .a files.

libext=lib

# FIXME: Setting linknames here is a bad hack.

archive_cmds='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | sed -e '\''s/ -lc$//'\''` -link -dll~linknames='

# The linker will automatically build a .lib file if we build a DLL.

old_archive_from_new_cmds='true'

# FIXME: Should let the user specify the lib program.

old_archive_cmds='lib /OUT:$oldlib$oldobjs$old_deplibs'

fix_srcfile_path='`cygpath -w "$srcfile"`'

;;

darwin* | rhapsody*)

case "$host_os" in

lt_cv_deplibs_check_method=pass_all

rhapsody* | darwin1.[[012]])

allow_undefined_flag='-undefined suppress'

;;

*) # Darwin 1.3 on

allow_undefined_flag='-flat_namespace -undefined suppress'

freebsd* | kfreebsd*-gnu)

if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then

case $host_cpu in

i*86 )

# Not sure whether the presence of OpenBSD here was a mistake.

# Let's accept both of them until this is cleared up.

lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[[3-9]]86 (compact )?demand paged shared library'

lt_cv_file_magic_cmd=/usr/bin/file

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`

;;

esac

# FIXME: Relying on posixy $() will cause problems for

else

# cross-compilation, but unfortunately the echo tests do not

lt_cv_deplibs_check_method=pass_all

# yet detect zsh echo's removal of \ escapes. Also zsh mangles

# `"' quotes if we put them in here... so don't!

archive_cmds='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs && $CC $(test .$module = .yes && echo -bundle || echo -dynamiclib) $allow_undefined_flag -o $lib ${lib}-master.o $deplibs$linker_flags $(test .$module != .yes && echo -install_name $rpath/$soname $verstring)'

# We need to add '_' to the symbols in $export_symbols first

#archive_expsym_cmds="$archive_cmds"' && strip -s $export_symbols'

hardcode_direct=yes

hardcode_shlibpath_var=no

whole_archive_flag_spec='-all_load $convenience'

;;

freebsd1*)

gnu*)

ld_shlibs=no

lt_cv_deplibs_check_method=pass_all

;;

# FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor

hpux10.20* | hpux11*)

# support. Future versions do this automatically, but an explicit c++rt0.o

lt_cv_file_magic_cmd=/usr/bin/file

# does not break anything, and helps significantly (at the cost of a little

case "$host_cpu" in

# extra space).

ia64*)

freebsd2.2*)

lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'

lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so

hardcode_libdir_flag_spec='-R$libdir'

;;

hardcode_direct=yes

hppa*64*)

hardcode_shlibpath_var=no

[lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']

lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl

;;

# Unfortunately, older versions of FreeBSD 2 do not have this feature.

lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'

freebsd2*)

lt_cv_file_magic_test_file=/usr/lib/libc.sl

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

hardcode_direct=yes

hardcode_minus_L=yes

hardcode_shlibpath_var=no

;;

esac

# FreeBSD 3 and greater uses gcc -shared to do shared libraries.

freebsd*)

archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'

hardcode_libdir_flag_spec='-R$libdir'

hardcode_direct=yes

hardcode_shlibpath_var=no

;;

hpux9* | hpux10* | hpux11*)

irix5* | irix6* | nonstopux*)

case $host_os in

case $LD in

hpux9*) archive_cmds='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' ;;

*-32|*"-32 ") libmagic=32-bit;;

*) archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' ;;

*-n32|*"-n32 ") libmagic=N32;;

*-64|*"-64 ") libmagic=64-bit;;

*) libmagic=never-match;;

esac

hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'

lt_cv_deplibs_check_method=pass_all

hardcode_libdir_separator=:

hardcode_direct=yes

hardcode_minus_L=yes # Not in the search PATH, but as the default

# location of the library.

export_dynamic_flag_spec='${wl}-E'

;;

irix5* | irix6* | nonstopux*)

# This must be Linux ELF.

if test "$GCC" = yes; then

linux*)

archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

lt_cv_deplibs_check_method=pass_all

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

else

archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

hardcode_libdir_flag_spec='-rpath $libdir'

hardcode_libdir_separator=:

link_all_deplibs=yes

;;

netbsd*)

if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out

lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'

else

archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF

lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'

hardcode_libdir_flag_spec='-R$libdir'

hardcode_direct=yes

hardcode_shlibpath_var=no

;;

newsos6)

newos6*)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'

hardcode_direct=yes

lt_cv_file_magic_cmd=/usr/bin/file

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

lt_cv_file_magic_test_file=/usr/lib/libnls.so

hardcode_libdir_separator=:

hardcode_shlibpath_var=no

;;

openbsd*)

hardcode_direct=yes

hardcode_shlibpath_var=no

if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

hardcode_libdir_flag_spec='${wl}-rpath,$libdir'

export_dynamic_flag_spec='${wl}-E'

else

case "$host_os" in

openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)

archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'

hardcode_libdir_flag_spec='-R$libdir'

;;

archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'

hardcode_libdir_flag_spec='${wl}-rpath,$libdir'

;;

esac

;;

os2*)

nto-qnx*)

hardcode_libdir_flag_spec='-L$libdir'

lt_cv_deplibs_check_method=unknown

hardcode_minus_L=yes

allow_undefined_flag=unsupported

archive_cmds='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'

old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'

;;

osf3*)

openbsd*)

if test "$GCC" = yes; then

lt_cv_file_magic_cmd=/usr/bin/file

allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`

archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'

else

allow_undefined_flag=' -expect_unresolved \*'

lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'

archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

hardcode_libdir_separator=:

;;

osf4* | osf5*) # as osf3* with the addition of -msym flag

osf3* | osf4* | osf5*)

if test "$GCC" = yes; then

lt_cv_deplibs_check_method=pass_all

allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'

archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'

hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'

else

allow_undefined_flag=' -expect_unresolved \*'

archive_cmds='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'

archive_expsym_cmds='for i in `cat $export_symbols`; do printf "-exported_symbol " >> $lib.exp; echo "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~

$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp'

#Both c and cxx compiler support -rpath directly

hardcode_libdir_flag_spec='-rpath $libdir'

hardcode_libdir_separator=:

;;

sco3.2v5*)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_deplibs_check_method=pass_all

hardcode_shlibpath_var=no

runpath_var=LD_RUN_PATH

hardcode_runpath_var=yes

export_dynamic_flag_spec='${wl}-Bexport'

;;

solaris*)

# gcc --version < 3.0 without binutils cannot create self contained

lt_cv_deplibs_check_method=pass_all

# shared libraries reliably, requiring libgcc.a to resolve some of

;;

# the object symbols generated in some cases. Libraries that use

# assert need libgcc.a to resolve __eprintf, for example. Linking

# a copy of libgcc.a into every shared library to guarantee resolving

# such symbols causes other problems: According to Tim Van Holder

# <tim.van.holder@pandora.be>, C++ libraries end up with a separate

# (to the application) exception stack for one thing.

no_undefined_flag=' -z defs'

if test "$GCC" = yes; then

case `$CC --version 2>/dev/null` in

[[12]].*)

cat <<EOF 1>&2

*** Warning: Releases of GCC earlier than version 3.0 cannot reliably

*** create self contained shared libraries on Solaris systems, without

*** introducing a dependency on libgcc.a. Therefore, libtool is disabling

*** -no-undefined support, which will at least allow you to build shared

*** libraries. However, you may find that when you link such libraries

*** into an application without using GCC, you have to manually add

*** \`gcc --print-libgcc-file-name\` to the link command. We urge you to

*** upgrade to a newer version of GCC. Another option is to rebuild your

*** current GCC to use the GNU linker from GNU binutils 2.9.1 or newer.

EOF

sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)

no_undefined_flag=

case $host_vendor in

motorola)

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'

lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`

;;

esac

ncr)

lt_cv_deplibs_check_method=pass_all

# $CC -shared without GNU ld will not create a library from C++

# object files and a static libstdc++, better avoid it by now

archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

hardcode_libdir_flag_spec='-R$libdir'

hardcode_shlibpath_var=no

case $host_os in

solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;

*) # Supported since Solaris 2.6 (maybe 2.5.1?)

whole_archive_flag_spec='-z allextract$convenience -z defaultextract' ;;

esac

link_all_deplibs=yes

;;

sequent)

sunos4*)

lt_cv_file_magic_cmd='/bin/file'

if test "x$host_vendor" = xsequent; then

lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'

# Use $CC to link under sequent, because it throws in some extra .o

# files that make .init and .fini sections work.

archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'

else

archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'

hardcode_libdir_flag_spec='-L$libdir'

hardcode_direct=yes

hardcode_minus_L=yes

hardcode_shlibpath_var=no

;;

sysv4)

case $host_vendor in

sni)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_file_magic_cmd='/bin/file'

hardcode_direct=yes # is this really true???

lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"

lt_cv_file_magic_test_file=/lib/libc.so

;;

siemens)

## LD is ld it makes a PLAMLIB

lt_cv_deplibs_check_method=pass_all

## CC just makes a GrossModule.

archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'

reload_cmds='$CC -r -o $output$reload_objs'

hardcode_direct=no

;;

motorola)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

hardcode_direct=no #Motorola manual says yes, but my tests say they lie

;;

esac

runpath_var='LD_RUN_PATH'

hardcode_shlibpath_var=no

;;

sysv4.3*)

sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*)

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

lt_cv_deplibs_check_method=pass_all

hardcode_shlibpath_var=no

export_dynamic_flag_spec='-Bexport'

;;

esac

])

file_magic_cmd=$lt_cv_file_magic_cmd

deplibs_check_method=$lt_cv_deplibs_check_method

test -z "$deplibs_check_method" && deplibs_check_method=unknown

])# AC_DEPLIBS_CHECK_METHOD

sysv5*)

no_undefined_flag=' -z text'

# $CC -shared without GNU ld will not create a library from C++

# object files and a static libstdc++, better avoid it by now

archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'

archive_expsym_cmds='$echo "{ global:" > $lib.exp~cat $export_symbols | sed -e "s/$.*$/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~

$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'

hardcode_libdir_flag_spec=

hardcode_shlibpath_var=no

runpath_var='LD_RUN_PATH'

;;

uts4*)

# AC_PROG_NM

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

# ----------

hardcode_libdir_flag_spec='-L$libdir'

# find the pathname to a BSD-compatible name lister

hardcode_shlibpath_var=no

AC_DEFUN([AC_PROG_NM],

[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,

[if test -n "$NM"; then

# Let the user override the test.

lt_cv_path_NM="$NM"

else

lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR

for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do

IFS="$lt_save_ifs"

test -z "$ac_dir" && ac_dir=.

tmp_nm="$ac_dir/${ac_tool_prefix}nm"

if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then

# Check to see if the nm accepts a BSD-compat flag.

# Adding the `sed 1q' prevents false positives on HP-UX, which says:

# nm: unknown option "B" ignored

# Tru64's nm complains that /dev/null is an invalid object file

case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in

*/dev/null* | *'Invalid file or object type'*)

lt_cv_path_NM="$tmp_nm -B"

break

;;

dgux*)

case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

*/dev/null*)

hardcode_libdir_flag_spec='-L$libdir'

lt_cv_path_NM="$tmp_nm -p"

hardcode_shlibpath_var=no

break

;;

sysv4*MP*)

lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but

if test -d /usr/nec; then

continue # so that we can try to find one that supports BSD flags

archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'

hardcode_shlibpath_var=no

runpath_var=LD_RUN_PATH

hardcode_runpath_var=yes

ld_shlibs=yes

;;

esac

done

IFS="$lt_save_ifs"

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

fi])

NM="$lt_cv_path_NM"

])# AC_PROG_NM

sysv4.2uw2*)

archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'

hardcode_direct=yes

hardcode_minus_L=no

hardcode_shlibpath_var=no

hardcode_runpath_var=yes

runpath_var=LD_RUN_PATH

;;

sysv5uw7* | unixware7*)

# AC_CHECK_LIBM

no_undefined_flag='${wl}-z ${wl}text'

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

if test "$GCC" = yes; then

# check for math library

archive_cmds='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

AC_DEFUN([AC_CHECK_LIBM],

else

[AC_REQUIRE([AC_CANONICAL_HOST])dnl

archive_cmds='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'

LIBM=

case $host in

runpath_var='LD_RUN_PATH'

*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)

hardcode_shlibpath_var=no

# These system don't have libm, or don't need it

;;

*-ncr-sysv4.3*)

AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")

AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")

;;

ld_shlibs=no

AC_CHECK_LIB(m, cos, LIBM="-lm")

;;

esac

])# AC_CHECK_LIBM

AC_MSG_RESULT([$ld_shlibs])

test "$ld_shlibs" = no && can_build_shared=no

# Check hardcoding attributes.

AC_MSG_CHECKING([how to hardcode library paths into programs])

hardcode_action=

if test -n "$hardcode_libdir_flag_spec" || \

test -n "$runpath_var"; then

# We can hardcode non-existant directories.

# AC_LIBLTDL_CONVENIENCE([DIRECTORY])

if test "$hardcode_direct" != no &&

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

# If the only mechanism to avoid hardcoding is shlibpath_var, we

# sets LIBLTDL to the link flags for the libltdl convenience library and

# have to relink, otherwise we might link with an installed library

# LTDLINCL to the include flags for the libltdl header and adds

# when we should be linking with a yet-to-be-installed one

# --enable-ltdl-convenience to the configure arguments. Note that LIBLTDL

## test "$hardcode_shlibpath_var" != no &&

# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If

test "$hardcode_minus_L" != no; then

# DIRECTORY is not provided, it is assumed to be `libltdl'. LIBLTDL will

# Linking always hardcodes the temporary library directory.

# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed with

hardcode_action=relink

# '${top_srcdir}/' (note the single quotes!). If your package is not

# flat and you're not using automake, define top_builddir and

# top_srcdir appropriately in the Makefiles.

AC_DEFUN([AC_LIBLTDL_CONVENIENCE],

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

case $enable_ltdl_convenience in

no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;

"") enable_ltdl_convenience=yes

ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;

esac

LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdlc.la

LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])

# For backwards non-gettext consistent compatibility...

INCLTDL="$LTDLINCL"

])# AC_LIBLTDL_CONVENIENCE

# AC_LIBLTDL_INSTALLABLE([DIRECTORY])

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

# sets LIBLTDL to the link flags for the libltdl installable library and

# LTDLINCL to the include flags for the libltdl header and adds

# --enable-ltdl-install to the configure arguments. Note that LIBLTDL

# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If

# DIRECTORY is not provided and an installed libltdl is not found, it is

# assumed to be `libltdl'. LIBLTDL will be prefixed with '${top_builddir}/'

# and LTDLINCL will be prefixed with '${top_srcdir}/' (note the single

# quotes!). If your package is not flat and you're not using automake,

# define top_builddir and top_srcdir appropriately in the Makefiles.

# In the future, this macro may have to be called after AC_PROG_LIBTOOL.

AC_DEFUN([AC_LIBLTDL_INSTALLABLE],

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

AC_CHECK_LIB(ltdl, lt_dlinit,

[test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],

[if test x"$enable_ltdl_install" = xno; then

AC_MSG_WARN([libltdl not installed, but installation disabled])

else

# We can link without hardcoding, and we can hardcode nonexisting dirs.

enable_ltdl_install=yes

hardcode_action=immediate

])

if test x"$enable_ltdl_install" = x"yes"; then

ac_configure_args="$ac_configure_args --enable-ltdl-install"

LIBLTDL='${top_builddir}/'ifelse($#,1,[$1],['libltdl'])/libltdl.la

LTDLINCL='-I${top_srcdir}/'ifelse($#,1,[$1],['libltdl'])

else

# We cannot hardcode anything, or else we can only hardcode existing

ac_configure_args="$ac_configure_args --enable-ltdl-install=no"

# directories.

LIBLTDL="-lltdl"

hardcode_action=unsupported

LTDLINCL=

AC_MSG_RESULT([$hardcode_action])

# For backwards non-gettext consistent compatibility...

INCLTDL="$LTDLINCL"

])# AC_LIBLTDL_INSTALLABLE

striplib=

old_striplib=

AC_MSG_CHECKING([whether stripping libraries is possible])

if test -n "$STRIP" && $STRIP -V 2>&1 | grep "GNU strip" >/dev/null; then

test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"

test -z "$striplib" && striplib="$STRIP --strip-unneeded"

AC_MSG_RESULT([yes])

else

AC_MSG_RESULT([no])

reload_cmds='$LD$reload_flag -o $output$reload_objs'

# AC_LIBTOOL_CXX

test -z "$deplibs_check_method" && deplibs_check_method=unknown

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

# enable support for C++ libraries

AC_DEFUN([AC_LIBTOOL_CXX],

[AC_REQUIRE([_LT_AC_LANG_CXX])

])# AC_LIBTOOL_CXX

# PORTME Fill in your ld.so characteristics

AC_MSG_CHECKING([dynamic linker characteristics])

library_names_spec=

libname_spec='lib$name'

soname_spec=

postinstall_cmds=

postuninstall_cmds=

finish_cmds=

finish_eval=

shlibpath_var=

shlibpath_overrides_runpath=unknown

version_type=none

dynamic_linker="$host_os ld.so"

sys_lib_dlsearch_path_spec="/lib /usr/lib"

sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"

case $host_os in

# _LT_AC_LANG_CXX

aix3*)

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

version_type=linux

AC_DEFUN([_LT_AC_LANG_CXX],

library_names_spec='${libname}${release}.so$versuffix $libname.a'

[AC_REQUIRE([AC_PROG_CXX])

shlibpath_var=LIBPATH

AC_REQUIRE([AC_PROG_CXXCPP])

_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX])

])# _LT_AC_LANG_CXX

# AIX has no versioning support, so we append a major version to the name.

soname_spec='${libname}${release}.so$major'

;;

aix4* | aix5*)

# AC_LIBTOOL_F77

version_type=linux

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

need_lib_prefix=no

# enable support for Fortran 77 libraries

need_version=no

AC_DEFUN([AC_LIBTOOL_F77],

hardcode_into_libs=yes

[AC_REQUIRE([_LT_AC_LANG_F77])

if test "$host_cpu" = ia64; then

])# AC_LIBTOOL_F77

# AIX 5 supports IA64

library_names_spec='${libname}${release}.so$major ${libname}${release}.so$versuffix $libname.so'

shlibpath_var=LD_LIBRARY_PATH

# _LT_AC_LANG_F77

else

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

# With GCC up to 2.95.x, collect2 would create an import file

AC_DEFUN([_LT_AC_LANG_F77],

# for dependence libraries. The import file would start with

[AC_REQUIRE([AC_PROG_F77])

# the line `#! .'. This would cause the generated library to

_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}F77])

# depend on `.', always an invalid library. This was fixed in

])# _LT_AC_LANG_F77

# development snapshots of GCC prior to 3.0.

# AC_LIBTOOL_GCJ

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

# enable support for GCJ libraries

AC_DEFUN([AC_LIBTOOL_GCJ],

[AC_REQUIRE([_LT_AC_LANG_GCJ])

])# AC_LIBTOOL_GCJ

# _LT_AC_LANG_GCJ

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

AC_DEFUN([_LT_AC_LANG_GCJ],

[AC_PROVIDE_IFELSE([AC_PROG_GCJ],[],

[AC_PROVIDE_IFELSE([A][M_PROG_GCJ],[],

[AC_PROVIDE_IFELSE([LT_AC_PROG_GCJ],[],

[ifdef([AC_PROG_GCJ],[AC_REQUIRE([AC_PROG_GCJ])],

[ifdef([A][M_PROG_GCJ],[AC_REQUIRE([A][M_PROG_GCJ])],

[AC_REQUIRE([A][C_PROG_GCJ_OR_A][M_PROG_GCJ])])])])])])

_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}GCJ])

])# _LT_AC_LANG_GCJ

# AC_LIBTOOL_RC

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

# enable support for Windows resource files

AC_DEFUN([AC_LIBTOOL_RC],

[AC_REQUIRE([LT_AC_PROG_RC])

_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}RC])

])# AC_LIBTOOL_RC

# AC_LIBTOOL_LANG_C_CONFIG

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

# Ensure that the configuration vars for the C compiler are

# suitably defined. Those variables are subsequently used by

# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG], [_LT_AC_LANG_C_CONFIG])

AC_DEFUN([_LT_AC_LANG_C_CONFIG],

[lt_save_CC="$CC"

AC_LANG_PUSH(C)

# Source file extension for C test sources.

ac_ext=c

# Object file extension for compiled C test sources.

objext=o

_LT_AC_TAGVAR(objext, $1)=$objext

# Code to be used in simple compile tests

lt_simple_compile_test_code="int some_variable = 0;\n"

# Code to be used in simple link tests

lt_simple_link_test_code='int main(){return(0);}\n'

_LT_AC_SYS_COMPILER

# Check for any special shared library compilation flags.

_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)=

if test "$GCC" = no; then

case $host_os in

aix4 | aix4.[[01]] | aix4.[[01]].*)

sco3.2v5*)

if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'

_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)='-belf'

echo ' yes '

echo '#endif'; } | ${CC} -E - | grep yes > /dev/null; then

else

can_build_shared=no

;;

esac

# AIX (on Power*) has no versioning support, so currently we can

# not hardcode correct soname into executable. Probably we can

if test -n "$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)"; then

# add versioning support to collect2, so additional links can

AC_MSG_WARN([`$CC' requires `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to build shared libraries])

# be useful in future.

if echo "$old_CC $old_CFLAGS " | grep "[[ ]]$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)[[ ]]" >/dev/null; then :

if test "$aix_use_runtimelinking" = yes; then

# If using run time linking (on AIX 4.2 or later) use lib<name>.so

# instead of lib<name>.a to let people know that these are not

# typical AIX shared libraries.

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

else

# We preserve .a as extension for shared libraries through AIX4.2

AC_MSG_WARN([add `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to the CC or CFLAGS env variable and reconfigure])

# and later when we are not doing run time linking.

_LT_AC_TAGVAR(lt_cv_prog_cc_can_build_shared, $1)=no

library_names_spec='${libname}${release}.a $libname.a'

soname_spec='${libname}${release}.so$major'

shlibpath_var=LIBPATH

hardcode_into_libs=yes

;;

amigaos*)

library_names_spec='$libname.ixlibrary $libname.a'

# Create ${libname}_ixlibrary.a entries in /sys/libs.

finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/$[[^/]]*$\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "(cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a)"; (cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a) || exit 1; done'

;;

beos*)

library_names_spec='${libname}.so'

# Check to make sure the static flag actually works.

dynamic_linker="$host_os ld.so"

shlibpath_var=LIBRARY_PATH

AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $_LT_AC_TAGVAR(lt_prog_compiler_static, $1) works],

;;

_LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),

$_LT_AC_TAGVAR(lt_prog_compiler_static, $1),

[],

[_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])

bsdi4*)

version_type=linux

AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)

need_version=no

AC_LIBTOOL_PROG_COMPILER_PIC($1)

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major $libname.so'

AC_LIBTOOL_PROG_CC_C_O($1)

soname_spec='${libname}${release}.so$major'

AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)

finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'

AC_LIBTOOL_PROG_LD_SHLIBS($1)

shlibpath_var=LD_LIBRARY_PATH

AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)

sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"

AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)

sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"

AC_LIBTOOL_SYS_LIB_STRIP

export_dynamic_flag_spec=-rdynamic

AC_LIBTOOL_DLOPEN_SELF($1)

# the default ld.so.conf also contains /usr/contrib/lib and

# /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow

# Report which librarie types wil actually be built

# libtool to hard-code these into programs

AC_MSG_CHECKING([if libtool supports shared libraries])

AC_MSG_RESULT([$can_build_shared])

AC_MSG_CHECKING([whether to build shared libraries])

test "$can_build_shared" = "no" && enable_shared=no

# On AIX, shared libraries and static libraries use the same namespace, and

# are all built from PIC.

case "$host_os" in

aix3*)

test "$enable_shared" = yes && enable_static=no

if test -n "$RANLIB"; then

archive_cmds="$archive_cmds~\$RANLIB \$lib"

postinstall_cmds='$RANLIB $lib'

;;

cygwin* | mingw* | pw32*)

aix4*)

version_type=windows

if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then

need_version=no

test "$enable_shared" = yes && enable_static=no

need_lib_prefix=no

case $GCC,$host_os in

;;

yes,cygwin*)

darwin* | rhapsody*)

library_names_spec='$libname.dll.a'

if test "$GCC" = yes; then

soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

postinstall_cmds='dlpath=`bash 2>&1 -c '\''. $dir/${file}i;echo \$dlname'\''`~

case "$host_os" in

dldir=$destdir/`dirname \$dlpath`~

rhapsody* | darwin1.[[012]])

test -d \$dldir || mkdir -p \$dldir~

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'

$install_prog .libs/$dlname \$dldir/$dlname'

postuninstall_cmds='dldll=`bash 2>&1 -c '\''. $file; echo \$dlname'\''`~

dlpath=$dir/\$dldll~

$rm \$dlpath'

;;

yes,mingw*)

*) # Darwin 1.3 on

library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll'

if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then

sys_lib_search_path_spec=`$CC -print-search-dirs | grep "^libraries:" | sed -e "s/^libraries://" -e "s/;/ /g" -e "s,=/,/,g"`

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'

else

case ${MACOSX_DEPLOYMENT_TARGET} in

10.[[012]])

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'

;;

yes,pw32*)

10.*)

library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | sed -e 's/[.]/-/g'`${versuffix}.dll'

_LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'

;;

esac

library_names_spec='${libname}`echo ${release} | sed -e 's/[[.]]/-/g'`${versuffix}.dll $libname.lib'

;;

esac

dynamic_linker='Win32 ld.exe'

output_verbose_link_cmd='echo'

# FIXME: first we should search . and the directory the executable is in

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring'

shlibpath_var=PATH

_LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'

# Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^$..*$,_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

_LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^$..*$,_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'

_LT_AC_TAGVAR(hardcode_direct, $1)=no

_LT_AC_TAGVAR(hardcode_automatic, $1)=yes

_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'

_LT_AC_TAGVAR(link_all_deplibs, $1)=yes

else

_LT_AC_TAGVAR(ld_shlibs, $1)=no

;;

esac

AC_MSG_RESULT([$enable_shared])

darwin* | rhapsody*)

AC_MSG_CHECKING([whether to build static libraries])

dynamic_linker="$host_os dyld"

# Make sure either enable_shared or enable_static is yes.

version_type=darwin

test "$enable_shared" = yes || enable_static=yes

need_lib_prefix=no

AC_MSG_RESULT([$enable_static])

need_version=no

# FIXME: Relying on posixy $() will cause problems for

# cross-compilation, but unfortunately the echo tests do not

# yet detect zsh echo's removal of \ escapes.

library_names_spec='${libname}${release}${versuffix}.$(test .$module = .yes && echo so || echo dylib) ${libname}${release}${major}.$(test .$module = .yes && echo so || echo dylib) ${libname}.$(test .$module = .yes && echo so || echo dylib)'

soname_spec='${libname}${release}${major}.$(test .$module = .yes && echo so || echo dylib)'

shlibpath_overrides_runpath=yes

shlibpath_var=DYLD_LIBRARY_PATH

;;

freebsd1*)

AC_LIBTOOL_CONFIG($1)

dynamic_linker=no

;;

freebsd*)

AC_LANG_POP

objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`

CC="$lt_save_CC"

version_type=freebsd-$objformat

])# AC_LIBTOOL_LANG_C_CONFIG

case $version_type in

freebsd-elf*)

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so $libname.so'

need_version=no

need_lib_prefix=no

;;

freebsd-*)

library_names_spec='${libname}${release}.so$versuffix $libname.so$versuffix'

need_version=yes

;;

esac

shlibpath_var=LD_LIBRARY_PATH

case $host_os in

freebsd2*)

shlibpath_overrides_runpath=yes

;;

shlibpath_overrides_runpath=no

hardcode_into_libs=yes

;;

esac

;;

gnu*)

version_type=linux

need_lib_prefix=no

need_version=no

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so${major} ${libname}.so'

soname_spec='${libname}${release}.so$major'

shlibpath_var=LD_LIBRARY_PATH

hardcode_into_libs=yes

;;

hpux9* | hpux10* | hpux11*)

# AC_LIBTOOL_LANG_CXX_CONFIG

# Give a soname corresponding to the major version so that dld.sl refuses to

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

# link against other versions.

# Ensure that the configuration vars for the C compiler are

dynamic_linker="$host_os dld.sl"

# suitably defined. Those variables are subsequently used by

version_type=sunos

# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.

need_lib_prefix=no

AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG], [_LT_AC_LANG_CXX_CONFIG(CXX)])

need_version=no

AC_DEFUN([_LT_AC_LANG_CXX_CONFIG],

shlibpath_var=SHLIB_PATH

[AC_LANG_PUSH(C++)

shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH

AC_REQUIRE([AC_PROG_CXX])

library_names_spec='${libname}${release}.sl$versuffix ${libname}${release}.sl$major $libname.sl'

AC_REQUIRE([AC_PROG_CXXCPP])

soname_spec='${libname}${release}.sl$major'

# HP-UX runs *really* slowly unless shared libraries are mode 555.

_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no

postinstall_cmds='chmod 555 $lib'

_LT_AC_TAGVAR(allow_undefined_flag, $1)=

;;

_LT_AC_TAGVAR(always_export_symbols, $1)=no

_LT_AC_TAGVAR(archive_expsym_cmds, $1)=

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=

_LT_AC_TAGVAR(hardcode_direct, $1)=no

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=

_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=

_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=

_LT_AC_TAGVAR(hardcode_minus_L, $1)=no

_LT_AC_TAGVAR(hardcode_automatic, $1)=no

_LT_AC_TAGVAR(module_cmds, $1)=

_LT_AC_TAGVAR(module_expsym_cmds, $1)=

_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown

_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds

_LT_AC_TAGVAR(no_undefined_flag, $1)=

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no

# Dependencies to place before and after the object being linked:

_LT_AC_TAGVAR(predep_objects, $1)=

_LT_AC_TAGVAR(postdep_objects, $1)=

_LT_AC_TAGVAR(predeps, $1)=

_LT_AC_TAGVAR(postdeps, $1)=

_LT_AC_TAGVAR(compiler_lib_search_path, $1)=

# Source file extension for C++ test sources.

ac_ext=cc

# Object file extension for compiled C++ test sources.

objext=o

_LT_AC_TAGVAR(objext, $1)=$objext

irix5* | irix6* | nonstopux*)

# Code to be used in simple compile tests

case $host_os in

lt_simple_compile_test_code="int some_variable = 0;\n"

nonstopux*) version_type=nonstopux ;;

*) version_type=irix ;;

# Code to be used in simple link tests

esac

lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n'

need_lib_prefix=no

need_version=no

# ltmain only uses $CC for tagged configurations so make sure $CC is set.

soname_spec='${libname}${release}.so$major'

_LT_AC_SYS_COMPILER

library_names_spec='${libname}${release}.so$versuffix ${libname}${release}.so$major ${libname}${release}.so $libname.so'

# Allow CC to be a program name with arguments.

lt_save_CC=$CC

lt_save_LD=$LD

lt_save_GCC=$GCC

GCC=$GXX

lt_save_with_gnu_ld=$with_gnu_ld

lt_save_path_LD=$lt_cv_path_LD

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

lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx

else

unset lt_cv_prog_gnu_ld

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

lt_cv_path_LD=$lt_cv_path_LDCXX

else

unset lt_cv_path_LD

test -z "${LDCXX+set}" || LD=$LDCXX

CC=${CXX-"c++"}

compiler=$CC

_LT_AC_TAGVAR(compiler, $1)=$CC

cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`

# We don't want -fno-exception wen compiling C++ code, so set the

# no_builtin_flag separately

if test "$GXX" = yes; then

_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'

else

_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=

if test "$GXX" = yes; then

# Set up default GNU C++ configuration

AC_PROG_LD

# Check if GNU C++ uses GNU ld as the underlying linker, since the

# archiving commands below assume that GNU ld is being used.

if test "$with_gnu_ld" = yes; then

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'

_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'

_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'

_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'

# If archive_cmds runs LD, not CC, wlarc should be empty

# XXX I think wlarc can be eliminated in ltcf-cxx, but I need to

# investigate it a little bit more. (MM)

wlarc='${wl}'

# ancient GNU ld didn't support --whole-archive et. al.

if eval "`$CC -print-prog-name=ld` --help 2>&1" | \

grep 'no-whole-archive' > /dev/null; then

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'

else

_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=

else

with_gnu_ld=no

wlarc=

# A generic and very simple default shared library creation

# command for GNU C++ for the case where it uses the native

# linker, instead of GNU ld. If possible, this setting should

# overridden to take advantage of the native linker features on

# the platform it is being used on.

_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'

# Commands to make compiler produce verbose output that lists

# what "hidden" libraries, object files and flags are used when

# linking a shared library.

output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep "\-L"'

else

GXX=no

with_gnu_ld=no

wlarc=

# PORTME: fill in a description of your system's C++ link characteristics

AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])

_LT_AC_TAGVAR(ld_shlibs, $1)=yes

case $host_os in

irix5* | nonstopux*)

aix3*)

libsuff= shlibsuff=

# FIXME: insert proper C++ library support

;;

_LT_AC_TAGVAR(ld_shlibs, $1)=no

case $LD in # libtool.m4 will add one of these switches to LD

*-32|*"-32 ") libsuff= shlibsuff= libmagic=32-bit;;

*-n32|*"-n32 ") libsuff=32 shlibsuff=N32 libmagic=N32;;

*-64|*"-64 ") libsuff=64 shlibsuff=64 libmagic=64-bit;;

*) libsuff= shlibsuff= libmagic=never-match;;

esac

;;

esac

shlibpath_var=LD_LIBRARY${shlibsuff}_PATH

shlibpath_overrides_runpath=no

sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"

sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"

;;

aix4* | aix5*)

if test "$host_cpu" = ia64; then

# On IA64, the linker does run time linking by default, so we don't

# have to do anything special.

aix_use_runtimelinking=no

exp_sym_flag='-Bexport'

no_entry_flag=""

else

aix_use_runtimelinking=no

# No shared lib support for Linux oldld, aout, or coff.

# Test if we are trying to use run time linking or normal

linux-gnuoldld* | linux-gnuaout* | linux-gnucoff*)

# AIX style linking. If -brtl is somewhere in LDFLAGS, we

dynamic_linker=no

# need to do runtime linking.

case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)

for ld_flag in $LDFLAGS; do

case $ld_flag in

*-brtl*)

aix_use_runtimelinking=yes

break

;;

esac

done

esac

# This must be Linux ELF.

exp_sym_flag='-bexport'

linux-gnu*)